[ { "path": ".gitignore", "content": "target/\n**/*.rs.bk\nCargo.lock\n\n*.dot\n*.dot.pdf\n*.core\n*.eir\n*.png\n\n!test_data/**/*.core\ntest_data/**/.*.core\n\n*.swp\n\ncompiler/src/parser/grammar.rs\n\ntrace.html\ntrace.json\n\n*.ll\n*.bc\n*.so\n*.ll.old\n*.o\n*.s\n\n!gen_nif/src/target/\n" }, { "path": ".gitmodules", "content": "[submodule \"otp\"]\n\tpath = otp\n\turl = https://github.com/erlang/otp.git\n" }, { "path": "DOCS.md", "content": "# Type system\n\nThere are two parallel type systems:\n * Pessimistic types\n * Optimistic types\n\nPessimistic types are what we can statically infer from the code itself. Using only this type system, the code would behave like it would in normal Erlang. As an example, we know that `erlang:+/2` returns a number, so this type check can be elided in code that follows it. Pessimistic types should only infer details from with the function itself.\n\nOptimistic types are informed by annotations from the user. If the user annotates that a function `foo/1` should only receive a number as an input, we can optimize the code for this case. The compiler is allowed to optionally insert type assertions for supplied optimistic type hints.\n\n## Type tree\n\nIt should be noted that everything here is under construction and subject to change. This especially applies to the pseudo-types (`mapclass`, `tupclass` and `contlist`).\n\n* `any`\n * `atom`\n * `boolean`\n * `number`\n * `integer`\n * `smallint`\n * `bigint`\n * `float`\n * `pid`\n * `reference`\n * `map`\n * `list`\n * `tuple`\n * `n-tuple`\n * `nil`\n * `mapclass`\n * `contlist`\n \n### Pseudo-types\n \n#### The `mapclass` pseudo-type\n \n`mapclass` is a special \"pseudo-type\". When the compiler infers or gets informed that a map will always adhere to a given type signature at a location, it can promote the given `map` into its pseudo-type. When these types leave the locations where their type can be inferred, they get transparently demoted into their normal types.\n\nA normal use-case for `mapclass` would be Elixirs structs.\n\nFrom the host language, these look completely identical to their non-pseudo counterparts.\n\n#### The `contlist` pseudo-type\n\n`contlist` stands for continuous list. When a `list` gets promoted into this pseudo-type, it will not be stored as a linked list, but rather as a (possibly chunked and linked?) array.\n\nNot very well thought out yet, but it is to be expected that the cache locality of storing a list in a continuous block of memory could improve performance in some cases. I have a sneaking unconfirmed suspicion that this could be especially useful in places where a list is constructed recursively and then reversed.\n\n### Type modifiers\n\n\n\n# Intrinsics\nThe module that contains all these intrinsics functions is `eir_intrinsics`. All of these functions are directly handled by the compiler. Defining a `eir_intrinsics` module could be done for compatibility with the BEAM, but it will always be overridden in this project.\n\nIt should be noted that no intrinsics are dynamically callable.\n\n## Types\n\n * `type_tag(T)`\n Returns the type tag of the type in the form of an atom.\n * `atom`\n * `float`\n * `smallint`\n * `bigint`\n \n * `annotate_type(Variable, EirTypeSpec)`\n Inserts an annotation that the given variable should be the given type spec.\n The compiler might insert assertions if it decides so, but can also choose not to.\n When annotating types, this should be used most often.\n \n The second argument is required to be known at compile-time.\n\n * `assert_type(Variable, EirTypeSpec)`\n Same as above, but the compiler is required to insert assertions.\n This can potentially result in a performance impact over `annotate_type`.\n\n The second argument is required to be known at compile-time.\n\n## Message passing\n\n### Receiving\n\nTODO: Finish updating\n\n`receive_start` the start of a receive structure, must jump to a \nblock containing a single `receive_wait`.\nNo further `receive_start` or function termination is allowed\nbefore control flow is passed through a `receive_finish` or exited\nthe structure through the timeout edge.\n\n```\n\n [eir_intrinsics:receive_start()]\n |\n v\n ----------[eir_intrinsics:receive_wait()]<--------\n v | |\n[Timeout ] | |\n[Other control flow] | |\n v |\n -----[Match logic ]---------------------\n | |\n | ----->[eir_intrinsics:receive_finish()]\n | [Other ]\n v\n [eir_intrinsics:receive_finish()]\n [Other ]\n\n```\n\n```\n #start:\n ...\n %receive_context = ReceiveStart(%timeout, #receive_loop)\n #receive_loop:\n ReceiveWait(%receive_context, #match_body, #timeout_body)\n #match_body:\n %message = ReceiveGetMessage()\n // Jump to #receive_loop if message does not match\n // Jump to #message_1_match if a message matches\n // Jump to #message_2_match if another message matches\n #timeout_body:\n ...\n #message_1_match:\n ReceiveFinish(%receive_context)\n ...\n #message_2_match:\n ReceiveFinish(%receive_context)\n ...\n```\n\nReceiveStart,\n Central node of match loop of a receive structure.\n Must be the only op in its basic block.\n Jumps to edge 0 when a message has been received.\n Jumps to edge 1 when a timeout has occured.\nReceiveWait,\n This must be the first instruction on edge 0 from ReceiveWait.\n Peeks at the message in the mailbox, not removed unless ReceiveFinish\n is passed through on this iteration\nReceiveGetMessage,\n When jumped to from edge 0 from a ReceiveWait, control flow either\n needs to (eventually) return to ReceiveWait or needs to pass\n through ReceiveFinish on its way out. Returning while inside a receive\n structure is a hard error!\n This will actually consume the message from the mailbox.\nReceiveFinish,\n" }, { "path": "LICENSE.md", "content": " Apache License\n Version 2.0, January 2004\n http://www.apache.org/licenses/\n\n TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION\n\n 1. Definitions.\n\n \"License\" shall mean the terms and conditions for use, reproduction,\n and distribution as defined by Sections 1 through 9 of this document.\n\n \"Licensor\" shall mean the copyright owner or entity authorized by\n the copyright owner that is granting the License.\n\n \"Legal Entity\" shall mean the union of the acting entity and all\n other entities that control, are controlled by, or are under common\n control with that entity. For the purposes of this definition,\n \"control\" means (i) the power, direct or indirect, to cause the\n direction or management of such entity, whether by contract or\n otherwise, or (ii) ownership of fifty percent (50%) or more of the\n outstanding shares, or (iii) beneficial ownership of such entity.\n\n \"You\" (or \"Your\") shall mean an individual or Legal Entity\n exercising permissions granted by this License.\n\n \"Source\" form shall mean the preferred form for making modifications,\n including but not limited to software source code, documentation\n source, and configuration files.\n\n \"Object\" form shall mean any form resulting from mechanical\n transformation or translation of a Source form, including but\n not limited to compiled object code, generated documentation,\n and conversions to other media types.\n\n \"Work\" shall mean the work of authorship, whether in Source or\n Object form, made available under the License, as indicated by a\n copyright notice that is included in or attached to the work\n (an example is provided in the Appendix below).\n\n \"Derivative Works\" shall mean any work, whether in Source or Object\n form, that is based on (or derived from) the Work and for which the\n editorial revisions, annotations, elaborations, or other modifications\n represent, as a whole, an original work of authorship. For the purposes\n of this License, Derivative Works shall not include works that remain\n separable from, or merely link (or bind by name) to the interfaces of,\n the Work and Derivative Works thereof.\n\n \"Contribution\" shall mean any work of authorship, including\n the original version of the Work and any modifications or additions\n to that Work or Derivative Works thereof, that is intentionally\n submitted to Licensor for inclusion in the Work by the copyright owner\n or by an individual or Legal Entity authorized to submit on behalf of\n the copyright owner. For the purposes of this definition, \"submitted\"\n means any form of electronic, verbal, or written communication sent\n to the Licensor or its representatives, including but not limited to\n communication on electronic mailing lists, source code control systems,\n and issue tracking systems that are managed by, or on behalf of, the\n Licensor for the purpose of discussing and improving the Work, but\n excluding communication that is conspicuously marked or otherwise\n designated in writing by the copyright owner as \"Not a Contribution.\"\n\n \"Contributor\" shall mean Licensor and any individual or Legal Entity\n on behalf of whom a Contribution has been received by Licensor and\n subsequently incorporated within the Work.\n\n 2. Grant of Copyright License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n copyright license to reproduce, prepare Derivative Works of,\n publicly display, publicly perform, sublicense, and distribute the\n Work and such Derivative Works in Source or Object form.\n\n 3. Grant of Patent License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n (except as stated in this section) patent license to make, have made,\n use, offer to sell, sell, import, and otherwise transfer the Work,\n where such license applies only to those patent claims licensable\n by such Contributor that are necessarily infringed by their\n Contribution(s) alone or by combination of their Contribution(s)\n with the Work to which such Contribution(s) was submitted. If You\n institute patent litigation against any entity (including a\n cross-claim or counterclaim in a lawsuit) alleging that the Work\n or a Contribution incorporated within the Work constitutes direct\n or contributory patent infringement, then any patent licenses\n granted to You under this License for that Work shall terminate\n as of the date such litigation is filed.\n\n 4. Redistribution. You may reproduce and distribute copies of the\n Work or Derivative Works thereof in any medium, with or without\n modifications, and in Source or Object form, provided that You\n meet the following conditions:\n\n (a) You must give any other recipients of the Work or\n Derivative Works a copy of this License; and\n\n (b) You must cause any modified files to carry prominent notices\n stating that You changed the files; and\n\n (c) You must retain, in the Source form of any Derivative Works\n that You distribute, all copyright, patent, trademark, and\n attribution notices from the Source form of the Work,\n excluding those notices that do not pertain to any part of\n the Derivative Works; and\n\n (d) If the Work includes a \"NOTICE\" text file as part of its\n distribution, then any Derivative Works that You distribute must\n include a readable copy of the attribution notices contained\n within such NOTICE file, excluding those notices that do not\n pertain to any part of the Derivative Works, in at least one\n of the following places: within a NOTICE text file distributed\n as part of the Derivative Works; within the Source form or\n documentation, if provided along with the Derivative Works; or,\n within a display generated by the Derivative Works, if and\n wherever such third-party notices normally appear. The contents\n of the NOTICE file are for informational purposes only and\n do not modify the License. You may add Your own attribution\n notices within Derivative Works that You distribute, alongside\n or as an addendum to the NOTICE text from the Work, provided\n that such additional attribution notices cannot be construed\n as modifying the License.\n\n You may add Your own copyright statement to Your modifications and\n may provide additional or different license terms and conditions\n for use, reproduction, or distribution of Your modifications, or\n for any such Derivative Works as a whole, provided Your use,\n reproduction, and distribution of the Work otherwise complies with\n the conditions stated in this License.\n\n 5. Submission of Contributions. Unless You explicitly state otherwise,\n any Contribution intentionally submitted for inclusion in the Work\n by You to the Licensor shall be under the terms and conditions of\n this License, without any additional terms or conditions.\n Notwithstanding the above, nothing herein shall supersede or modify\n the terms of any separate license agreement you may have executed\n with Licensor regarding such Contributions.\n\n 6. Trademarks. This License does not grant permission to use the trade\n names, trademarks, service marks, or product names of the Licensor,\n except as required for reasonable and customary use in describing the\n origin of the Work and reproducing the content of the NOTICE file.\n\n 7. Disclaimer of Warranty. Unless required by applicable law or\n agreed to in writing, Licensor provides the Work (and each\n Contributor provides its Contributions) on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or\n implied, including, without limitation, any warranties or conditions\n of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A\n PARTICULAR PURPOSE. You are solely responsible for determining the\n appropriateness of using or redistributing the Work and assume any\n risks associated with Your exercise of permissions under this License.\n\n 8. Limitation of Liability. In no event and under no legal theory,\n whether in tort (including negligence), contract, or otherwise,\n unless required by applicable law (such as deliberate and grossly\n negligent acts) or agreed to in writing, shall any Contributor be\n liable to You for damages, including any direct, indirect, special,\n incidental, or consequential damages of any character arising as a\n result of this License or out of the use or inability to use the\n Work (including but not limited to damages for loss of goodwill,\n work stoppage, computer failure or malfunction, or any and all\n other commercial damages or losses), even if such Contributor\n has been advised of the possibility of such damages.\n\n 9. Accepting Warranty or Additional Liability. While redistributing\n the Work or Derivative Works thereof, You may choose to offer,\n and charge a fee for, acceptance of support, warranty, indemnity,\n or other liability obligations and/or rights consistent with this\n License. However, in accepting such obligations, You may act only\n on Your own behalf and on Your sole responsibility, not on behalf\n of any other Contributor, and only if You agree to indemnify,\n defend, and hold each Contributor harmless for any liability\n incurred by, or claims asserted against, such Contributor by reason\n of your accepting any such warranty or additional liability.\n\n END OF TERMS AND CONDITIONS\n\n APPENDIX: How to apply the Apache License to your work.\n\n To apply the Apache License to your work, attach the following\n boilerplate notice, with the fields enclosed by brackets \"{}\"\n replaced with your own identifying information. (Don't include\n the brackets!) The text should be enclosed in the appropriate\n comment syntax for the file format. We also recommend that a\n file or class name and description of purpose be included on the\n same \"printed page\" as the copyright notice for easier\n identification within third-party archives.\n\n Copyright 2018 Paul Schoenfelder\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n" }, { "path": "README.md", "content": "# Eir Project\nErlang compiler and IR implemented in Rust\n\n## Details\n\nCurrent features:\n* Unified Thorin based IR representation named Eir\n* Erlang frontend\n* Core frontend\n* Pattern match compilation passes\n* Basic optimization and cleanup passes\n* Naive interpreter used for testing\n\nThe project is split into several crates:\n* `libeir_ir` - Contains the core Eir IR data structures, validation, printing\n* `libeir_syntax_erl` - Frontend for Erlang, lowers to Eir.\n* `libeir_syntax_core` - Frontend for Core Erlang, lowers to Eir.\n* `libeir_passes` - Compiler passes operating on Eir.\n* `libeir_lowerutils` - Utilities for lowering Eir to SSA form.\n* `libeir_interpreter` - Naive interpreter for Eir. Used to run OTP test suites.\n* `libeir_intern` - Symbol interning. Used by most other crates.\n* `libeir_diagnostics` - Source span handling and diagnostics printing.\n* `libeir_util` - Kitchen sink of utilities used by other crates.\n* `pattern-compiler` - A generic pattern matching tree compiler.\n* `tools` - CLI tools used to work with the IR.\n" }, { "path": "ROADMAP.org", "content": "* Roadmap\n** 1. Cleanup\n*** Includes fixing all tech dept created leading up to the conference\n*** Setting up infrastructure for writing integration tests using the interpreter\n**** Ease work for Luke, Paul, improve confidence in high levels of compiler and the runtime\n** 2. Basic passes\n*** Unified cleanup pass\n**** Includes removal of call chains, tail call promotion, closure inlining in one pass.\n*** Simple branch elimination pass\n**** Removes superfluous branches\n** 3. Lower utilities\n*** Introduce a barebones more traditional IR (LIR)\n**** No passes operate on this (at least for now), eases lowering to other IRs\n** 4. Documentation\n*** Write gitbook-like documentation for EIR\n**** Critical for enabling others to work with the project efficiently\n** 5. BEAM assembly target\n*** Target BEAM assembly from LIR\n**** Enables more easy testing of compiler\n**** Comparing our optimization passes with the BEAM compiler\n***** Proves our approach of using a Thorin-like IR is beneficial\n** 6. Typing infrastructure\n*** This is critical for doing good native codegen\n\n" }, { "path": "azure-pipelines.yml", "content": "variables:\n nightly: nightly-2020-08-15\n RUSTFLAGS:\n\njobs:\n\n # Test crates\n - template: ci/azure-test.yml\n parameters:\n name: test_eir\n displayName: Test Eir\n rust: $(nightly)\n cross: true\n crates:\n util/libeir_util_binary: []\n util/libeir_util_datastructures: []\n util/libeir_util_number: []\n util/libeir_util_parse: []\n util/libeir_util_parse_listing: []\n util/libeir_util_pattern_compiler: []\n libeir_intern: []\n libeir_diagnostics: []\n libeir_interpreter: []\n libeir_ir: []\n libeir_passes: []\n libeir_lowerutils: []\n libeir_syntax_erl: []\n libeir_tests: []\n" }, { "path": "ci/azure-clone-patch-otp.yml", "content": "steps:\n - script: |\n set -e\n cd $(Build.SourcesDirectory)\n git submodule update --init --recursive\n cd otp_build\n bash patch_tests.sh\n displayName: Clone and patch OTP\n" }, { "path": "ci/azure-install-dependencies.yml", "content": "steps:\n\n # Windows only: Install m4\n #- script: |\n # choco install msys2\n # refreshenv\n # pacman -S --noconfirm m4\n # displayName: Install dependencies (windows)\n # condition: eq(variables['Agent.OS'], 'Windows_NT')\n" }, { "path": "ci/azure-install-rust.yml", "content": "steps:\n # Linux and macOS.\n - script: |\n set -e\n curl https://sh.rustup.rs -sSf | sh -s -- -y --default-toolchain none\n export PATH=$PATH:$HOME/.cargo/bin\n rustup toolchain install $RUSTUP_TOOLCHAIN\n rustup default $RUSTUP_TOOLCHAIN\n echo \"##vso[task.setvariable variable=PATH;]$PATH:$HOME/.cargo/bin\"\n env:\n RUSTUP_TOOLCHAIN: ${{parameters.rust_version}}\n displayName: \"Install rust (*nix)\"\n condition: not(eq(variables['Agent.OS'], 'Windows_NT'))\n # Windows.\n - script: |\n curl -sSf -o rustup-init.exe https://win.rustup.rs\n rustup-init.exe -y --default-toolchain none\n set PATH=%PATH%;%USERPROFILE%\\.cargo\\bin\n rustup toolchain install %RUSTUP_TOOLCHAIN%\n rustup default %RUSTUP_TOOLCHAIN%\n echo \"##vso[task.setvariable variable=PATH;]%PATH%;%USERPROFILE%\\.cargo\\bin\"\n env:\n RUSTUP_TOOLCHAIN: ${{parameters.rust_version}}-gnu\n displayName: \"Install rust (windows)\"\n condition: eq(variables['Agent.OS'], 'Windows_NT')\n\n # All platforms.\n # Add components\n - ${{ each component in parameters.components }}:\n - script: rustup component add ${{ component }}\n displayName: \"Add rust component: ${{ component }}\"\n\n # Print versions\n - script: |\n rustup toolchain list\n rustc -Vv\n cargo -V\n displayName: Query rust and cargo versions\n" }, { "path": "ci/azure-test.yml", "content": "jobs:\n - job: ${{ parameters.name }}\n displayName: ${{ parameters.displayName }}\n strategy:\n matrix:\n Linux:\n vmImage: ubuntu-16.04\n\n ${{ if parameters.cross }}:\n MacOs:\n vmImage: macOS-10.13\n Windows:\n vmImage: vs2017-win2016\n pool:\n vmImage: $(vmImage)\n\n steps:\n - template: azure-install-rust.yml\n parameters:\n rust_version: ${{ parameters.rust }}\n\n# - template: azure-install-dependencies.yml\n\n - template: azure-clone-patch-otp.yml\n\n - script: cargo build --tests\n env:\n CI: 'True'\n displayName: cargo build --tests\n\n - ${{ each crate in parameters.crates }}:\n - script: cargo test\n env:\n CI: 'True'\n displayName: ${{ crate.key }} - cargo test\n workingDirectory: $(Build.SourcesDirectory)/${{ crate.key }}\n" }, { "path": "deny.toml", "content": "[licenses]\n# This section is considered when running `cargo deny check license`\n# More documentation for the licenses section can be found here:\n# https://github.com/EmbarkStudios/cargo-deny#the-licenses-section\n\n# Uncomment the following line to change the lint level for unlicensed crates\n# [possible values: \"deny\", \"allow\" or \"warn\"].\n#unlicensed = \"deny\"\n\n# Uncomment the following line to explictly allow certain licenses\n# See https://spdx.org/licenses/ for list of possible licenses\n# [possible values: any SPDX 3.7 short identifier (+ optional exception)].\nallow = [\"MIT\", \"Apache-2.0\", \"Apache-2.0 WITH LLVM-exception\", \"ISC\", \"BSD-3-Clause\", \"BSD-2-Clause\", \"CC0-1.0\"]\n\n# Uncomment the following line to explictly disallow certain licenses\n# See https://spdx.org/licenses/ for list of possible licenses\n# [possible values: any SPDX 3.7 short identifier (+ optional exception)].\n#deny = []\n\n# Uncomment the following line to change the lint level for licenses considered copyleft\n# [possible values: \"deny\", \"allow\" or \"warn\"].\n#copyleft = \"warn\"\n\n# Uncomment the following line to approve or deny OSI-approved or FSF Free/Libre licenses\n# [possible values: \"both\", \"either\", \"osi-only\", \"fsf-only\" or \"neither\"].\n#allow-osi-fsf-free = \"neither\"\n\n# Uncomment the following line to change the confidence threshold. The higher the value,\n# the more closely the license text must be to the canonical license text of a valid \n# SPDX license file.\n# [possible values: any between 0.0 and 1.0].\n#confidence-threshold = 0.8\n\n[bans]\n# This section is considered when running `cargo deny check ban`.\n# More documentation about the 'bans' section can be found here:\n# https://github.com/EmbarkStudios/cargo-deny#crate-bans-cargo-deny-check-ban\n\n# Uncomment the following line to change what happens when multiple versions of the same \n# crate are encountered\n# [possible values: \"deny\", \"warn\" or \"allow\"].\n#multiple-versions = \"warn\"\n\n# Uncomment the following line to change the highlighting variant used to multiple versions \n# of the same crate when creating a dotgraph of your crates dependencies\n# [possible values: \"lowest-version\", \"simplest-path\" or \"all\"].\n#highlight = \"all\"\n\n# Uncomment the following line to allow specific crates.\n#allow = []\n\n# Uncomment the following line to deny specific crates.\n#deny = []\n\n# Uncomment the following line to skip specific crates.\n#skip = []\n\n# Uncomment the following line to skip specific crates (including different versions of the \n# same crate down the dependency tree). By default, the depth is infinite, but you can also\n# specify `depth = ` to limit it.\n#skip-tree = []\n" }, { "path": "libeir_diagnostics/Cargo.toml", "content": "[package]\nname = \"libeir_diagnostics\"\nversion = \"0.1.0\"\nauthors = [\"Paul Schoenfelder \", \"Luke Imhoff \"]\nedition = \"2018\"\nlicense = \"MIT OR Apache-2.0\"\n\n[dependencies]\nanyhow = \"1.0\"\nthiserror = \"1.0\"\nitertools = \"0.8\"\nunicode-width = \"0.1\"\ncodespan = \"0.9\"\ncodespan-reporting = \"0.9\"\ndashmap = \"3.11\"\n\n[dev-dependencies]\npretty_assertions = \"0.5\"\n" }, { "path": "libeir_diagnostics/src/codemap.rs", "content": "use std::ops::Range;\nuse std::path::PathBuf;\nuse std::sync::atomic::{AtomicU32, Ordering};\nuse std::sync::Arc;\n\nuse dashmap::DashMap;\n\nuse super::*;\n\n#[derive(Debug)]\npub struct CodeMap {\n files: DashMap>,\n names: DashMap,\n seen: DashMap,\n next_file_id: AtomicU32,\n}\nimpl CodeMap {\n /// Creates an empty `CodeMap`.\n pub fn new() -> Self {\n Self {\n files: DashMap::new(),\n names: DashMap::new(),\n seen: DashMap::new(),\n next_file_id: AtomicU32::new(1),\n }\n }\n\n /// Add a file to the map, returning the handle that can be used to\n /// refer to it again.\n pub fn add(&self, name: impl Into, source: String) -> SourceId {\n // De-duplicate real files on add; it _may_ be possible for concurrent\n // adds to add the same file more than once, since we're working across\n // two maps; but since DashMap uses read/write locks internally to lock\n // buckets, the sequence of locks required here should prevent that from\n // happening\n //\n // We don't de-duplicate virtual files, because the same name could be used\n // for different content, and its unlikely that we'd be adding the same content\n // over and over again with the same virtual file name\n let name = name.into();\n if let FileName::Real(ref path) = name {\n let seen_ref = self\n .seen\n .entry(path.clone())\n .or_insert_with(|| self.insert_file(name, source, None));\n *seen_ref.value()\n } else {\n self.insert_file(name, source, None)\n }\n }\n\n /// Add a file to the map with the given source span as a parent.\n /// This will not deduplicate the file in the map.\n pub fn add_child(\n &self,\n name: impl Into,\n source: String,\n parent: SourceSpan,\n ) -> SourceId {\n self.insert_file(name.into(), source, Some(parent))\n }\n\n fn insert_file(&self, name: FileName, source: String, parent: Option) -> SourceId {\n let file_id = self.next_file_id();\n let filename = name.clone();\n self.files.insert(\n file_id,\n Arc::new(SourceFile::new(file_id, name.into(), source, parent)),\n );\n self.names.insert(filename, file_id);\n file_id\n }\n\n /// Get the file corresponding to the given id.\n pub fn get(&self, file_id: SourceId) -> Option> {\n if file_id == SourceId::UNKNOWN {\n None\n } else {\n self.files.get(&file_id).map(|r| r.value().clone())\n }\n }\n\n pub fn parent(&self, file_id: SourceId) -> Option {\n self.get(file_id).and_then(|f| f.parent())\n }\n\n /// Get the file id corresponding to the given FileName\n pub fn get_file_id(&self, filename: &FileName) -> Option {\n self.names.get(filename).map(|id| *id)\n }\n\n /// Get the file corresponding to the given FileName\n pub fn get_by_name(&self, filename: &FileName) -> Option> {\n self.get_file_id(filename).and_then(|id| self.get(id))\n }\n\n pub fn name(&self, file_id: SourceId) -> Option {\n self.get(file_id).map(|f| f.name().clone())\n }\n\n pub fn iter<'a>(&'a self) -> impl Iterator> + 'a {\n self.files.iter().map(|r| r.value().clone())\n }\n\n pub fn line_span(\n &self,\n file_id: SourceId,\n line_index: impl Into,\n ) -> Option> {\n let f = self.get(file_id)?;\n Some(f.line_span(line_index.into()))\n }\n\n pub fn line_index(\n &self,\n file_id: SourceId,\n byte_index: impl Into,\n ) -> Option {\n let f = self.get(file_id)?;\n Some(f.line_index(byte_index.into()))\n }\n\n pub fn location(\n &self,\n file_id: SourceId,\n byte_index: impl Into,\n ) -> Option> {\n let f = self.get(file_id)?;\n Some(f.location(byte_index.into()))\n }\n\n pub fn source_span(&self, file_id: SourceId) -> Option {\n let f = self.get(file_id)?;\n Some(f.source_span())\n }\n\n pub fn source_slice<'a>(\n &'a self,\n file_id: SourceId,\n span: impl Into,\n ) -> Option> {\n let f = self.get(file_id)?;\n match f.source_slice(span.into()) {\n Err(err) => Some(Err(err)),\n Ok(slice) => unsafe { Some(Ok(std::mem::transmute::<&str, &'a str>(slice))) },\n }\n }\n\n #[inline(always)]\n fn next_file_id(&self) -> SourceId {\n let id = self.next_file_id.fetch_add(1, Ordering::Relaxed);\n SourceId::new(id)\n }\n}\nimpl Default for CodeMap {\n fn default() -> Self {\n Self::new()\n }\n}\nimpl<'a> Files<'a> for CodeMap {\n type FileId = SourceId;\n type Name = String;\n type Source = &'a str;\n\n fn name(&self, file_id: Self::FileId) -> Option {\n Some(format!(\"{}\", self.get(file_id)?.name()))\n }\n\n fn source(&self, file_id: Self::FileId) -> Option<&'a str> {\n use std::mem;\n\n let f = self.get(file_id)?;\n Some(unsafe { mem::transmute::<&str, &'a str>(f.source()) })\n }\n\n fn line_index(&self, file_id: Self::FileId, byte_index: usize) -> Option {\n Some(self.line_index(file_id, byte_index as u32)?.to_usize())\n }\n\n fn line_range(&self, file_id: Self::FileId, line_index: usize) -> Option> {\n let span = self.line_span(file_id, line_index as u32)?.ok()?;\n\n Some(span.start().to_usize()..span.end().to_usize())\n }\n}\n" }, { "path": "libeir_diagnostics/src/filename.rs", "content": "//! Various source mapping utilities\n\nuse std::borrow::Cow;\nuse std::fmt;\nuse std::path::{Path, PathBuf};\n\n#[derive(Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]\npub enum FileName {\n /// A real file on disk\n Real(PathBuf),\n /// A synthetic file, eg. from the REPL\n Virtual(Cow<'static, str>),\n}\n\nimpl From for FileName {\n fn from(name: PathBuf) -> FileName {\n FileName::real(name)\n }\n}\n\nimpl From for PathBuf {\n fn from(name: FileName) -> PathBuf {\n match name {\n FileName::Real(path) => path,\n FileName::Virtual(Cow::Owned(owned)) => PathBuf::from(owned),\n FileName::Virtual(Cow::Borrowed(borrowed)) => PathBuf::from(borrowed),\n }\n }\n}\n\nimpl<'a> From<&'a FileName> for &'a Path {\n fn from(name: &'a FileName) -> &'a Path {\n match *name {\n FileName::Real(ref path) => path,\n FileName::Virtual(ref cow) => Path::new(cow.as_ref()),\n }\n }\n}\n\nimpl<'a> From<&'a Path> for FileName {\n fn from(name: &Path) -> FileName {\n FileName::real(name)\n }\n}\n\nimpl From for FileName {\n fn from(name: String) -> FileName {\n FileName::virtual_(name)\n }\n}\n\nimpl From<&'static str> for FileName {\n fn from(name: &'static str) -> FileName {\n FileName::virtual_(name)\n }\n}\n\nimpl AsRef for FileName {\n fn as_ref(&self) -> &Path {\n match *self {\n FileName::Real(ref path) => path.as_ref(),\n FileName::Virtual(ref cow) => Path::new(cow.as_ref()),\n }\n }\n}\n\nimpl PartialEq for FileName {\n fn eq(&self, other: &Path) -> bool {\n self.as_ref() == other\n }\n}\n\nimpl PartialEq for FileName {\n fn eq(&self, other: &PathBuf) -> bool {\n self.as_ref() == other.as_path()\n }\n}\n\nimpl FileName {\n pub fn real>(name: T) -> FileName {\n FileName::Real(name.into())\n }\n\n pub fn virtual_>>(name: T) -> FileName {\n FileName::Virtual(name.into())\n }\n\n pub fn to_string(&self) -> String {\n match *self {\n FileName::Real(ref path) => match path.to_str() {\n None => path.to_string_lossy().into_owned(),\n Some(s) => s.to_owned(),\n },\n FileName::Virtual(ref s) => s.clone().into_owned(),\n }\n }\n}\n\nimpl fmt::Display for FileName {\n fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {\n match *self {\n FileName::Real(ref path) => write!(fmt, \"{}\", path.display()),\n FileName::Virtual(ref name) => write!(fmt, \"<{}>\", name),\n }\n }\n}\n" }, { "path": "libeir_diagnostics/src/index.rs", "content": "use std::num::NonZeroUsize;\nuse std::ops::{Add, AddAssign, Sub, SubAssign};\n\nuse codespan::{ByteIndex, ByteOffset, RawIndex, RawOffset};\n\nuse super::SourceId;\n\n#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]\npub struct SourceIndex(NonZeroUsize);\nimpl SourceIndex {\n const INDEX_MASK: usize = u32::max_value() as usize;\n\n const UNKNOWN_SRC_ID: usize = (SourceId::UNKNOWN_SOURCE_ID as usize) << 32;\n\n pub const UNKNOWN: Self = Self(unsafe { NonZeroUsize::new_unchecked(Self::UNKNOWN_SRC_ID) });\n\n #[inline]\n pub fn new(source: SourceId, index: ByteIndex) -> Self {\n let source = (source.get() as usize) << 32;\n\n Self(NonZeroUsize::new(source | index.0 as usize).unwrap())\n }\n\n #[inline]\n pub fn source_id(&self) -> SourceId {\n let source_id_part = (self.0.get() >> 32) as u32;\n if source_id_part == SourceId::UNKNOWN_SOURCE_ID {\n SourceId::UNKNOWN\n } else {\n SourceId::new(source_id_part)\n }\n }\n\n #[inline]\n pub fn index(&self) -> ByteIndex {\n ByteIndex((self.0.get() & Self::INDEX_MASK) as u32)\n }\n\n pub fn to_usize(&self) -> usize {\n self.0.get()\n }\n}\nimpl Default for SourceIndex {\n fn default() -> Self {\n Self::UNKNOWN\n }\n}\n\nimpl Add for SourceIndex {\n type Output = SourceIndex;\n\n #[inline]\n fn add(self, rhs: usize) -> Self {\n if self == Self::UNKNOWN {\n return Self::UNKNOWN;\n }\n let source = self.source_id();\n let index = self.index();\n let new_index = index.0 as RawOffset + rhs as RawOffset;\n Self::new(source, ByteIndex(new_index as RawIndex))\n }\n}\n\nimpl Add for SourceIndex {\n type Output = SourceIndex;\n\n #[inline]\n fn add(self, rhs: ByteOffset) -> Self {\n if self == Self::UNKNOWN {\n return Self::UNKNOWN;\n }\n let source = self.source_id();\n let index = self.index();\n let new_index = ByteIndex(index.0) + rhs;\n Self::new(source, new_index)\n }\n}\n\nimpl AddAssign for SourceIndex {\n #[inline]\n fn add_assign(&mut self, rhs: usize) {\n *self = *self + rhs;\n }\n}\n\nimpl AddAssign for SourceIndex {\n #[inline]\n fn add_assign(&mut self, rhs: ByteOffset) {\n *self = *self + rhs;\n }\n}\n\nimpl Sub for SourceIndex {\n type Output = SourceIndex;\n\n #[inline]\n fn sub(self, rhs: usize) -> Self {\n if self == Self::UNKNOWN {\n return Self::UNKNOWN;\n }\n let source = self.source_id();\n let index = self.index();\n let new_index = index.0 as RawOffset - rhs as RawOffset;\n Self::new(source, ByteIndex(new_index as RawIndex))\n }\n}\n\nimpl SubAssign for SourceIndex {\n #[inline]\n fn sub_assign(&mut self, rhs: usize) {\n *self = *self - rhs;\n }\n}\n" }, { "path": "libeir_diagnostics/src/lib.rs", "content": "#![feature(crate_visibility_modifier)]\n\nmod codemap;\nmod filename;\nmod index;\nmod source;\nmod span;\n\npub use codespan::{ByteIndex, ByteOffset};\npub use codespan::{ColumnIndex, ColumnNumber, ColumnOffset};\npub use codespan::{Index, Offset};\npub use codespan::{LineIndex, LineNumber, LineOffset};\npub use codespan::{LineIndexOutOfBoundsError, LocationError, SpanOutOfBoundsError};\npub use codespan::{Location, Span};\npub use codespan::{RawIndex, RawOffset};\n\npub use codespan_reporting::diagnostic::{LabelStyle, Severity};\npub use codespan_reporting::files::Files;\npub use codespan_reporting::term;\n\npub use self::codemap::CodeMap;\npub use self::filename::FileName;\npub use self::index::SourceIndex;\npub use self::source::{SourceFile, SourceId};\npub use self::span::SourceSpan;\n\npub type Diagnostic = codespan_reporting::diagnostic::Diagnostic;\npub type Label = codespan_reporting::diagnostic::Label;\n\npub trait ToDiagnostic {\n fn to_diagnostic(&self) -> Diagnostic;\n}\n" }, { "path": "libeir_diagnostics/src/source.rs", "content": "use std::convert::Into;\nuse std::num::NonZeroU32;\nuse std::ops::Range;\n\nuse super::*;\n\n/// A handle that points to a file in the database.\n#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]\npub struct SourceId(crate NonZeroU32);\nimpl SourceId {\n crate const UNKNOWN_SOURCE_ID: u32 = u32::max_value();\n\n pub const UNKNOWN: Self = Self(unsafe { NonZeroU32::new_unchecked(Self::UNKNOWN_SOURCE_ID) });\n\n crate fn new(index: u32) -> Self {\n assert!(index > 0);\n assert!(index < Self::UNKNOWN_SOURCE_ID);\n Self(NonZeroU32::new(index).unwrap())\n }\n\n #[inline]\n crate fn get(self) -> u32 {\n self.0.get()\n }\n}\n\n/// The representation of a source file in the database.\n#[derive(Debug, Clone)]\npub struct SourceFile {\n id: SourceId,\n name: FileName,\n source: String,\n line_starts: Vec,\n parent: Option,\n}\nimpl SourceFile {\n crate fn new(id: SourceId, name: FileName, source: String, parent: Option) -> Self {\n let line_starts = codespan_reporting::files::line_starts(source.as_str())\n .map(|i| ByteIndex::from(i as u32))\n .collect();\n\n Self {\n id,\n name,\n source,\n line_starts,\n parent,\n }\n }\n\n pub fn name(&self) -> &FileName {\n &self.name\n }\n\n pub fn id(&self) -> SourceId {\n self.id\n }\n\n pub fn parent(&self) -> Option {\n self.parent\n }\n\n pub fn line_start(\n &self,\n line_index: LineIndex,\n ) -> Result {\n use std::cmp::Ordering;\n\n match line_index.cmp(&self.last_line_index()) {\n Ordering::Less => Ok(self.line_starts[line_index.to_usize()]),\n Ordering::Equal => Ok(self.source_span().end_index()),\n Ordering::Greater => Err(LineIndexOutOfBoundsError {\n given: line_index,\n max: self.last_line_index(),\n }),\n }\n }\n\n pub fn last_line_index(&self) -> LineIndex {\n LineIndex::from(self.line_starts.len() as RawIndex)\n }\n\n pub fn line_span(&self, line_index: LineIndex) -> Result {\n let line_start = self.line_start(line_index)?;\n let next_line_start = self.line_start(line_index + LineOffset::from(1))?;\n\n Ok(Span::new(line_start, next_line_start))\n }\n\n pub fn line_index(&self, byte_index: ByteIndex) -> LineIndex {\n match self.line_starts.binary_search(&byte_index) {\n // Found the start of a line\n Ok(line) => LineIndex::from(line as u32),\n Err(next_line) => LineIndex::from(next_line as u32 - 1),\n }\n }\n\n pub fn location(&self, byte_index: ByteIndex) -> Result {\n let line_index = self.line_index(byte_index);\n let line_start_index =\n self.line_start(line_index)\n .map_err(|_| LocationError::OutOfBounds {\n given: byte_index,\n span: self.source_span().as_span(),\n })?;\n let line_src = self\n .source\n .as_str()\n .get(line_start_index.to_usize()..byte_index.to_usize())\n .ok_or_else(|| {\n let given = byte_index;\n if given >= self.source_span().end_index() {\n let span = self.source_span();\n LocationError::OutOfBounds {\n given,\n span: span.as_span(),\n }\n } else {\n LocationError::InvalidCharBoundary { given }\n }\n })?;\n\n Ok(Location {\n line: line_index,\n column: ColumnIndex::from(line_src.chars().count() as u32),\n })\n }\n\n #[inline(always)]\n pub fn source(&self) -> &str {\n self.source.as_str()\n }\n\n pub fn source_span(&self) -> SourceSpan {\n SourceSpan {\n source_id: self.id,\n start: ByteIndex(0),\n end: ByteIndex(self.source.len() as u32),\n }\n }\n\n pub fn source_slice(\n &self,\n span: impl Into>,\n ) -> Result<&str, SpanOutOfBoundsError> {\n let span = span.into();\n let start = span.start;\n let end = span.end;\n\n self.source().get(start..end).ok_or_else(|| {\n let given = Span::new(start as u32, end as u32);\n let span = Span::from_str(self.source());\n SpanOutOfBoundsError { given, span }\n })\n }\n}\n" }, { "path": "libeir_diagnostics/src/span.rs", "content": "use std::ops::Range;\n\nuse codespan::{ByteIndex, ByteOffset, Span};\n\nuse super::{CodeMap, SourceId, SourceIndex};\n\n#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]\npub struct SourceSpan {\n crate source_id: SourceId,\n crate start: ByteIndex,\n crate end: ByteIndex,\n}\nimpl SourceSpan {\n pub const UNKNOWN: Self = Self {\n source_id: SourceId::UNKNOWN,\n start: ByteIndex(0),\n end: ByteIndex(0),\n };\n\n #[inline]\n pub fn new(start: SourceIndex, end: SourceIndex) -> Self {\n let source_id = start.source_id();\n assert_eq!(\n source_id,\n end.source_id(),\n \"source spans cannot start and end in different files!\"\n );\n let start = start.index();\n let end = end.index();\n\n Self {\n source_id,\n start,\n end,\n }\n }\n\n pub fn new_align(\n start: SourceIndex,\n end: SourceIndex,\n get_codemap: &dyn Fn(&mut dyn FnOnce(&CodeMap)),\n ) -> SourceSpan {\n let start_source = start.source_id();\n let end_source = end.source_id();\n\n if start_source == end_source {\n Self::new(start, end)\n } else {\n let mut result = None;\n get_codemap(&mut |codemap: &CodeMap| {\n let mut idx = start_source;\n loop {\n if let Some(parent) = codemap.parent(idx) {\n if idx == end_source {\n result = Some(Self::new(parent.start(), end));\n return;\n }\n idx = parent.source_id();\n } else {\n break;\n }\n }\n\n let mut idx = end_source;\n loop {\n if let Some(parent) = codemap.parent(idx) {\n if idx == start_source {\n result = Some(Self::new(start, parent.end()));\n return;\n }\n idx = parent.source_id();\n } else {\n break;\n }\n }\n });\n result.expect(\"source spans cannot be aligned!\")\n }\n }\n\n #[inline(always)]\n pub fn source_id(&self) -> SourceId {\n self.source_id\n }\n\n #[inline(always)]\n pub fn start(&self) -> SourceIndex {\n SourceIndex::new(self.source_id, self.start)\n }\n\n #[inline(always)]\n pub fn start_index(&self) -> ByteIndex {\n self.start\n }\n\n pub fn shrink_front(mut self, offset: ByteOffset) -> Self {\n self.start += offset;\n self\n }\n\n #[inline(always)]\n pub fn end(&self) -> SourceIndex {\n SourceIndex::new(self.source_id, self.end)\n }\n\n #[inline(always)]\n pub fn end_index(&self) -> ByteIndex {\n self.end\n }\n\n pub fn as_span(&self) -> Span {\n Span::new(self.start, self.end)\n }\n}\n\nimpl From for Range {\n fn from(span: SourceSpan) -> Range {\n span.start.into()..span.end.into()\n }\n}\n\nimpl From for Range {\n fn from(span: SourceSpan) -> Range {\n let start = SourceIndex::new(span.source_id, span.start);\n let end = SourceIndex::new(span.source_id, span.end);\n start..end\n }\n}\n" }, { "path": "libeir_frontend/Cargo.toml", "content": "[package]\nname = \"libeir_frontend\"\nversion = \"0.1.0\"\nauthors = [\"Hans Elias B. Josephsen \"]\nedition = \"2018\"\nlicense = \"MIT OR Apache-2.0\"\n\n[dependencies]\nlibeir_ir = { path = \"../libeir_ir\" }\nlibeir_syntax_erl = { path = \"../libeir_syntax_erl\" }\nlibeir_util_parse = { path = \"../util/libeir_util_parse\" }\nlibeir_diagnostics = { path = \"../libeir_diagnostics\" }\nlibeir_util_parse_listing = { path = \"../util/libeir_util_parse_listing\" }\n\n[features]\ndefault = [\"frontend_erlang\", \"frontend_abstr_erlang\", \"frontend_eir\"]\nfrontend_erlang = []\nfrontend_abstr_erlang = []\nfrontend_eir = []\n" }, { "path": "libeir_frontend/README.md", "content": "# libeir_frontend\n\nWrapper crate for all the different frontends in this project.\n\nCurrently includes:\n* eir frontend\n* erlang frontend\n* abstract erlang frontend\n" }, { "path": "libeir_frontend/src/abstr_erlang.rs", "content": "use std::path::Path;\nuse std::sync::Arc;\n\nuse libeir_diagnostics::*;\nuse libeir_ir::Module;\nuse libeir_syntax_erl::{lower_abstr, lower_module, LowerError};\nuse libeir_util_parse::{error_tee, Parse, Parser};\nuse libeir_util_parse_listing::{ast::Root, parser::ParseError};\n\nuse super::{Frontend, FrontendErrorReceiver};\n\npub enum Error {\n Parse(ParseError),\n Lower(LowerError),\n}\nimpl ToDiagnostic for Error {\n fn to_diagnostic(&self) -> Diagnostic {\n match self {\n Error::Parse(err) => err.to_diagnostic(),\n Error::Lower(err) => err.to_diagnostic(),\n }\n }\n}\nimpl From for Error {\n fn from(err: ParseError) -> Error {\n Error::Parse(err)\n }\n}\nimpl From for Error {\n fn from(err: LowerError) -> Error {\n Error::Lower(err)\n }\n}\n\npub struct AbstrErlangFrontend {\n parser: Parser<()>,\n}\nimpl AbstrErlangFrontend {\n pub fn new(codemap: Arc) -> Self {\n Self {\n parser: Parser::new((), codemap),\n }\n }\n}\nimpl Frontend for AbstrErlangFrontend {\n type Error = Error;\n\n fn parse_source<'a>(\n &self,\n errors: &'a mut FrontendErrorReceiver<'a, Self::Error>,\n source: Arc,\n ) -> Result {\n error_tee(errors, |mut errors| {\n let root = self\n .parser\n .parse::(&mut errors.make_into_adapter(), source)?;\n let ast = lower_abstr(&root);\n let eir = lower_module(\n &mut errors.make_into_adapter(),\n self.parser.codemap.clone(),\n &ast,\n )?;\n Ok(eir)\n })\n }\n\n fn parse_string<'a>(\n &self,\n errors: &'a mut FrontendErrorReceiver<'a, Self::Error>,\n source: &str,\n ) -> Result {\n let id = self.parser.codemap.add(\"nofile\", source.to_string());\n let file = self.parser.codemap.get(id).unwrap();\n self.parse_source(errors, file)\n }\n\n fn parse_file<'a>(\n &self,\n errors: &'a mut FrontendErrorReceiver<'a, Self::Error>,\n path: &Path,\n ) -> Result {\n match std::fs::read_to_string(path) {\n Err(err) => {\n errors.error(>::root_file_error(err, path.to_owned()).into());\n Err(())\n }\n Ok(content) => {\n let id = self.parser.codemap.add(path, content);\n let file = self.parser.codemap.get(id).unwrap();\n self.parse_source(errors, file)\n }\n }\n }\n}\n" }, { "path": "libeir_frontend/src/eir.rs", "content": "use std::path::Path;\nuse std::sync::Arc;\n\nuse libeir_diagnostics::*;\nuse libeir_ir::{\n text::{ast::Module as ModuleAst, parser::ParserError, LowerError},\n Module,\n};\nuse libeir_util_parse::{error_tee, Parse, Parser};\n\nuse super::{Frontend, FrontendErrorReceiver};\n\npub enum Error {\n Parser(ParserError),\n Lower(LowerError),\n}\nimpl ToDiagnostic for Error {\n fn to_diagnostic(&self) -> Diagnostic {\n match self {\n Error::Parser(err) => err.to_diagnostic(),\n Error::Lower(err) => err.to_diagnostic(),\n }\n }\n}\nimpl From for Error {\n fn from(err: ParserError) -> Self {\n Error::Parser(err)\n }\n}\nimpl From for Error {\n fn from(err: LowerError) -> Self {\n Error::Lower(err)\n }\n}\n\npub struct EirFrontend {\n parser: Parser<()>,\n}\nimpl EirFrontend {\n pub fn new(codemap: Arc) -> Self {\n Self {\n parser: Parser::new((), codemap),\n }\n }\n}\nimpl Frontend for EirFrontend {\n type Error = Error;\n\n fn parse_source<'a>(\n &self,\n errors: &'a mut FrontendErrorReceiver<'a, Self::Error>,\n source: Arc,\n ) -> Result {\n error_tee(errors, |mut errors| {\n let ast = self\n .parser\n .parse::(&mut errors.make_into_adapter(), source)?;\n let eir = ast.lower(&mut errors.make_into_adapter())?;\n Ok(eir)\n })\n }\n\n fn parse_string<'a>(\n &self,\n errors: &'a mut FrontendErrorReceiver<'a, Self::Error>,\n source: &str,\n ) -> Result {\n let id = self.parser.codemap.add(\"nofile\", source.to_owned());\n let file = self.parser.codemap.get(id).unwrap();\n self.parse_source(errors, file)\n }\n\n fn parse_file<'a>(\n &self,\n errors: &'a mut FrontendErrorReceiver<'a, Self::Error>,\n path: &Path,\n ) -> Result {\n match std::fs::read_to_string(path) {\n Err(err) => {\n errors.error(>::root_file_error(err, path.to_owned()).into());\n Err(())\n }\n Ok(content) => {\n let id = self.parser.codemap.add(path, content);\n let file = self.parser.codemap.get(id).unwrap();\n self.parse_source(errors, file)\n }\n }\n }\n}\n" }, { "path": "libeir_frontend/src/erlang.rs", "content": "use std::path::Path;\nuse std::sync::Arc;\n\nuse libeir_diagnostics::*;\nuse libeir_ir::Module;\nuse libeir_syntax_erl::{\n ast::Module as ModuleAst, lower_module, LowerError, ParseConfig, ParserError,\n};\nuse libeir_util_parse::{error_tee, Parse, Parser};\n\nuse super::{Frontend, FrontendErrorReceiver};\n\npub enum Error {\n Parser(ParserError),\n Lower(LowerError),\n}\nimpl ToDiagnostic for Error {\n fn to_diagnostic(&self) -> Diagnostic {\n match self {\n Error::Parser(err) => err.to_diagnostic(),\n Error::Lower(err) => err.to_diagnostic(),\n }\n }\n}\nimpl Into for ParserError {\n fn into(self) -> Error {\n Error::Parser(self)\n }\n}\nimpl Into for LowerError {\n fn into(self) -> Error {\n Error::Lower(self)\n }\n}\n\npub struct ErlangFrontend {\n parser: Parser,\n}\n\nimpl ErlangFrontend {\n pub fn new(config: ParseConfig, codemap: Arc) -> Self {\n Self {\n parser: Parser::new(config, codemap),\n }\n }\n}\n\nimpl Frontend for ErlangFrontend {\n type Error = Error;\n\n fn parse_source<'a>(\n &self,\n errors: &'a mut FrontendErrorReceiver<'a, Self::Error>,\n source: Arc,\n ) -> Result {\n error_tee(errors, |mut errors| {\n let ast = self\n .parser\n .parse::(&mut errors.make_into_adapter(), source)?;\n let eir = lower_module(\n &mut errors.make_into_adapter(),\n self.parser.codemap.clone(),\n &ast,\n )?;\n Ok(eir)\n })\n }\n\n fn parse_string<'a>(\n &self,\n errors: &'a mut FrontendErrorReceiver<'a, Self::Error>,\n source: &str,\n ) -> Result {\n let id = self.parser.codemap.add(\"nofile\", source.to_owned());\n let file = self.parser.codemap.get(id).unwrap();\n self.parse_source(errors, file)\n }\n\n fn parse_file<'a>(\n &self,\n errors: &'a mut FrontendErrorReceiver<'a, Self::Error>,\n path: &Path,\n ) -> Result {\n match std::fs::read_to_string(path) {\n Err(err) => {\n errors.error(>::root_file_error(err, path.to_owned()).into());\n Err(())\n }\n Ok(content) => {\n let id = self.parser.codemap.add(path, content);\n let file = self.parser.codemap.get(id).unwrap();\n self.parse_source(errors, file)\n }\n }\n }\n}\n" }, { "path": "libeir_frontend/src/lib.rs", "content": "#[cfg(feature = \"frontend_abstr_erlang\")]\npub mod abstr_erlang;\n#[cfg(feature = \"frontend_eir\")]\npub mod eir;\n#[cfg(feature = \"frontend_erlang\")]\npub mod erlang;\n\nuse std::path::Path;\nuse std::sync::Arc;\n\nuse libeir_diagnostics::{Diagnostic, SourceFile, ToDiagnostic};\nuse libeir_ir::Module;\nuse libeir_util_parse::ErrorReceiver;\n\npub type FrontendErrorReceiver<'a, E> = dyn ErrorReceiver + 'a;\n\npub trait DynFrontend {\n fn parse_source_dyn<'a>(\n &self,\n source: Arc,\n ) -> (Result, Vec);\n\n fn parse_string_dyn<'a>(&self, source: &str) -> (Result, Vec);\n\n fn parse_file_dyn<'a>(&self, source: &Path) -> (Result, Vec);\n}\n\npub trait Frontend {\n type Error;\n\n fn parse_source<'a>(\n &self,\n errors: &'a mut FrontendErrorReceiver<'a, Self::Error>,\n source: Arc,\n ) -> Result;\n\n fn parse_string<'a>(\n &self,\n errors: &'a mut FrontendErrorReceiver<'a, Self::Error>,\n source: &str,\n ) -> Result;\n\n fn parse_file<'a>(\n &self,\n errors: &'a mut FrontendErrorReceiver<'a, Self::Error>,\n source: &Path,\n ) -> Result;\n}\n\nimpl DynFrontend for F\nwhere\n F: Frontend,\n E: ToDiagnostic,\n{\n fn parse_source_dyn<'a>(\n &self,\n source: Arc,\n ) -> (Result, Vec) {\n let mut errors = libeir_util_parse::Errors::new();\n let res = self.parse_source(&mut errors, source);\n (res, errors.iter_diagnostics().collect())\n }\n\n fn parse_string_dyn<'a>(&self, source: &str) -> (Result, Vec) {\n let mut errors = libeir_util_parse::Errors::new();\n let res = self.parse_string(&mut errors, source);\n (res, errors.iter_diagnostics().collect())\n }\n\n fn parse_file_dyn<'a>(&self, source: &Path) -> (Result, Vec) {\n let mut errors = libeir_util_parse::Errors::new();\n let res = self.parse_file(&mut errors, source);\n (res, errors.iter_diagnostics().collect())\n }\n}\n\npub enum AnyFrontend {\n #[cfg(feature = \"frontend_erlang\")]\n Erlang(erlang::ErlangFrontend),\n #[cfg(feature = \"frontend_abstr_erlang\")]\n AbstrErlang(abstr_erlang::AbstrErlangFrontend),\n #[cfg(feature = \"frontend_eir\")]\n Eir(eir::EirFrontend),\n}\nimpl DynFrontend for AnyFrontend {\n fn parse_source_dyn<'a>(\n &self,\n source: Arc,\n ) -> (Result, Vec) {\n match self {\n #[cfg(feature = \"frontend_erlang\")]\n AnyFrontend::Erlang(front) => front.parse_source_dyn(source),\n #[cfg(feature = \"frontend_abstr_erlang\")]\n AnyFrontend::AbstrErlang(front) => front.parse_source_dyn(source),\n #[cfg(feature = \"frontend_eir\")]\n AnyFrontend::Eir(front) => front.parse_source_dyn(source),\n }\n }\n\n fn parse_string_dyn<'a>(&self, source: &str) -> (Result, Vec) {\n match self {\n #[cfg(feature = \"frontend_erlang\")]\n AnyFrontend::Erlang(front) => front.parse_string_dyn(source),\n #[cfg(feature = \"frontend_abstr_erlang\")]\n AnyFrontend::AbstrErlang(front) => front.parse_string_dyn(source),\n #[cfg(feature = \"frontend_eir\")]\n AnyFrontend::Eir(front) => front.parse_string_dyn(source),\n }\n }\n\n fn parse_file_dyn<'a>(&self, source: &Path) -> (Result, Vec) {\n match self {\n #[cfg(feature = \"frontend_erlang\")]\n AnyFrontend::Erlang(front) => front.parse_file_dyn(source),\n #[cfg(feature = \"frontend_abstr_erlang\")]\n AnyFrontend::AbstrErlang(front) => front.parse_file_dyn(source),\n #[cfg(feature = \"frontend_eir\")]\n AnyFrontend::Eir(front) => front.parse_file_dyn(source),\n }\n }\n}\nimpl From for AnyFrontend {\n fn from(f: erlang::ErlangFrontend) -> Self {\n AnyFrontend::Erlang(f)\n }\n}\nimpl From for AnyFrontend {\n fn from(f: abstr_erlang::AbstrErlangFrontend) -> Self {\n AnyFrontend::AbstrErlang(f)\n }\n}\nimpl From for AnyFrontend {\n fn from(f: eir::EirFrontend) -> Self {\n AnyFrontend::Eir(f)\n }\n}\n" }, { "path": "libeir_intern/Cargo.toml", "content": "[package]\nname = \"libeir_intern\"\nversion = \"0.1.0\"\nauthors = [\"Hans Elias B. Josephsen \"]\nedition = \"2018\"\nlicense = \"MIT OR Apache-2.0\"\n\n# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html\n\n[dependencies]\nlibeir_diagnostics = { path = \"../libeir_diagnostics\" }\n\nrustc-hash = \"1.0\"\nlazy_static = \"1.2\"\n" }, { "path": "libeir_intern/src/arena.rs", "content": "#![allow(unused)]\n//! NOTE: Modified version of impl in rustc\n//!\n//! The arena, a fast but limited type of allocator.\n//!\n//! Arenas are a type of allocator that destroy the objects within, all at\n//! once, once the arena itself is destroyed. They do not support deallocation\n//! of individual objects while the arena itself is still alive. The benefit\n//! of an arena is very fast allocation; just a pointer bump.\n//!\n//! This crate implements `TypedArena`, a simple arena that can only hold\n//! objects of a single type.\nuse core::cell::{Cell, RefCell};\nuse core::cmp;\nuse core::intrinsics;\nuse core::marker::{PhantomData, Send};\nuse core::mem;\nuse core::ptr;\nuse core::slice;\n\nuse alloc::raw_vec::RawVec;\nuse alloc::vec::Vec;\n\n/// An arena that can hold objects of only one type.\npub struct TypedArena {\n /// A pointer to the next object to be allocated.\n ptr: Cell<*mut T>,\n\n /// A pointer to the end of the allocated area. When this pointer is\n /// reached, a new chunk is allocated.\n end: Cell<*mut T>,\n\n /// A vector of arena chunks.\n chunks: RefCell>>,\n\n /// Marker indicating that dropping the arena causes its owned\n /// instances of `T` to be dropped.\n _own: PhantomData,\n}\n\nstruct TypedArenaChunk {\n /// The raw storage for the arena chunk.\n storage: RawVec,\n}\n\nimpl TypedArenaChunk {\n #[inline]\n unsafe fn new(capacity: usize) -> TypedArenaChunk {\n TypedArenaChunk {\n storage: RawVec::with_capacity(capacity),\n }\n }\n\n /// Destroys this arena chunk.\n #[inline]\n unsafe fn destroy(&mut self, len: usize) {\n // The branch on needs_drop() is an -O1 performance optimization.\n // Without the branch, dropping TypedArena takes linear time.\n if mem::needs_drop::() {\n let mut start = self.start();\n // Destroy all allocated objects.\n for _ in 0..len {\n ptr::drop_in_place(start);\n start = start.offset(1);\n }\n }\n }\n\n // Returns a pointer to the first allocated object.\n #[inline]\n fn start(&self) -> *mut T {\n self.storage.ptr()\n }\n\n // Returns a pointer to the end of the allocated space.\n #[inline]\n fn end(&self) -> *mut T {\n unsafe {\n if mem::size_of::() == 0 {\n // A pointer as large as possible for zero-sized elements.\n !0 as *mut T\n } else {\n self.start().add(self.storage.capacity())\n }\n }\n }\n}\n\n#[cfg(not(target_arch = \"wasm32\"))]\nconst PAGE: usize = 4 * 1024;\n\n#[cfg(target_arch = \"wasm32\")]\nconst PAGE: usize = 64 * 1024;\n\nimpl Default for TypedArena {\n /// Creates a new `TypedArena`.\n fn default() -> TypedArena {\n TypedArena {\n // We set both `ptr` and `end` to 0 so that the first call to\n // alloc() will trigger a grow().\n ptr: Cell::new(0 as *mut T),\n end: Cell::new(0 as *mut T),\n chunks: RefCell::new(Vec::new()),\n _own: PhantomData,\n }\n }\n}\n\nimpl TypedArena {\n pub fn in_arena(&self, ptr: *const T) -> bool {\n let ptr = ptr as *const T as *mut T;\n\n self.chunks\n .borrow()\n .iter()\n .any(|chunk| chunk.start() <= ptr && ptr < chunk.end())\n }\n /// Allocates an object in the `TypedArena`, returning a reference to it.\n #[inline]\n pub fn alloc(&self, object: T) -> &mut T {\n if self.ptr == self.end {\n self.grow(1)\n }\n\n unsafe {\n if mem::size_of::() == 0 {\n self.ptr\n .set(intrinsics::arith_offset(self.ptr.get() as *mut u8, 1) as *mut T);\n let ptr = mem::align_of::() as *mut T;\n // Don't drop the object. This `write` is equivalent to `forget`.\n ptr::write(ptr, object);\n &mut *ptr\n } else {\n let ptr = self.ptr.get();\n // Advance the pointer.\n self.ptr.set(self.ptr.get().offset(1));\n // Write into uninitialized memory.\n ptr::write(ptr, object);\n &mut *ptr\n }\n }\n }\n\n /// Allocates a slice of objects that are copied into the `TypedArena`, returning a mutable\n /// reference to it. Will panic if passed a zero-sized types.\n ///\n /// Panics:\n ///\n /// - Zero-sized types\n /// - Zero-length slices\n #[inline]\n pub fn alloc_slice(&self, slice: &[T]) -> &mut [T]\n where\n T: Copy,\n {\n assert!(mem::size_of::() != 0);\n assert!(slice.len() != 0);\n\n let available_capacity_bytes = self.end.get() as usize - self.ptr.get() as usize;\n let at_least_bytes = slice.len() * mem::size_of::();\n if available_capacity_bytes < at_least_bytes {\n self.grow(slice.len());\n }\n\n unsafe {\n let start_ptr = self.ptr.get();\n let arena_slice = slice::from_raw_parts_mut(start_ptr, slice.len());\n self.ptr.set(start_ptr.add(arena_slice.len()));\n arena_slice.copy_from_slice(slice);\n arena_slice\n }\n }\n\n /// Grows the arena.\n #[inline(never)]\n #[cold]\n fn grow(&self, n: usize) {\n unsafe {\n let mut chunks = self.chunks.borrow_mut();\n let (chunk, mut new_capacity);\n if let Some(last_chunk) = chunks.last_mut() {\n let used_bytes = self.ptr.get() as usize - last_chunk.start() as usize;\n let currently_used_cap = used_bytes / mem::size_of::();\n new_capacity = last_chunk.storage.capacity();\n loop {\n new_capacity = new_capacity.checked_mul(2).unwrap();\n if new_capacity >= currently_used_cap + n {\n break;\n }\n }\n } else {\n let elem_size = cmp::max(1, mem::size_of::());\n new_capacity = cmp::max(n, PAGE / elem_size);\n }\n chunk = TypedArenaChunk::::new(new_capacity);\n self.ptr.set(chunk.start());\n self.end.set(chunk.end());\n chunks.push(chunk);\n }\n }\n\n /// Clears the arena. Deallocates all but the longest chunk which may be reused.\n pub fn clear(&mut self) {\n unsafe {\n // Clear the last chunk, which is partially filled.\n let mut chunks_borrow = self.chunks.borrow_mut();\n if let Some(mut last_chunk) = chunks_borrow.last_mut() {\n self.clear_last_chunk(&mut last_chunk);\n let len = chunks_borrow.len();\n // If `T` is ZST, code below has no effect.\n for mut chunk in chunks_borrow.drain(..len - 1) {\n let cap = chunk.storage.capacity();\n chunk.destroy(cap);\n }\n }\n }\n }\n\n // Drops the contents of the last chunk. The last chunk is partially empty, unlike all other\n // chunks.\n fn clear_last_chunk(&self, last_chunk: &mut TypedArenaChunk) {\n // Determine how much was filled.\n let start = last_chunk.start() as usize;\n // We obtain the value of the pointer to the first uninitialized element.\n let end = self.ptr.get() as usize;\n // We then calculate the number of elements to be dropped in the last chunk,\n // which is the filled area's length.\n let diff = if mem::size_of::() == 0 {\n // `T` is ZST. It can't have a drop flag, so the value here doesn't matter. We get\n // the number of zero-sized values in the last and only chunk, just out of caution.\n // Recall that `end` was incremented for each allocated value.\n end - start\n } else {\n (end - start) / mem::size_of::()\n };\n // Pass that to the `destroy` method.\n unsafe {\n last_chunk.destroy(diff);\n }\n // Reset the chunk.\n self.ptr.set(last_chunk.start());\n }\n}\n\nunsafe impl<#[may_dangle] T> Drop for TypedArena {\n fn drop(&mut self) {\n unsafe {\n // Determine how much was filled.\n let mut chunks_borrow = self.chunks.borrow_mut();\n if let Some(mut last_chunk) = chunks_borrow.pop() {\n // Drop the contents of the last chunk.\n self.clear_last_chunk(&mut last_chunk);\n // The last chunk will be dropped. Destroy all other chunks.\n for chunk in chunks_borrow.iter_mut() {\n let cap = chunk.storage.capacity();\n chunk.destroy(cap);\n }\n }\n // RawVec handles deallocation of `last_chunk` and `self.chunks`.\n }\n }\n}\n\nunsafe impl Send for TypedArena {}\n\npub struct DroplessArena {\n /// A pointer to the next object to be allocated.\n ptr: Cell<*mut u8>,\n\n /// A pointer to the end of the allocated area. When this pointer is\n /// reached, a new chunk is allocated.\n end: Cell<*mut u8>,\n\n /// A vector of arena chunks.\n chunks: RefCell>>,\n}\n\nunsafe impl Send for DroplessArena {}\n\nimpl Default for DroplessArena {\n #[inline]\n fn default() -> DroplessArena {\n DroplessArena {\n ptr: Cell::new(0 as *mut u8),\n end: Cell::new(0 as *mut u8),\n chunks: Default::default(),\n }\n }\n}\n\nimpl DroplessArena {\n pub fn in_arena(&self, ptr: *const T) -> bool {\n let ptr = ptr as *const u8 as *mut u8;\n\n self.chunks\n .borrow()\n .iter()\n .any(|chunk| chunk.start() <= ptr && ptr < chunk.end())\n }\n\n #[inline]\n fn align(&self, align: usize) {\n let final_address = ((self.ptr.get() as usize) + align - 1) & !(align - 1);\n self.ptr.set(final_address as *mut u8);\n assert!(self.ptr <= self.end);\n }\n\n #[inline(never)]\n #[cold]\n fn grow(&self, needed_bytes: usize) {\n unsafe {\n let mut chunks = self.chunks.borrow_mut();\n let (chunk, mut new_capacity);\n if let Some(last_chunk) = chunks.last_mut() {\n let used_bytes = self.ptr.get() as usize - last_chunk.start() as usize;\n new_capacity = last_chunk.storage.capacity();\n loop {\n new_capacity = new_capacity.checked_mul(2).unwrap();\n if new_capacity >= used_bytes + needed_bytes {\n break;\n }\n }\n } else {\n new_capacity = cmp::max(needed_bytes, PAGE);\n }\n chunk = TypedArenaChunk::::new(new_capacity);\n self.ptr.set(chunk.start());\n self.end.set(chunk.end());\n chunks.push(chunk);\n }\n }\n\n #[inline]\n pub unsafe fn alloc_raw(&self, bytes: usize, align: usize) -> *mut u8 {\n assert!(bytes != 0);\n\n self.align(align);\n\n let future_end = intrinsics::arith_offset(self.ptr.get(), bytes as isize);\n if (future_end as *mut u8) >= self.end.get() {\n self.grow(bytes);\n }\n\n let ptr = self.ptr.get();\n // Set the pointer past ourselves\n self.ptr\n .set(intrinsics::arith_offset(self.ptr.get(), bytes as isize) as *mut u8);\n\n ptr\n }\n\n #[inline]\n pub fn alloc_copy(&self, object: T) -> &mut T {\n assert!(!mem::needs_drop::());\n\n unsafe {\n let mem = self.alloc_raw(mem::size_of::(), mem::align_of::()) as *mut T;\n\n // Write into uninitialized memory.\n ptr::write(mem, object);\n &mut *mem\n }\n }\n\n /// Allocates a slice of objects that are copied into the `DroplessArena`, returning a mutable\n /// reference to it. Will panic if passed a zero-sized type.\n ///\n /// Panics:\n ///\n /// - Zero-sized types\n /// - Zero-length slices\n #[inline]\n pub fn alloc_slice(&self, slice: &[T]) -> &mut [T]\n where\n T: Copy,\n {\n assert!(!mem::needs_drop::());\n assert!(mem::size_of::() != 0);\n assert!(!slice.is_empty());\n\n unsafe {\n let mem = self.alloc_raw(slice.len() * mem::size_of::(), mem::align_of::())\n as *mut _ as *mut T;\n\n let arena_slice = slice::from_raw_parts_mut(mem, slice.len());\n arena_slice.copy_from_slice(slice);\n arena_slice\n }\n }\n}\n\n#[cfg(test)]\nmod tests {\n use super::TypedArena;\n use alloc::boxed::Box;\n use alloc::string::String;\n use alloc::vec;\n use alloc::vec::Vec;\n use core::cell::Cell;\n use core::sync::atomic::{AtomicUsize, Ordering};\n use test::Bencher;\n\n #[allow(dead_code)]\n #[derive(Debug, Eq, PartialEq)]\n struct Point {\n x: i32,\n y: i32,\n z: i32,\n }\n\n #[test]\n pub fn test_unused() {\n let arena: TypedArena = TypedArena::default();\n assert!(arena.chunks.borrow().is_empty());\n }\n\n #[test]\n fn test_arena_alloc_nested() {\n struct Inner {\n value: u8,\n }\n struct Outer<'a> {\n inner: &'a Inner,\n }\n enum EI<'e> {\n I(Inner),\n O(Outer<'e>),\n }\n\n struct Wrap<'a>(TypedArena>);\n\n impl<'a> Wrap<'a> {\n fn alloc_inner Inner>(&self, f: F) -> &Inner {\n let r: &EI = self.0.alloc(EI::I(f()));\n if let &EI::I(ref i) = r {\n i\n } else {\n panic!(\"mismatch\");\n }\n }\n fn alloc_outer Outer<'a>>(&self, f: F) -> &Outer {\n let r: &EI = self.0.alloc(EI::O(f()));\n if let &EI::O(ref o) = r {\n o\n } else {\n panic!(\"mismatch\");\n }\n }\n }\n\n let arena = Wrap(TypedArena::default());\n\n let result = arena.alloc_outer(|| Outer {\n inner: arena.alloc_inner(|| Inner { value: 10 }),\n });\n\n assert_eq!(result.inner.value, 10);\n }\n\n #[test]\n pub fn test_copy() {\n let arena = TypedArena::default();\n for _ in 0..100000 {\n arena.alloc(Point { x: 1, y: 2, z: 3 });\n }\n }\n\n #[bench]\n pub fn bench_copy(b: &mut Bencher) {\n let arena = TypedArena::default();\n b.iter(|| arena.alloc(Point { x: 1, y: 2, z: 3 }))\n }\n\n #[bench]\n pub fn bench_copy_nonarena(b: &mut Bencher) {\n b.iter(|| {\n let _: Box<_> = Box::new(Point { x: 1, y: 2, z: 3 });\n })\n }\n\n #[allow(dead_code)]\n struct Noncopy {\n string: String,\n array: Vec,\n }\n\n #[test]\n pub fn test_noncopy() {\n let arena = TypedArena::default();\n for _ in 0..100000 {\n arena.alloc(Noncopy {\n string: String::from(\"hello world\"),\n array: vec![1, 2, 3, 4, 5],\n });\n }\n }\n\n #[test]\n pub fn test_typed_arena_zero_sized() {\n let arena = TypedArena::default();\n for _ in 0..100000 {\n arena.alloc(());\n }\n }\n\n #[test]\n pub fn test_typed_arena_clear() {\n let mut arena = TypedArena::default();\n for _ in 0..10 {\n arena.clear();\n for _ in 0..10000 {\n arena.alloc(Point { x: 1, y: 2, z: 3 });\n }\n }\n }\n\n #[bench]\n pub fn bench_typed_arena_clear(b: &mut Bencher) {\n let mut arena = TypedArena::default();\n b.iter(|| {\n arena.alloc(Point { x: 1, y: 2, z: 3 });\n arena.clear();\n })\n }\n\n // Drop tests\n\n struct DropCounter<'a> {\n count: &'a Cell,\n }\n\n impl<'a> Drop for DropCounter<'a> {\n fn drop(&mut self) {\n self.count.set(self.count.get() + 1);\n }\n }\n\n #[test]\n fn test_typed_arena_drop_count() {\n let counter = Cell::new(0);\n {\n let arena: TypedArena = TypedArena::default();\n for _ in 0..100 {\n // Allocate something with drop glue to make sure it doesn't leak.\n arena.alloc(DropCounter { count: &counter });\n }\n };\n assert_eq!(counter.get(), 100);\n }\n\n #[test]\n fn test_typed_arena_drop_on_clear() {\n let counter = Cell::new(0);\n let mut arena: TypedArena = TypedArena::default();\n for i in 0..10 {\n for _ in 0..100 {\n // Allocate something with drop glue to make sure it doesn't leak.\n arena.alloc(DropCounter { count: &counter });\n }\n arena.clear();\n assert_eq!(counter.get(), i * 100 + 100);\n }\n }\n\n static DROP_COUNTER: AtomicUsize = AtomicUsize::new(0);\n\n struct SmallDroppable;\n\n impl Drop for SmallDroppable {\n fn drop(&mut self) {\n DROP_COUNTER.fetch_add(1, Ordering::SeqCst);\n }\n }\n\n #[test]\n fn test_typed_arena_drop_small_count() {\n DROP_COUNTER.store(0, Ordering::SeqCst);\n {\n let arena: TypedArena = TypedArena::default();\n for _ in 0..100 {\n // Allocate something with drop glue to make sure it doesn't leak.\n arena.alloc(SmallDroppable);\n }\n // dropping\n };\n assert_eq!(DROP_COUNTER.load(Ordering::SeqCst), 100);\n }\n\n #[bench]\n pub fn bench_noncopy(b: &mut Bencher) {\n let arena = TypedArena::default();\n b.iter(|| {\n arena.alloc(Noncopy {\n string: String::from(\"hello world\"),\n array: vec![1, 2, 3, 4, 5],\n })\n })\n }\n\n #[bench]\n pub fn bench_noncopy_nonarena(b: &mut Bencher) {\n b.iter(|| {\n let _: Box<_> = Box::new(Noncopy {\n string: String::from(\"hello world\"),\n array: vec![1, 2, 3, 4, 5],\n });\n })\n }\n}\n" }, { "path": "libeir_intern/src/lib.rs", "content": "#![feature(core_intrinsics)]\n#![feature(dropck_eyepatch)]\n#![feature(raw_vec_internals)]\n#![feature(test)]\n\nextern crate alloc;\n\n#[cfg(any(test, bench))]\nextern crate test;\n\npub mod arena;\n\npub mod symbol;\npub use symbol::{Ident, InternedString, LocalInternedString, Symbol};\n\n#[cfg(test)]\nmod tests {\n #[test]\n fn it_works() {\n assert_eq!(2 + 2, 4);\n }\n}\n" }, { "path": "libeir_intern/src/symbol.rs", "content": "//! An \"interner\" is a data structure that associates values with usize tags and\n//! allows bidirectional lookup; i.e., given a value, one can easily find the\n//! type, and vice versa.\n#![allow(unused)]\nuse std::cell::RefCell;\nuse std::cmp::{Ord, Ordering, PartialEq, PartialOrd};\nuse std::fmt;\nuse std::hash::{Hash, Hasher};\nuse std::marker::PhantomData;\nuse std::str;\nuse std::sync::{Arc, RwLock};\n\nuse lazy_static::lazy_static;\nuse rustc_hash::FxHashMap;\n\nuse crate::arena::DroplessArena;\n\nuse libeir_diagnostics::SourceSpan;\n\nlazy_static! {\n /// A globally accessible symbol table\n pub static ref SYMBOL_TABLE: SymbolTable = {\n SymbolTable::new()\n };\n}\n\npub struct SymbolTable {\n interner: RwLock,\n}\nimpl SymbolTable {\n pub fn new() -> Self {\n SymbolTable {\n interner: RwLock::new(Interner::fresh()),\n }\n }\n}\nunsafe impl Sync for SymbolTable {}\n\n#[derive(Copy, Clone, Eq)]\npub struct Ident {\n pub name: Symbol,\n pub span: SourceSpan,\n}\n\nimpl Ident {\n #[inline]\n pub const fn new(name: Symbol, span: SourceSpan) -> Ident {\n Ident { name, span }\n }\n\n #[inline]\n pub const fn with_empty_span(name: Symbol) -> Ident {\n Ident::new(name, SourceSpan::UNKNOWN)\n }\n\n /// Maps an interned string to an identifier with an empty syntax context.\n pub fn from_interned_str(string: InternedString) -> Ident {\n Ident::with_empty_span(string.as_symbol())\n }\n\n /// Maps a string to an identifier with an empty syntax context.\n pub fn from_str(string: &str) -> Ident {\n Ident::with_empty_span(Symbol::intern(string))\n }\n\n pub fn unquote_string(self) -> Ident {\n Ident::new(Symbol::intern(self.as_str().trim_matches('\"')), self.span)\n }\n\n pub fn unquote_atom(self) -> Ident {\n Ident::new(Symbol::intern(self.as_str().trim_matches('\\'')), self.span)\n }\n\n pub fn gensym(self) -> Ident {\n Ident::new(self.name.gensymed(), self.span)\n }\n\n pub fn as_str(self) -> LocalInternedString {\n self.name.as_str()\n }\n\n pub fn as_interned_str(self) -> InternedString {\n self.name.as_interned_str()\n }\n}\n\nimpl PartialOrd for Ident {\n fn partial_cmp(&self, other: &Self) -> Option {\n self.name.partial_cmp(&other.name)\n }\n}\n\nimpl PartialEq for Ident {\n fn eq(&self, rhs: &Self) -> bool {\n self.name == rhs.name\n }\n}\n\nimpl Hash for Ident {\n fn hash(&self, state: &mut H) {\n self.name.hash(state);\n }\n}\n\nimpl fmt::Debug for Ident {\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n write!(f, \"Ident<{} {:?}>\", self.name, self.span)\n }\n}\n\nimpl fmt::Display for Ident {\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n fmt::Display::fmt(&self.name, f)\n }\n}\n\n#[derive(Debug, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]\npub struct SymbolIndex(u32);\nimpl Clone for SymbolIndex {\n fn clone(&self) -> Self {\n *self\n }\n}\nimpl From for u32 {\n #[inline]\n fn from(v: SymbolIndex) -> u32 {\n v.as_u32()\n }\n}\nimpl From for usize {\n #[inline]\n fn from(v: SymbolIndex) -> usize {\n v.as_usize()\n }\n}\nimpl SymbolIndex {\n // shave off 256 indices at the end to allow space for packing these indices into enums\n pub const MAX_AS_U32: u32 = 0xFFFF_FF00;\n\n pub const MAX: SymbolIndex = SymbolIndex::new(0xFFFF_FF00);\n\n #[inline]\n const fn new(n: u32) -> Self {\n // This will fail at const eval time unless `value <=\n // max` is true (in which case we get the index 0).\n // It will also fail at runtime, of course, but in a\n // kind of wacky way.\n let _ = [\"out of range value used\"][!(n <= Self::MAX_AS_U32) as usize];\n\n SymbolIndex(n)\n }\n\n #[inline]\n pub fn as_u32(self) -> u32 {\n self.0\n }\n\n #[inline]\n pub fn as_usize(self) -> usize {\n self.0 as usize\n }\n}\n\n/// A symbol is an interned or gensymed string.\n#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]\npub struct Symbol(SymbolIndex);\n\nimpl Symbol {\n const fn new(n: u32) -> Self {\n Symbol(SymbolIndex::new(n))\n }\n\n /// Maps a string to its interned representation.\n pub fn intern(string: &str) -> Self {\n with_interner(|interner| interner.intern(string))\n }\n\n pub fn interned(self) -> Self {\n with_interner(|interner| interner.interned(self))\n }\n\n /// Gensyms a new usize, using the current interner.\n pub fn gensym(string: &str) -> Self {\n with_interner(|interner| interner.gensym(string))\n }\n\n pub fn gensymed(self) -> Self {\n with_interner(|interner| interner.gensymed(self))\n }\n\n pub fn as_str(self) -> LocalInternedString {\n with_interner(|interner| unsafe {\n LocalInternedString {\n string: ::std::mem::transmute::<&str, &str>(interner.get(self)),\n dummy: PhantomData,\n }\n })\n }\n\n pub fn as_interned_str(self) -> InternedString {\n with_interner(|interner| InternedString {\n symbol: interner.interned(self),\n })\n }\n\n #[inline]\n pub fn as_u32(self) -> u32 {\n self.0.as_u32()\n }\n\n #[inline]\n pub fn as_usize(self) -> usize {\n self.0.as_usize()\n }\n}\n\nimpl fmt::Debug for Symbol {\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n let is_gensymed = with_interner(|interner| interner.is_gensymed(*self));\n if is_gensymed {\n write!(f, \"{}({:?})\", self, self.0)\n } else {\n write!(f, \"{}({:?})\", self, self.0)\n }\n }\n}\n\nimpl fmt::Display for Symbol {\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n fmt::Display::fmt(&self.as_str(), f)\n }\n}\n\nimpl> PartialEq for Symbol {\n fn eq(&self, other: &T) -> bool {\n self.as_str() == other.deref()\n }\n}\n\n// The `&'static str`s in this type actually point into the arena.\n//\n// Note that normal symbols are indexed upward from 0, and gensyms are indexed\n// downward from SymbolIndex::MAX_AS_U32.\n#[derive(Default)]\npub struct Interner {\n arena: DroplessArena,\n pub names: FxHashMap<&'static str, Symbol>,\n pub strings: Vec<&'static str>,\n gensyms: Vec,\n}\n\nimpl Interner {\n fn prefill(init: &[&str]) -> Self {\n let mut this = Interner::default();\n for &string in init {\n if string == \"\" {\n // We can't allocate empty strings in the arena, so handle this here.\n let name = Symbol::new(this.strings.len() as u32);\n this.names.insert(\"\", name);\n this.strings.push(\"\");\n } else {\n this.intern(string);\n }\n }\n this\n }\n\n pub fn intern(&mut self, string: &str) -> Symbol {\n if let Some(&name) = self.names.get(string) {\n return name;\n }\n\n let name = Symbol::new(self.strings.len() as u32);\n\n // `from_utf8_unchecked` is safe since we just allocated a `&str` which is known to be\n // UTF-8.\n let string: &str =\n unsafe { str::from_utf8_unchecked(self.arena.alloc_slice(string.as_bytes())) };\n // It is safe to extend the arena allocation to `'static` because we only access\n // these while the arena is still alive.\n let string: &'static str = unsafe { &*(string as *const str) };\n self.strings.push(string);\n self.names.insert(string, name);\n name\n }\n\n pub fn interned(&self, symbol: Symbol) -> Symbol {\n if (symbol.0.as_usize()) < self.strings.len() {\n symbol\n } else {\n self.interned(self.gensyms[(SymbolIndex::MAX_AS_U32 - symbol.0.as_u32()) as usize])\n }\n }\n\n fn gensym(&mut self, string: &str) -> Symbol {\n let symbol = self.intern(string);\n self.gensymed(symbol)\n }\n\n fn gensymed(&mut self, symbol: Symbol) -> Symbol {\n self.gensyms.push(symbol);\n Symbol::new(SymbolIndex::MAX_AS_U32 - self.gensyms.len() as u32 + 1)\n }\n\n fn is_gensymed(&mut self, symbol: Symbol) -> bool {\n symbol.0.as_usize() >= self.strings.len()\n }\n\n pub fn get(&self, symbol: Symbol) -> &str {\n match self.strings.get(symbol.0.as_usize()) {\n Some(string) => string,\n None => self.get(self.gensyms[(SymbolIndex::MAX_AS_U32 - symbol.0.as_u32()) as usize]),\n }\n }\n}\n\n// In this macro, there is the requirement that the name (the number) must be monotonically\n// increasing by one in the special identifiers, starting at 0; the same holds for the keywords,\n// except starting from the next number instead of zero.\nmacro_rules! declare_atoms {(\n $( ($index: expr, $konst: ident, $string: expr) )*\n) => {\n pub mod symbols {\n use super::Symbol;\n $(\n #[allow(non_upper_case_globals)]\n pub const $konst: Symbol = super::Symbol::new($index);\n )*\n\n /// Used *only* for testing that the declared atoms have no gaps\n /// NOTE: The length must be static, so it must be changed when new\n /// declared keywords are added to the list\n pub(super) static DECLARED: [(Symbol, &'static str); 60] = [$(($konst, $string),)*];\n }\n\n impl Interner {\n pub fn fresh() -> Self {\n let interner = Interner::prefill(&[$($string,)*]);\n interner\n }\n }\n}}\n\n// NOTE: When determining whether an Ident is a keyword or not, we compare against\n// the ident table index, but if a hole is left in the table, then non-keyword idents\n// will be interned with an id in the keyword range. It is important to ensure there are\n// no holes, which means you have to adjust the indexes when adding a new keyword earlier\n// in the table\ndeclare_atoms! {\n // We want true/false to correspond to 1/0 respectively for convenience\n (0, False, \"false\")\n (1, True, \"true\")\n // Special reserved identifiers used internally, such as for error recovery\n (2, Invalid, \"\")\n // Keywords that are used in Erlang\n (3, After, \"after\")\n (4, Begin, \"begin\")\n (5, Case, \"case\")\n (6, Try, \"try\")\n (7, Catch, \"catch\")\n (8, End, \"end\")\n (9, Fun, \"fun\")\n (10, If, \"if\")\n (11, Of, \"of\")\n (12, Receive, \"receive\")\n (13, When, \"when\")\n (14, AndAlso, \"andalso\")\n (15, OrElse, \"orelse\")\n (16, Bnot, \"bnot\")\n (17, Not, \"not\")\n (18, Div, \"div\")\n (19, Rem, \"rem\")\n (20, Band, \"band\")\n (21, And, \"and\")\n (22, Bor, \"bor\")\n (23, Bxor, \"bxor\")\n (24, Bsl, \"bsl\")\n (25, Bsr, \"bsr\")\n (26, Or, \"or\")\n (27, Xor, \"xor\")\n // Not reserved words, but used in attributes or preprocessor directives\n (28, Module, \"module\")\n (29, Export, \"export\")\n (30, Import, \"import\")\n (31, Compile, \"compile\")\n (32, Vsn, \"vsn\")\n (33, OnLoad, \"on_load\")\n (34, Behaviour, \"behaviour\")\n (35, Spec, \"spec\")\n (36, Callback, \"callback\")\n (37, Include, \"include\")\n (38, IncludeLib, \"include_lib\")\n (39, Define, \"define\")\n (40, Undef, \"undef\")\n (41, Ifdef, \"ifdef\")\n (42, Ifndef, \"ifndef\")\n (43, Else, \"else\")\n (44, Elif, \"elif\")\n (45, Endif, \"endif\")\n (46, Error, \"error\")\n (47, Warning, \"warning\")\n (48, File, \"file\")\n // Common words\n (49, ModuleInfo, \"module_info\")\n (50, RecordInfo, \"record_info\")\n (51, BehaviourInfo,\"behaviour_info\")\n (52, Exports, \"exports\")\n (53, Attributes, \"attributes\")\n (54, Native, \"native\")\n (55, Deprecated, \"deprecated\")\n (56, ModuleCapital,\"MODULE\")\n (57, ModuleStringCapital,\"MODULE_STRING\")\n (58, Throw, \"throw\")\n (59, Exit, \"exit\")\n}\n\nimpl Symbol {\n /// Returns `true` if the token is a keyword, reserved in all name positions\n pub fn is_keyword(self) -> bool {\n self > symbols::Invalid && self <= symbols::Xor\n }\n\n /// Returns `true` if the token is a reserved attribute name\n pub fn is_reserved_attr(self) -> bool {\n self >= symbols::Module && self <= symbols::Warning\n }\n\n /// Returns `true` if the token is a preprocessor directive name\n pub fn is_preprocessor_directive(self) -> bool {\n self >= symbols::Include && self <= symbols::Warning\n }\n}\n\nimpl Ident {\n pub fn is_keyword(self) -> bool {\n self.name.is_keyword()\n }\n\n pub fn is_reserved_attr(self) -> bool {\n self.name.is_reserved_attr()\n }\n\n pub fn is_preprocessor_directive(self) -> bool {\n self.name.is_preprocessor_directive()\n }\n}\n\n// If an interner exists, return it. Otherwise, prepare a fresh one.\n#[inline]\nfn with_interner T>(f: F) -> T {\n let mut r = SYMBOL_TABLE\n .interner\n .write()\n .expect(\"unable to acquire write lock for symbol table\");\n f(&mut *r)\n //GLOBALS.with(|globals| {\n //f(&mut *globals.symbol_interner.lock().expect(\"symbol interner lock was held\"))\n //})\n}\n\n#[inline]\nfn with_read_only_interner T>(f: F) -> T {\n let r = SYMBOL_TABLE\n .interner\n .read()\n .expect(\"unable to acquire read lock for symbol table\");\n f(&*r)\n}\n\n/// Represents a string stored in the interner. Because the interner outlives any thread\n/// which uses this type, we can safely treat `string` which points to interner data,\n/// as an immortal string, as long as this type never crosses between threads.\n#[derive(Clone, Copy, Hash, PartialOrd, Eq, Ord)]\npub struct LocalInternedString {\n string: &'static str,\n /// This type cannot be sent across threads, this emulates the\n /// behavior of !impl without the unsafe feature flag.\n dummy: PhantomData<*const u8>,\n}\n\nimpl LocalInternedString {\n pub fn as_interned_str(self) -> InternedString {\n InternedString {\n symbol: Symbol::intern(self.string),\n }\n }\n\n pub fn get(&self) -> &'static str {\n self.string\n }\n}\n\nimpl ::std::convert::AsRef for LocalInternedString\nwhere\n str: ::std::convert::AsRef,\n{\n fn as_ref(&self) -> &U {\n self.string.as_ref()\n }\n}\n\nimpl> ::std::cmp::PartialEq for LocalInternedString {\n fn eq(&self, other: &T) -> bool {\n self.string == other.deref()\n }\n}\n\nimpl ::std::cmp::PartialEq for str {\n fn eq(&self, other: &LocalInternedString) -> bool {\n self == other.string\n }\n}\n\nimpl<'a> ::std::cmp::PartialEq for &'a str {\n fn eq(&self, other: &LocalInternedString) -> bool {\n *self == other.string\n }\n}\n\nimpl ::std::cmp::PartialEq for String {\n fn eq(&self, other: &LocalInternedString) -> bool {\n self == other.string\n }\n}\n\nimpl<'a> ::std::cmp::PartialEq for &'a String {\n fn eq(&self, other: &LocalInternedString) -> bool {\n *self == other.string\n }\n}\n\n//impl !Send for LocalInternedString {}\n//impl !Sync for LocalInternedString {}\n\nimpl ::std::ops::Deref for LocalInternedString {\n type Target = str;\n fn deref(&self) -> &str {\n self.string\n }\n}\n\nimpl fmt::Debug for LocalInternedString {\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n fmt::Debug::fmt(self.string, f)\n }\n}\n\nimpl fmt::Display for LocalInternedString {\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n fmt::Display::fmt(self.string, f)\n }\n}\n\n/// Represents a string stored in the string interner.\n#[derive(Clone, Copy, Eq)]\npub struct InternedString {\n symbol: Symbol,\n}\n\nimpl InternedString {\n pub fn with R, R>(self, f: F) -> R {\n let str = with_interner(|interner| interner.get(self.symbol) as *const str);\n // This is safe because the interner keeps string alive until it is dropped.\n // We can access it because we know the interner is still alive since we use a\n // scoped thread local to access it, and it was alive at the beginning of this scope\n unsafe { f(&*str) }\n }\n\n pub fn as_symbol(self) -> Symbol {\n self.symbol\n }\n\n pub fn as_str(self) -> LocalInternedString {\n self.symbol.as_str()\n }\n}\n\nimpl Hash for InternedString {\n fn hash(&self, state: &mut H) {\n self.with(|str| str.hash(state))\n }\n}\n\nimpl PartialOrd for InternedString {\n fn partial_cmp(&self, other: &InternedString) -> Option {\n if self.symbol == other.symbol {\n return Some(Ordering::Equal);\n }\n self.with(|self_str| other.with(|other_str| self_str.partial_cmp(other_str)))\n }\n}\n\nimpl Ord for InternedString {\n fn cmp(&self, other: &InternedString) -> Ordering {\n if self.symbol == other.symbol {\n return Ordering::Equal;\n }\n self.with(|self_str| other.with(|other_str| self_str.cmp(&other_str)))\n }\n}\n\nimpl> PartialEq for InternedString {\n fn eq(&self, other: &T) -> bool {\n self.with(|string| string == other.deref())\n }\n}\n\nimpl PartialEq for InternedString {\n fn eq(&self, other: &InternedString) -> bool {\n self.symbol == other.symbol\n }\n}\n\nimpl PartialEq for str {\n fn eq(&self, other: &InternedString) -> bool {\n other.with(|string| self == string)\n }\n}\n\nimpl<'a> PartialEq for &'a str {\n fn eq(&self, other: &InternedString) -> bool {\n other.with(|string| *self == string)\n }\n}\n\nimpl PartialEq for String {\n fn eq(&self, other: &InternedString) -> bool {\n other.with(|string| self == string)\n }\n}\n\nimpl<'a> PartialEq for &'a String {\n fn eq(&self, other: &InternedString) -> bool {\n other.with(|string| *self == string)\n }\n}\n\nimpl ::std::convert::From for String {\n fn from(val: InternedString) -> String {\n val.as_symbol().to_string()\n }\n}\n\nimpl fmt::Debug for InternedString {\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n self.with(|str| fmt::Debug::fmt(&str, f))\n }\n}\n\nimpl fmt::Display for InternedString {\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n self.with(|str| fmt::Display::fmt(&str, f))\n }\n}\n\n#[cfg(test)]\nmod tests {\n use super::*;\n\n #[test]\n fn interner_tests() {\n let mut i: Interner = Interner::default();\n // first one is zero:\n assert_eq!(i.intern(\"dog\"), Symbol::new(0));\n // re-use gets the same entry:\n assert_eq!(i.intern(\"dog\"), Symbol::new(0));\n // different string gets a different #:\n assert_eq!(i.intern(\"cat\"), Symbol::new(1));\n assert_eq!(i.intern(\"cat\"), Symbol::new(1));\n // dog is still at zero\n assert_eq!(i.intern(\"dog\"), Symbol::new(0));\n assert_eq!(i.gensym(\"zebra\"), Symbol::new(SymbolIndex::MAX_AS_U32));\n // gensym of same string gets new number:\n assert_eq!(i.gensym(\"zebra\"), Symbol::new(SymbolIndex::MAX_AS_U32 - 1));\n // gensym of *existing* string gets new number:\n assert_eq!(i.gensym(\"dog\"), Symbol::new(SymbolIndex::MAX_AS_U32 - 2));\n }\n\n #[test]\n fn interned_keywords_no_gaps() {\n let mut i = Interner::fresh();\n // Should already be interned with matching indexes\n for (sym, s) in symbols::DECLARED.iter() {\n assert_eq!(i.intern(&s), *sym)\n }\n // Should create a new symbol resulting in an index equal to the last entry in the table\n assert_eq!(i.intern(\"foo\").as_u32(), (i.names.len() - 1) as u32);\n }\n\n #[test]\n fn unquote_string() {\n let i = Ident::from_str(\"\\\"after\\\"\");\n assert_eq!(i.unquote_string().name, symbols::After);\n }\n\n #[test]\n fn unquote_atom() {\n let i = Ident::from_str(\"'after'\");\n assert_eq!(i.unquote_atom().name, symbols::After);\n }\n}\n" }, { "path": "libeir_interpreter/Cargo.toml", "content": "[package]\nname = \"libeir_interpreter\"\nversion = \"0.1.0\"\nauthors = [\"hansihe\"]\nedition = \"2018\"\nlicense = \"MIT OR Apache-2.0\"\n\n[features]\ndefault = [\"trace\"]\ntrace = []\n\n[dependencies]\nnum = \"0.2\"\nnum-traits = \"0.2\"\ntempdir = \"0.3\"\nlazy_static = \"1.2\"\n\nserde = { version = \"1.0\", features = [\"derive\"] }\nserde_json = \"1.0\"\n\nlibeir_ir = { path = \"../libeir_ir\" }\nlibeir_intern = { path = \"../libeir_intern\" }\nlibeir_util_binary = { path = \"../util/libeir_util_binary\" }\nlibeir_util_number = { path = \"../util/libeir_util_number\" }\n\nnum-bigint = { git = \"https://github.com/hansihe/num-bigint.git\" }\n\npretty = \"0.7\"\n\n#[dependencies.rug]\n#version = \"1.2\"\n#default-features = false\n#features = [\"integer\", \"float\", \"rand\"]\n" }, { "path": "libeir_interpreter/README.md", "content": "# libeir_interpreter\n\n**This interpreter is really basic and unfinished. It is only meant to aid testing.**\n\n" }, { "path": "libeir_interpreter/src/erl_lib/erlang.rs", "content": "use libeir_intern::Symbol;\nuse libeir_util_number::bigint_to_double;\n\nuse crate::module::{NativeModule, NativeReturn};\nuse crate::process::ProcessContext;\nuse crate::vm::VMState;\n\nuse crate::term::ListIteratorItem;\nuse crate::term::Term;\nuse crate::term::{ErlEq, ErlExactEq, ErlOrd};\n\nuse ::num_traits::Signed;\n\nuse std::rc::Rc;\n\nfn abs(_vm: &VMState, _proc: &mut ProcessContext, args: &[Rc]) -> NativeReturn {\n if args.len() != 1 {\n panic!()\n }\n let a1 = &*args[0];\n\n let ret = match a1 {\n Term::Integer(ref int) => Term::Integer(int.clone().abs()),\n Term::Float(flt) => Term::Float(flt.0.abs().into()),\n _ => panic!(),\n };\n\n NativeReturn::Return { term: ret.into() }\n}\n\nfn add(_vm: &VMState, _proc: &mut ProcessContext, args: &[Rc]) -> NativeReturn {\n // TODO: Verify semantics\n\n if args.len() != 2 {\n panic!();\n }\n let a1 = &*args[0];\n let a2 = &*args[1];\n\n match (a1, a2) {\n (Term::Integer(ref i1), Term::Integer(ref i2)) => NativeReturn::Return {\n term: Term::Integer(i1.clone() + i2).into(),\n },\n (Term::Integer(ref i1), Term::Float(f2)) => {\n let f1 = bigint_to_double(i1);\n NativeReturn::Return {\n term: Term::Float((f1 + f2.0).into()).into(),\n }\n }\n (Term::Float(f1), Term::Integer(ref i2)) => {\n let f2 = bigint_to_double(i2);\n NativeReturn::Return {\n term: Term::Float((f1.0 + f2).into()).into(),\n }\n }\n (Term::Float(f1), Term::Float(f2)) => NativeReturn::Return {\n term: Term::Float((f1.0 + f2.0).into()).into(),\n },\n _ => NativeReturn::Throw {\n typ: Term::new_atom(\"error\").into(),\n reason: Term::new_atom(\"badarith\").into(),\n },\n }\n}\n\nfn sub(_vm: &VMState, _proc: &mut ProcessContext, args: &[Rc]) -> NativeReturn {\n if args.len() != 2 {\n panic!();\n }\n let a1 = &*args[0];\n let a2 = &*args[1];\n\n match (a1, a2) {\n (Term::Integer(ref i1), Term::Integer(ref i2)) => NativeReturn::Return {\n term: Term::Integer(i1.clone() - i2).into(),\n },\n (Term::Integer(ref int), Term::Float(ref flt)) => {\n let flt_c = bigint_to_double(int);\n NativeReturn::Return {\n term: Term::Float((flt_c - flt.0).into()).into(),\n }\n }\n (Term::Float(ref flt), Term::Integer(ref int)) => {\n let flt_c = bigint_to_double(int);\n NativeReturn::Return {\n term: Term::Float((flt.0 - flt_c).into()).into(),\n }\n }\n (Term::Float(flt1), Term::Float(flt2)) => NativeReturn::Return {\n term: Term::Float((flt1.0 - flt2.0).into()).into(),\n },\n _ => NativeReturn::Throw {\n typ: Term::new_atom(\"error\").into(),\n reason: Term::new_atom(\"badarith\").into(),\n },\n }\n}\n\nfn invert(_vm: &VMState, _proc: &mut ProcessContext, args: &[Rc]) -> NativeReturn {\n if args.len() != 1 {\n panic!();\n }\n match &*args[0] {\n Term::Integer(ref i1) => NativeReturn::Return {\n term: Term::Integer(-i1.clone()).into(),\n },\n Term::Float(ref f1) => NativeReturn::Return {\n term: Term::Float((-f1.0).into()).into(),\n },\n _ => unimplemented!(),\n }\n}\n\nfn mul(_vm: &VMState, _proc: &mut ProcessContext, args: &[Rc]) -> NativeReturn {\n if args.len() != 2 {\n panic!();\n }\n let a1 = &*args[0];\n let a2 = &*args[1];\n\n match (a1, a2) {\n (Term::Integer(ref i1), Term::Integer(ref i2)) => NativeReturn::Return {\n term: Term::Integer(i1.clone() * i2).into(),\n },\n _ => unimplemented!(),\n }\n}\n\nfn div(_vm: &VMState, _proc: &mut ProcessContext, args: &[Rc]) -> NativeReturn {\n if args.len() != 2 {\n panic!();\n }\n\n let a1 = match &*args[0] {\n Term::Integer(i1) => bigint_to_double(i1),\n Term::Float(flt) => flt.0,\n _ => panic!(),\n };\n let a2 = match &*args[1] {\n Term::Integer(i1) => bigint_to_double(i1),\n Term::Float(flt) => flt.0,\n _ => panic!(),\n };\n\n NativeReturn::Return {\n term: Term::Float((a1 / a2).into()).into(),\n }\n}\n\nfn is_list(_vm: &VMState, _proc: &mut ProcessContext, args: &[Rc]) -> NativeReturn {\n if args.len() != 1 {\n panic!();\n }\n let a1 = &*args[0];\n\n match a1 {\n Term::ListCell(_, _) => NativeReturn::Return {\n term: Term::new_atom(\"true\").into(),\n },\n Term::Nil => NativeReturn::Return {\n term: Term::new_atom(\"true\").into(),\n },\n _ => NativeReturn::Return {\n term: Term::new_atom(\"false\").into(),\n },\n }\n}\n\nfn is_atom(_vm: &VMState, _proc: &mut ProcessContext, args: &[Rc]) -> NativeReturn {\n if args.len() != 1 {\n panic!();\n }\n let a1 = &*args[0];\n\n match a1 {\n Term::Atom(_) => NativeReturn::Return {\n term: Term::new_bool(true).into(),\n },\n _ => NativeReturn::Return {\n term: Term::new_bool(false).into(),\n },\n }\n}\n\nfn is_integer(_vm: &VMState, _proc: &mut ProcessContext, args: &[Rc]) -> NativeReturn {\n assert!(args.len() == 1);\n let a1 = &*args[0];\n match a1 {\n Term::Integer(_) => NativeReturn::Return {\n term: Term::new_bool(true).into(),\n },\n _ => NativeReturn::Return {\n term: Term::new_bool(false).into(),\n },\n }\n}\n\nfn is_pid(_vm: &VMState, _proc: &mut ProcessContext, args: &[Rc]) -> NativeReturn {\n assert!(args.len() == 1);\n let a1 = &*args[0];\n match a1 {\n Term::Pid(_) => NativeReturn::Return {\n term: Term::new_bool(true).into(),\n },\n _ => NativeReturn::Return {\n term: Term::new_bool(false).into(),\n },\n }\n}\n\nfn is_tuple(_vm: &VMState, _proc: &mut ProcessContext, args: &[Rc]) -> NativeReturn {\n assert!(args.len() == 1);\n let a1 = &*args[0];\n match a1 {\n Term::Tuple(_) => NativeReturn::Return {\n term: Term::new_bool(true).into(),\n },\n _ => NativeReturn::Return {\n term: Term::new_bool(false).into(),\n },\n }\n}\n\nfn is_map(_vm: &VMState, _proc: &mut ProcessContext, args: &[Rc]) -> NativeReturn {\n assert!(args.len() == 1);\n let a1 = &*args[0];\n match a1 {\n Term::Map(_) => NativeReturn::Return {\n term: Term::new_bool(true).into(),\n },\n _ => NativeReturn::Return {\n term: Term::new_bool(false).into(),\n },\n }\n}\n\n//fn list_append(_vm: &VMState, _proc: &mut ProcessContext, args: &[Rc]) -> NativeReturn {\n// // TODO: Validate semantics\n// assert!(args.len() == 2);\n// match (&*args[0], &*args[1]) {\n// (Term::Nil, Term::Nil) => NativeReturn::Return { term: Term::Nil.into() },\n// (Term::Nil, Term::List(_, _)) => NativeReturn::Return { term: args[1].clone() },\n// (Term::List(_, ref tail), Term::Nil) if tail.erl_eq(&Term::Nil)\n// => NativeReturn::Return { term: args[0].clone() },\n// (Term::List(ref _f_head, ref _f_tail), Term::List(ref b_head, ref b_tail)) => {\n// let (mut f_head_terms, f_tail_term) = args[0].as_inproper_list();\n// if let Term::Nil = f_tail_term {\n// f_head_terms.extend(b_head.iter().cloned());\n// NativeReturn::Return { term: Term::List(f_head_terms, b_tail.clone()).into() }\n// } else {\n// NativeReturn::Throw\n// }\n// }\n// _ => NativeReturn::Throw,\n// }\n//}\nfn list_subtract(_vm: &VMState, _proc: &mut ProcessContext, args: &[Rc]) -> NativeReturn {\n let (mut to_remove_vec, tail) = Term::as_inproper_list(&args[1]);\n assert!(tail.erl_eq(&Term::Nil));\n\n let mut out = Vec::new();\n for item in Term::list_iter(&args[0]) {\n match item {\n ListIteratorItem::Elem(elem) => {\n if let Some(idx) = to_remove_vec\n .iter()\n .enumerate()\n .find(|(_, term)| elem.erl_eq(term))\n .map(|(idx, _)| idx)\n {\n to_remove_vec.remove(idx);\n } else {\n out.push(elem);\n }\n }\n ListIteratorItem::Tail(tail) => {\n assert!(tail.erl_eq(&Term::Nil));\n return NativeReturn::Return {\n term: Term::slice_to_list(&out, tail.clone()),\n };\n }\n }\n }\n\n unreachable!()\n}\n\nfn exact_eq(_vm: &VMState, _proc: &mut ProcessContext, args: &[Rc]) -> NativeReturn {\n assert!(args.len() == 2);\n NativeReturn::Return {\n term: Term::new_bool(args[0].erl_exact_eq(&*args[1])).into(),\n }\n}\nfn exact_not_eq(_vm: &VMState, _proc: &mut ProcessContext, args: &[Rc]) -> NativeReturn {\n assert!(args.len() == 2);\n NativeReturn::Return {\n term: Term::new_bool(!args[0].erl_exact_eq(&*args[1])).into(),\n }\n}\n\nfn and(_vm: &VMState, _proc: &mut ProcessContext, args: &[Rc]) -> NativeReturn {\n assert!(args.len() == 2);\n if let (Some(a1), Some(a2)) = (args[0].as_boolean(), args[1].as_boolean()) {\n NativeReturn::Return {\n term: Term::new_bool(a1 && a2).into(),\n }\n } else {\n panic!()\n }\n}\n\nfn or(_vm: &VMState, _proc: &mut ProcessContext, args: &[Rc]) -> NativeReturn {\n assert!(args.len() == 2);\n if let (Some(a1), Some(a2)) = (args[0].as_boolean(), args[1].as_boolean()) {\n NativeReturn::Return {\n term: Term::new_bool(a1 || a2).into(),\n }\n } else {\n panic!()\n }\n}\n\nfn tuple_size(_vm: &VMState, _proc: &mut ProcessContext, args: &[Rc]) -> NativeReturn {\n assert!(args.len() == 1);\n if let Term::Tuple(ref terms) = &*args[0] {\n NativeReturn::Return {\n term: Term::new_i64(terms.len() as i64).into(),\n }\n } else {\n panic!()\n }\n}\n\nfn is_function(_vm: &VMState, _proc: &mut ProcessContext, args: &[Rc]) -> NativeReturn {\n assert!(args.len() == 1 || args.len() == 2);\n\n let arity_ref = if args.len() == 2 {\n if let Some(int) = args[1].as_i64() {\n Some(int)\n } else {\n panic!()\n }\n } else {\n None\n };\n\n if let Term::CapturedFunction { ident, .. } = &*args[0] {\n let res = arity_ref.map(|a| a == ident.arity as i64).unwrap_or(true);\n NativeReturn::Return {\n term: Term::new_bool(res).into(),\n }\n } else if let Term::BoundLambda { ident, .. } = &*args[0] {\n let res = arity_ref.map(|a| a == ident.arity as i64).unwrap_or(true);\n NativeReturn::Return {\n term: Term::new_bool(res).into(),\n }\n } else {\n NativeReturn::Return {\n term: Term::new_bool(false).into(),\n }\n }\n}\n\n//fn base_spawn(vm: &VMState, ident: &FunctionIdent, args: Vec) -> Pid {\n// let new_pid = {\n// let mut processes = vm.processes.borrow();\n// Pid(processes.len())\n// };\n//\n// let process = ProcessContext::new(new_pid);\n//\n// let orig_pid = crate::trace::get_pid();\n// crate::trace::set_pid(new_pid);\n// let frame = process.make_call_stackframe(\n// vm,\n// ident.module.clone(),\n// ident.clone(),\n// args\n// );\n// crate::trace::set_pid(orig_pid);\n//\n// let stack_i = process.stack.clone();\n// let mut stack = stack_i.borrow_mut();\n// stack.push(frame);\n//\n// {\n// let mut processes = vm.processes.borrow_mut();\n// processes.push(Rc::new(RefCell::new(process)));\n// }\n//\n// {\n// let mut mailboxes = vm.mailboxes.borrow_mut();\n// mailboxes.insert(new_pid, ::mailbox::Mailbox::new());\n// }\n//\n// new_pid\n//}\n//\n//fn base_spawn_term(vm: &VMState, callable: &Term, mut args: Vec) -> Pid {\n// match callable {\n// Term::CapturedFunction { module, fun_name, arity } => {\n// let ident = FunctionIdent {\n// module: module.clone(),\n// name: fun_name.clone(),\n// arity: *arity,\n// lambda: None,\n// };\n// base_spawn(vm, &ident, args)\n// }\n// Term::BoundLambda { module, fun_name, arity, lambda, bound_env } => {\n// let ident = FunctionIdent {\n// module: module.clone(),\n// name: fun_name.clone(),\n// arity: *arity,\n// lambda: Some(*lambda),\n// };\n// args.insert(0, Term::LambdaEnv(bound_env.clone()));\n// base_spawn(vm, &ident, args)\n// },\n// _ => panic!(),\n// }\n//}\n//\n//fn base_monitor(vm: &VMState, proc: &mut ProcessContext, other: Pid) -> Reference {\n// let monitor_ref = vm.ref_gen.borrow_mut().next();\n// let mut watches = vm.watches.borrow_mut();\n//\n// if !watches.contains_key(&other) {\n// watches.insert(other, Vec::new());\n// }\n// let for_proc = watches.get_mut(&other).unwrap();\n//\n// for_proc.push((proc.pid, WatchType::Monitor(monitor_ref)));\n//\n// monitor_ref\n//}\n//\n//fn spawn_1(vm: &VMState, _proc: &mut ProcessContext, args: &[Rc]) -> NativeReturn {\n// assert!(args.len() == 1);\n// let fun_term = &*args[0];\n//\n// let new_pid = base_spawn_term(vm, fun_term, vec![]);\n// NativeReturn::Return { term: Term::Pid(new_pid) }\n//}\n//\n//fn spawn_monitor_1(vm: &VMState, proc: &mut ProcessContext, args: &[Rc]) -> NativeReturn {\n// assert!(args.len() == 1);\n// let fun_term = &*args[0];\n//\n// let new_pid = base_spawn_term(vm, fun_term, vec![]);\n// let monitor_ref = base_monitor(vm, proc, new_pid);\n//\n// let term = Term::Tuple(vec![\n// Term::Pid(new_pid),\n// Term::Reference(monitor_ref),\n// ]);\n// NativeReturn::Return { term: term }\n//}\n//\n//fn monitor_2(vm: &VMState, proc: &mut ProcessContext, args: &[Rc]) -> NativeReturn {\n// assert!(args.len() == 2);\n// if args[0].erl_eq(&Term::new_atom(\"process\")) {\n// if let Term::Pid(pid) = args[1] {\n// let monitor_ref = base_monitor(vm, proc, pid);\n// NativeReturn::Return { term: Term::Reference(monitor_ref) }\n// } else {\n// NativeReturn::Throw\n// }\n// } else {\n// unimplemented!()\n// }\n//}\n\nfn not(_vm: &VMState, _proc: &mut ProcessContext, args: &[Rc]) -> NativeReturn {\n assert!(args.len() == 1);\n if let Some(b) = args[0].as_boolean() {\n NativeReturn::Return {\n term: Term::new_bool(!b).into(),\n }\n } else {\n panic!()\n }\n}\n\nfn is_binary(_vm: &VMState, _proc: &mut ProcessContext, args: &[Rc]) -> NativeReturn {\n assert!(args.len() == 1);\n let a1 = &*args[0];\n\n match a1 {\n Term::Binary(_) => NativeReturn::Return {\n term: Term::new_bool(true).into(),\n },\n Term::BinarySlice { .. } => NativeReturn::Return {\n term: Term::new_bool(true).into(),\n },\n _ => NativeReturn::Return {\n term: Term::new_bool(false).into(),\n },\n }\n}\n\nfn atom_to_list(_vm: &VMState, _proc: &mut ProcessContext, args: &[Rc]) -> NativeReturn {\n assert!(args.len() == 1);\n let a1 = &*args[0];\n\n match a1 {\n Term::Atom(atom) => {\n let chars: Vec<_> = atom\n .as_str()\n .chars()\n .map(|c| Term::new_i64(c as i64).into())\n .collect();\n NativeReturn::Return {\n term: Term::slice_to_list(&chars, Term::Nil.into()).into(),\n }\n }\n _ => panic!(),\n }\n}\n\nfn less_than_or_equal(\n _vm: &VMState,\n _proc: &mut ProcessContext,\n args: &[Rc],\n) -> NativeReturn {\n assert!(args.len() == 2);\n let a1 = &*args[0];\n let a2 = &*args[1];\n let ord = a1.erl_ord(a2);\n NativeReturn::Return {\n term: Term::new_bool(ord != std::cmp::Ordering::Greater).into(),\n }\n}\nfn less_than(_vm: &VMState, _proc: &mut ProcessContext, args: &[Rc]) -> NativeReturn {\n assert!(args.len() == 2);\n let a1 = &*args[0];\n let a2 = &*args[1];\n let ord = a1.erl_ord(a2);\n NativeReturn::Return {\n term: Term::new_bool(ord == std::cmp::Ordering::Less).into(),\n }\n}\nfn greater_than_or_equal(\n _vm: &VMState,\n _proc: &mut ProcessContext,\n args: &[Rc],\n) -> NativeReturn {\n assert!(args.len() == 2);\n let a1 = &*args[0];\n let a2 = &*args[1];\n let ord = a1.erl_ord(a2);\n NativeReturn::Return {\n term: Term::new_bool(ord != std::cmp::Ordering::Less).into(),\n }\n}\nfn greater_than(_vm: &VMState, _proc: &mut ProcessContext, args: &[Rc]) -> NativeReturn {\n assert!(args.len() == 2);\n let a1 = &*args[0];\n let a2 = &*args[1];\n let ord = a1.erl_ord(a2);\n NativeReturn::Return {\n term: Term::new_bool(ord == std::cmp::Ordering::Greater).into(),\n }\n}\n\nfn setelement(_vm: &VMState, _proc: &mut ProcessContext, args: &[Rc]) -> NativeReturn {\n assert!(args.len() == 3);\n let idx = if let Some(num) = args[0].as_usize() {\n num\n } else {\n panic!()\n };\n let value = args[2].clone();\n if let Term::Tuple(vals) = &*args[1] {\n if idx == 0 || idx > vals.len() {\n panic!()\n } else {\n let mut vals = vals.clone();\n vals[idx - 1] = value;\n NativeReturn::Return {\n term: Term::Tuple(vals).into(),\n }\n }\n } else {\n panic!()\n }\n}\nfn element(_vm: &VMState, _proc: &mut ProcessContext, args: &[Rc]) -> NativeReturn {\n assert!(args.len() == 2);\n let idx = if let Some(num) = args[0].as_usize() {\n num\n } else {\n panic!()\n };\n if let Term::Tuple(vals) = &*args[1] {\n if idx == 0 || idx > vals.len() {\n panic!()\n } else {\n NativeReturn::Return {\n term: vals[idx - 1].clone(),\n }\n }\n } else {\n panic!()\n }\n}\n\nfn erl_self(_vm: &VMState, proc: &mut ProcessContext, args: &[Rc]) -> NativeReturn {\n assert!(args.len() == 0);\n NativeReturn::Return {\n term: Term::Pid(proc.pid).into(),\n }\n}\n\n//fn process_flag(vm: &VMState, proc: &mut ProcessContext, args: &[Rc]) -> NativeReturn {\n// assert!(args.len() == 2);\n// if args[0].erl_eq(&Term::new_atom(\"trap_exit\")) {\n// let mut mailboxes = vm.mailboxes.borrow_mut();\n// let mailbox = &mut mailboxes.get_mut(&proc.pid).unwrap();\n// let old_trap_exits = mailbox.get_trap_exits();\n// mailbox.set_trap_exits(args[1].as_boolean().unwrap());\n// NativeReturn::Return { term: Term::new_bool(old_trap_exits).into() }\n// } else {\n// unimplemented!()\n// }\n//}\n\nfn put(_vm: &VMState, proc: &mut ProcessContext, args: &[Rc]) -> NativeReturn {\n assert!(args.len() == 2);\n if let Some(entry) = proc.dict.iter_mut().find(|e| e.0.erl_exact_eq(&args[0])) {\n let old = entry.1.clone();\n entry.1 = args[1].clone();\n NativeReturn::Return { term: old }\n } else {\n proc.dict.push((args[0].clone(), args[1].clone()));\n NativeReturn::Return {\n term: Term::new_atom(\"undefined\").into(),\n }\n }\n}\n\nfn get(_vm: &VMState, proc: &mut ProcessContext, args: &[Rc]) -> NativeReturn {\n assert!(args.len() == 1);\n if let Some(entry) = proc.dict.iter().find(|e| e.0.erl_exact_eq(&args[0])) {\n NativeReturn::Return {\n term: entry.1.clone(),\n }\n } else {\n NativeReturn::Return {\n term: Term::new_atom(\"undefined\").into(),\n }\n }\n}\n\nfn erase(_vm: &VMState, proc: &mut ProcessContext, args: &[Rc]) -> NativeReturn {\n assert!(args.len() == 1);\n let idx = proc\n .dict\n .iter()\n .enumerate()\n .find(|e| (e.1).0.erl_exact_eq(&args[0]))\n .map(|(idx, _)| idx);\n if let Some(entry) = idx {\n let (_key, val) = proc.dict.remove(entry);\n NativeReturn::Return { term: val }\n } else {\n NativeReturn::Return {\n term: Term::new_atom(\"undefined\").into(),\n }\n }\n}\n\nfn length(_vm: &VMState, _proc: &mut ProcessContext, args: &[Rc]) -> NativeReturn {\n assert!(args.len() == 1);\n let mut len = 0;\n for item in Term::list_iter(&args[0]) {\n match item {\n ListIteratorItem::Elem(_) => {\n len += 1;\n }\n ListIteratorItem::Tail(tail) => {\n if tail.erl_eq(&Term::Nil) {\n return NativeReturn::Return {\n term: Term::new_i64(len as i64).into(),\n };\n } else {\n return NativeReturn::Throw {\n typ: Term::new_atom(\"error\").into(),\n reason: Term::new_atom(\"badarg\").into(),\n };\n }\n }\n }\n }\n unreachable!()\n}\n\nfn hd(_vm: &VMState, _proc: &mut ProcessContext, args: &[Rc]) -> NativeReturn {\n if args.len() != 1 {\n panic!();\n }\n let a1 = &*args[0];\n\n match a1 {\n Term::ListCell(hd, _) => NativeReturn::Return { term: hd.clone() },\n _ => NativeReturn::Throw {\n typ: Term::new_atom(\"error\").into(),\n reason: Term::new_atom(\"badarg\").into(),\n },\n }\n}\nfn tl(_vm: &VMState, _proc: &mut ProcessContext, args: &[Rc]) -> NativeReturn {\n if args.len() != 1 {\n panic!();\n }\n let a1 = &*args[0];\n\n match a1 {\n Term::ListCell(_, tl) => NativeReturn::Return { term: tl.clone() },\n _ => NativeReturn::Throw {\n typ: Term::new_atom(\"error\").into(),\n reason: Term::new_atom(\"badarg\").into(),\n },\n }\n}\n\nfn map_size(_vm: &VMState, _proc: &mut ProcessContext, args: &[Rc]) -> NativeReturn {\n assert!(args.len() == 1);\n if let Some(map) = args[0].as_map() {\n NativeReturn::Return {\n term: Term::new_usize(map.len()).into(),\n }\n } else {\n unimplemented!()\n }\n}\n\npub fn make_erlang() -> NativeModule {\n let mut module = NativeModule::new(Symbol::intern(\"erlang\"));\n module.add_fun(Symbol::intern(\"+\"), 2, Box::new(add));\n module.add_fun(Symbol::intern(\"-\"), 1, Box::new(invert));\n module.add_fun(Symbol::intern(\"-\"), 2, Box::new(sub));\n module.add_fun(Symbol::intern(\"*\"), 2, Box::new(mul));\n module.add_fun(Symbol::intern(\"/\"), 2, Box::new(div));\n module.add_fun(Symbol::intern(\"abs\"), 1, Box::new(abs));\n //module.add_fun(Symbol::intern(\"++\"), 2, Box::new(list_append));\n module.add_fun(Symbol::intern(\"--\"), 2, Box::new(list_subtract));\n module.add_fun(Symbol::intern(\"=:=\"), 2, Box::new(exact_eq));\n module.add_fun(Symbol::intern(\"=/=\"), 2, Box::new(exact_not_eq));\n module.add_fun(Symbol::intern(\"=<\"), 2, Box::new(less_than_or_equal));\n module.add_fun(Symbol::intern(\"<\"), 2, Box::new(less_than));\n module.add_fun(Symbol::intern(\">=\"), 2, Box::new(greater_than_or_equal));\n module.add_fun(Symbol::intern(\">\"), 2, Box::new(greater_than));\n module.add_fun(Symbol::intern(\"is_list\"), 1, Box::new(is_list));\n module.add_fun(Symbol::intern(\"is_atom\"), 1, Box::new(is_atom));\n module.add_fun(Symbol::intern(\"is_binary\"), 1, Box::new(is_binary));\n module.add_fun(Symbol::intern(\"is_integer\"), 1, Box::new(is_integer));\n module.add_fun(Symbol::intern(\"is_pid\"), 1, Box::new(is_pid));\n module.add_fun(Symbol::intern(\"is_tuple\"), 1, Box::new(is_tuple));\n module.add_fun(Symbol::intern(\"is_map\"), 1, Box::new(is_map));\n module.add_fun(Symbol::intern(\"and\"), 2, Box::new(and));\n module.add_fun(Symbol::intern(\"or\"), 2, Box::new(or));\n module.add_fun(Symbol::intern(\"tuple_size\"), 1, Box::new(tuple_size));\n module.add_fun(Symbol::intern(\"is_function\"), 1, Box::new(is_function));\n module.add_fun(Symbol::intern(\"is_function\"), 2, Box::new(is_function));\n //module.add_fun(Symbol::intern(\"spawn_monitor\"), 1, Box::new(spawn_monitor_1));\n module.add_fun(Symbol::intern(\"not\"), 1, Box::new(not));\n module.add_fun(Symbol::intern(\"atom_to_list\"), 1, Box::new(atom_to_list));\n module.add_fun(Symbol::intern(\"setelement\"), 3, Box::new(setelement));\n module.add_fun(Symbol::intern(\"element\"), 2, Box::new(element));\n module.add_fun(Symbol::intern(\"length\"), 1, Box::new(length));\n module.add_fun(Symbol::intern(\"self\"), 0, Box::new(erl_self));\n module.add_fun(Symbol::intern(\"put\"), 2, Box::new(put));\n module.add_fun(Symbol::intern(\"get\"), 1, Box::new(get));\n module.add_fun(Symbol::intern(\"erase\"), 1, Box::new(erase));\n module.add_fun(Symbol::intern(\"hd\"), 1, Box::new(hd));\n module.add_fun(Symbol::intern(\"tl\"), 1, Box::new(tl));\n module.add_fun(Symbol::intern(\"map_size\"), 1, Box::new(map_size));\n //module.add_fun(Symbol::intern(\"spawn\"), 1, Box::new(spawn_1));\n //module.add_fun(Symbol::intern(\"monitor\"), 2, Box::new(monitor_2));\n //module.add_fun(Symbol::intern(\"process_flag\"), 2, Box::new(process_flag));\n module\n}\n" }, { "path": "libeir_interpreter/src/erl_lib/file.rs", "content": "use ::module::NativeModule;\nuse ::vm::VMState;\nuse ::term::Term;\nuse ::process::{ CallReturn, ProcessContext };\n\nfn delete(_vm: &VMState, _proc: &mut ProcessContext, args: &[Term]) -> CallReturn {\n assert!(args.len() == 1);\n // TODO\n let n = vec![Term::new_atom(\"error\"), Term::new_atom(\"enoent\")];\n CallReturn::Return { term: Term::Tuple(n) }\n}\n\npub fn make_time() -> NativeModule {\n let mut module = NativeModule::new(\"file\".to_string());\n module.add_fun(\"delete\".to_string(), 1, Box::new(delete));\n module\n}\n" }, { "path": "libeir_interpreter/src/erl_lib/lists.rs", "content": "use std::rc::Rc;\n\nuse crate::module::{NativeModule, NativeReturn};\nuse crate::process::ProcessContext;\nuse crate::term::{ErlEq, Term};\nuse crate::vm::VMState;\n\nuse libeir_intern::Symbol;\n\n//fn member_list(item: &Term, list: &Term) -> NativeReturn {\n// if let Term::Nil = list {\n// NativeReturn::Return { term: Term::new_bool(false).into() }\n// } else if let Term::List(ref head, ref tail) = list {\n// for l_item in head {\n// if item.erl_exact_eq(l_item) {\n// return NativeReturn::Return { term: Term::new_bool(true).into() };\n// }\n// }\n// member_list(item, tail)\n// } else {\n// NativeReturn::Throw\n// }\n//}\n//\n//fn member(_vm: &VMState, _proc: &mut ProcessContext, args: &[Rc]) -> NativeReturn {\n// assert!(args.len() == 2);\n// member_list(&args[0], &args[1])\n//}\n//\nfn reverse_2(_vm: &VMState, _proc: &mut ProcessContext, args: &[Rc]) -> NativeReturn {\n assert!(args.len() == 2);\n\n let (mut head, tail) = Term::as_inproper_list(&args[0]);\n assert!(tail.erl_eq(&Term::Nil));\n\n head.reverse();\n NativeReturn::Return {\n term: Term::slice_to_list(&head, args[1].clone()),\n }\n}\n\nfn reverse_1(vm: &VMState, proc: &mut ProcessContext, args: &[Rc]) -> NativeReturn {\n assert!(args.len() == 1);\n reverse_2(vm, proc, &[args[0].clone(), Term::Nil.into()])\n}\n\n//fn keyfind(_vm: &VMState, _proc: &mut ProcessContext, args: &[Rc]) -> NativeReturn {\n// assert!(args.len() == 3);\n// let key = &*args[0];\n// let pos = if let Some(int) = args[1].as_i64() {\n// int\n// } else {\n// return NativeReturn::Throw;\n// };\n// let list_term = &*args[2];\n// let (list, list_tail) = list_term.as_inproper_list();\n// for term in list.iter() {\n// if let Term::Tuple(values) = &**term {\n// if let Some(val_term) = values.get(pos as usize) {\n// if val_term.erl_eq(key) {\n// return NativeReturn::Return { term: term.clone() };\n// }\n// }\n// }\n// }\n// if let Term::Nil = list_tail {\n// NativeReturn::Return { term: Term::new_bool(false).into() }\n// } else {\n// NativeReturn::Throw\n// }\n//}\n\npub fn make_lists() -> NativeModule {\n let mut module = NativeModule::new(Symbol::intern(\"lists\"));\n //module.add_fun(Symbol::intern(\"member\"), 2, Box::new(member));\n module.add_fun(Symbol::intern(\"reverse\"), 1, Box::new(reverse_1));\n module.add_fun(Symbol::intern(\"reverse\"), 2, Box::new(reverse_2));\n //module.add_fun(Symbol::intern(\"keyfind\"), 3, Box::new(keyfind));\n module\n}\n" }, { "path": "libeir_interpreter/src/erl_lib/maps.rs", "content": "use libeir_intern::Symbol;\n\nuse crate::module::{NativeModule, NativeReturn};\nuse crate::process::ProcessContext;\nuse crate::vm::VMState;\n\nuse crate::term::{ListIteratorItem, MapTerm, Term};\n\nuse std::rc::Rc;\n\nfn new_0(_vm: &VMState, _proc: &mut ProcessContext, args: &[Rc]) -> NativeReturn {\n assert!(args.len() == 0);\n NativeReturn::Return {\n term: Term::Map(MapTerm::new()).into(),\n }\n}\n\nfn from_list_1(_vm: &VMState, _proc: &mut ProcessContext, args: &[Rc]) -> NativeReturn {\n assert!(args.len() == 1);\n let mut map = MapTerm::new();\n\n for elem in Term::list_iter(&args[0]) {\n match elem {\n ListIteratorItem::Elem(tup_term) => {\n let tup = tup_term.as_tuple().unwrap();\n assert!(tup.len() == 2);\n map.insert(tup[0].clone(), tup[1].clone());\n }\n ListIteratorItem::Tail(term) => {\n assert!(term.is_nil());\n }\n }\n }\n\n NativeReturn::Return {\n term: Term::Map(map).into(),\n }\n}\n\npub fn make_maps() -> NativeModule {\n let mut module = NativeModule::new(Symbol::intern(\"maps\"));\n module.add_fun(Symbol::intern(\"new\"), 0, Box::new(new_0));\n module.add_fun(Symbol::intern(\"from_list\"), 1, Box::new(from_list_1));\n module\n}\n" }, { "path": "libeir_interpreter/src/erl_lib/math.rs", "content": "use std::rc::Rc;\n\nuse crate::module::{NativeModule, NativeReturn};\nuse crate::process::ProcessContext;\nuse crate::term::Term;\nuse crate::vm::VMState;\n\nuse libeir_intern::Symbol;\n\nuse num_traits::{Pow, ToPrimitive};\n\nfn pow(_vm: &VMState, _proc: &mut ProcessContext, args: &[Rc]) -> NativeReturn {\n assert!(args.len() == 2);\n\n let a1 = &*args[0];\n let a2 = &*args[1];\n\n let ret = match (a1, a2) {\n (Term::Integer(ref i1), Term::Integer(ref i2)) => {\n Term::Integer(i1.clone().pow(i2.to_u32().unwrap()))\n }\n //Term::Integer(num::pow::pow(i1.clone(), i2.to_usize().unwrap())),\n _ => unimplemented!(),\n };\n\n NativeReturn::Return { term: ret.into() }\n}\n\npub fn make_math() -> NativeModule {\n let mut module = NativeModule::new(Symbol::intern(\"math\"));\n module.add_fun(Symbol::intern(\"pow\"), 2, Box::new(pow));\n module\n}\n" }, { "path": "libeir_interpreter/src/erl_lib/mod.rs", "content": "mod erlang;\npub use self::erlang::make_erlang;\n\n//mod os;\n//pub use self::os::make_os;\n\nmod lists;\npub use self::lists::make_lists;\n\nmod math;\npub use self::math::make_math;\n\n//mod file;\n//pub use self::file::make_time;\n\nmod maps;\npub use self::maps::make_maps;\n" }, { "path": "libeir_interpreter/src/erl_lib/os.rs", "content": "use ::vm::VMState;\nuse ::module::NativeModule;\nuse ::term::Term;\nuse ::process::{ CallReturn, ProcessContext };\n\nfn getenv(_vm: &VMState, _proc: &mut ProcessContext, args: &[Term]) -> CallReturn {\n if args.len() == 1 {\n CallReturn::Return { term: Term::new_bool(false) }\n } else {\n CallReturn::Throw\n }\n}\n\nfn os_type(_vm: &VMState, _proc: &mut ProcessContext, args: &[Term]) -> CallReturn {\n assert!(args.len() == 0);\n // TODO\n let family = Term::new_atom(\"unix\");\n let name = Term::new_atom(\"linux\");\n CallReturn::Return { term: Term::Tuple(vec![family, name]) }\n}\n\npub fn make_os() -> NativeModule {\n let mut module = NativeModule::new(\"os\".to_string());\n module.add_fun(\"getenv\".to_string(), 1, Box::new(getenv));\n module.add_fun(\"type\".to_string(), 0, Box::new(os_type));\n module\n}\n" }, { "path": "libeir_interpreter/src/erl_tests/mod.rs", "content": "extern crate tempdir;\n\nuse ::std::io::{ Read, Write };\nuse ::{ VMState, Term };\nuse eir::Module;\nuse ::term::ErlEq;\n\nfn erl_to_core(erlang_code: &str) -> String {\n let temp = tempdir::TempDir::new(\"core_erlang_crate_tests\").unwrap();\n let temp_dir = temp.path();\n println!(\"Compilation dir: {:?}\", temp_dir);\n\n {\n let in_file_name = temp_dir.join(\"code.erl\");\n let mut in_file = ::std::fs::File::create(in_file_name).unwrap();\n in_file.write_all(erlang_code.as_bytes()).unwrap();\n }\n\n let out = ::std::process::Command::new(\"erlc\")\n .arg(\"+to_core\")\n .arg(\"code.erl\")\n .current_dir(temp_dir.clone())\n .output()\n .expect(\"failed to execute erlc\");\n println!(\"{:?}\", out);\n assert!(out.status.success());\n\n let out_file_name = temp_dir.join(\"code.core\");\n let mut out_file = ::std::fs::File::open(out_file_name).unwrap();\n let mut out_core = String::new();\n out_file.read_to_string(&mut out_core).unwrap();\n\n println!(\"====== Core ======\\n{}\\n==================\\n\\n\", out_core);\n\n out_core\n}\n\nfn erl_to_ir(erlang_code: &str) -> Module {\n let core = erl_to_core(erlang_code);\n\n let parsed = ::core_erlang_compiler::parser::parse(&core).unwrap();\n let ir = ::core_erlang_compiler::ir::from_parsed(&parsed.0);\n\n //println!(\"Ir:\\n{:?}\", ir);\n\n ir\n}\n\nfn ctx_from_erl(erlang_code: &str) -> VMState {\n let module = erl_to_ir(erlang_code);\n\n let mut ctx = VMState::new();\n\n ctx.add_native_module(::erl_lib::make_erlang());\n ctx.add_erlang_module(module);\n\n ctx\n}\n\nconst TEST_ERL_1: &str = r##\"\n-module(test).\n-export([add/2, add_two/3, return_closure/1]).\n\nadd(A, B) ->\n A + B.\n\nadd_two(A, B, C) ->\n I = add(A, B),\n add(I, C).\n\nreturn_closure(I) ->\n O = 1,\n fun(A) ->\n add(add(I, A), O)\n end.\n\nadd_with_closure(A, B) ->\n F = return_closure(A),\n F(B).\n\nmatching([], []) ->\n one;\nmatching([], _) ->\n two;\nmatching(_, []) ->\n three;\nmatching(A, B) ->\n {A, B}.\n\n \"##;\n\n\n#[test]\nfn simple_add() {\n let mut ctx = ctx_from_erl(TEST_ERL_1);\n\n let args = vec![Term::new_i64(1), Term::new_i64(2)];\n let result = ctx.call(\"test\", \"add\", args);\n\n assert!(result.unwrap_return().erl_eq(&Term::Integer(3.into())));\n}\n\n#[test]\nfn simple_function_call() {\n let mut ctx = ctx_from_erl(TEST_ERL_1);\n\n let args = vec![Term::new_i64(1), Term::new_i64(2), Term::new_i64(3)];\n let result = ctx.call(\"test\", \"add_two\", args);\n\n assert!(result.unwrap_return().erl_eq(&Term::Integer(6.into())));\n}\n\n#[test]\nfn simple_lambda() {\n let mut ctx = ctx_from_erl(TEST_ERL_1);\n\n let args = vec![Term::new_i64(1), Term::new_i64(2)];\n let result = ctx.call(\"test\", \"add_with_closure\", args);\n\n assert!(result.unwrap_return().erl_eq(&Term::Integer(4.into())));\n}\n\n#[test]\nfn simple_pattern_match() {\n let mut ctx = ctx_from_erl(TEST_ERL_1);\n\n let args = vec![Term::new_i64(1), Term::new_i64(2)];\n let result = ctx.call(\"test\", \"matching\", args);\n assert!(result.unwrap_return().erl_eq(&Term::Tuple(vec![\n Term::new_i64(1),\n Term::new_i64(2),\n ])));\n\n let args = vec![Term::Nil, Term::Nil];\n let result = ctx.call(\"test\", \"matching\", args);\n assert!(result.unwrap_return().erl_eq(&Term::new_atom(\"one\")));\n}\n\nconst FACTORIAL_ERL: &str = r##\"\n-module(test).\n-export([factorial/1]).\n\nfactorial(0) -> 1;\nfactorial(N) -> N * factorial(N-1).\n\n \"##;\n\n#[test]\nfn factorial() {\n let mut ctx = ctx_from_erl(FACTORIAL_ERL);\n\n let args = vec![Term::new_i64(10)];\n let result = ctx.call(\"test\", \"factorial\", args);\n\n println!(\"Res: {:?}\", result);\n}\n\n//#[test]\nfn long_strings() {\n let mut ctx = VMState::new();\n\n let mut f = ::std::fs::File::open(\"../test_data/long_strings.core\")\n .unwrap();\n let mut core = String::new();\n f.read_to_string(&mut core).unwrap();\n\n println!(\"Parsing\");\n let parsed = ::core_erlang_compiler::parser::parse(&core).unwrap();\n\n}\n\nfn compile_core_file(path: &str) -> Module {\n let mut f = ::std::fs::File::open(path)\n .unwrap();\n let mut core = String::new();\n f.read_to_string(&mut core).unwrap();\n let parsed = ::core_erlang_compiler::parser::parse(&core).unwrap();\n ::core_erlang_compiler::ir::from_parsed(&parsed.0)\n}\n\n#[test]\nfn compiler() {\n let result = std::panic::catch_unwind(|| {\n let mut ctx = VMState::new();\n\n ctx.add_native_module(::erl_lib::make_erlang());\n ctx.add_native_module(::erl_lib::make_os());\n ctx.add_native_module(::erl_lib::make_time());\n\n ctx.add_erlang_module(compile_core_file(\n \"../otp/lib/compiler/ebin/compile.core\"));\n ctx.add_erlang_module(compile_core_file(\n \"../otp/lib/stdlib/ebin/proplists.core\"));\n //\"/home/hansihe/proj/checkout/otp/lib/stdlib/ebin/proplists.core\"));\n ctx.add_erlang_module(compile_core_file(\n \"../otp/lib/stdlib/ebin/filename.core\"));\n //\"/home/hansihe/proj/checkout/otp/lib/stdlib/ebin/filename.core\"));\n ctx.add_erlang_module(compile_core_file(\n \"../otp/lib/stdlib/ebin/epp.core\"));\n\n ctx.add_erlang_module(compile_core_file(\n \"../otp/lib/stdlib/ebin/lists.core\"));\n //\"/home/hansihe/proj/checkout/otp/lib/stdlib/ebin/lists.core\"));\n ctx.add_nif_overlay(::erl_lib::make_lists());\n\n let args = vec![Term::new_atom(\"foo.erl\")];\n ctx.call(\"compile\", \"file\", args);\n });\n ::trace::dump_trace(\"trace.json\".to_string());\n assert!(result.is_ok());\n}\n" }, { "path": "libeir_interpreter/src/lib.rs", "content": "//#![deny(warnings)]\n\n//! LIR interpreter with zero consideration of performance.\n//! Made as an experiment to narrow down relevant implementation\n//! details.\n\nmod term;\npub use term::{ErlEq, ErlExactEq, ErlOrd, Pid, Reference, Term, TermType};\n\npub mod erl_lib;\n\nmod vm;\npub use vm::{VMState, WatchType};\n\nmod process;\n\nmod module;\n\n//mod trace;\n" }, { "path": "libeir_interpreter/src/mailbox.rs", "content": "use ::term::{ Term, Pid };\n\n#[derive(Debug)]\npub struct Mailbox {\n trap_exits: bool,\n messages: Vec<(Pid, Term)>,\n}\n\nimpl Mailbox {\n pub fn new() -> Self {\n Mailbox {\n trap_exits: false,\n messages: vec![],\n }\n }\n pub fn get_trap_exits(&self) -> bool {\n self.trap_exits\n }\n pub fn set_trap_exits(&mut self, val: bool) {\n self.trap_exits = val;\n }\n}\n" }, { "path": "libeir_interpreter/src/module.rs", "content": "use std::collections::HashMap;\nuse std::rc::Rc;\n\nuse crate::process::ProcessContext;\nuse crate::{Term, VMState};\n\nuse libeir_intern::Symbol;\nuse libeir_ir::{Function, FunctionIdent, LiveValues, Module};\n\npub enum NativeReturn {\n Return { term: Rc },\n Throw { typ: Rc, reason: Rc },\n}\n\npub struct NativeModule {\n pub name: Symbol,\n pub functions: HashMap<\n (Symbol, usize),\n Box]) -> NativeReturn>,\n >,\n}\nimpl NativeModule {\n pub fn new(name: Symbol) -> Self {\n NativeModule {\n name: name,\n functions: HashMap::new(),\n }\n }\n\n pub fn add_fun(\n &mut self,\n name: Symbol,\n arity: usize,\n fun: Box]) -> NativeReturn>,\n ) {\n self.functions.insert((name, arity), fun);\n }\n\n pub fn has_fun(&self, ident: &FunctionIdent) -> bool {\n self.functions.contains_key(&(ident.name.name, ident.arity))\n }\n}\n\npub struct ErlangFunction {\n pub fun: Function,\n pub live: LiveValues,\n}\n\npub struct ErlangModule {\n pub name: Symbol,\n pub functions: HashMap,\n}\n\nimpl ErlangModule {\n pub fn from_eir(module: Module) -> Self {\n let functions = module\n .index_iter()\n .map(|idx| {\n let fun_def = &module[idx];\n let fun = fun_def.function();\n let nfun = ErlangFunction {\n live: fun.live_values(),\n fun: fun.clone(),\n };\n (fun.ident().clone(), nfun)\n })\n .collect();\n\n ErlangModule {\n name: module.name().name,\n functions,\n }\n }\n}\n\npub enum ModuleType {\n Erlang(ErlangModule, Option),\n Native(NativeModule),\n}\n" }, { "path": "libeir_interpreter/src/pattern.rs", "content": "use std::collections::HashMap;\n\nuse ::term::Term;\nuse eir::Clause;\nuse eir::pattern::PatternNode;\nuse eir::AtomicTerm;\nuse eir::SSAVariable;\n\n#[derive(Debug, Copy, Clone)]\npub enum MatchState {\n MatchClause(usize),\n GuardWait(usize),\n Finished,\n}\n\nimpl MatchState {\n\n fn clause_num(&self) -> usize {\n match self {\n MatchState::MatchClause(num) => *num,\n MatchState::GuardWait(num) => *num,\n _ => panic!(),\n }\n }\n\n fn clause_num_mut(&mut self) -> &mut usize {\n match self {\n MatchState::MatchClause(num) => num,\n _ => panic!(),\n }\n }\n\n fn into_guard(&mut self) {\n match *self {\n MatchState::MatchClause(num) => *self = MatchState::GuardWait(num),\n _ => unreachable!(),\n }\n }\n\n fn into_body(&mut self) {\n match *self {\n MatchState::GuardWait(num) => *self = MatchState::MatchClause(num+1),\n _ => unreachable!(),\n }\n }\n\n fn into_finished(&mut self) {\n *self = MatchState::Finished;\n }\n\n}\n\n#[derive(Debug, Clone)]\npub struct CaseContext {\n pub state: MatchState,\n pub vars: Vec,\n pub clauses: Vec,\n pub last_binds: Option>,\n}\n\nfn match_node(term: &Term, node: &PatternNode,\n binds: &mut HashMap) -> bool {\n //println!(\" MATCH_NODE: {:?} {:?}\", term, node);\n match (term, node) {\n // Wildcard and purely recursive\n (_, PatternNode::Wildcard) => true,\n (_, PatternNode::Bind(ssa, i_node)) => {\n binds.insert(\n *ssa, //binds_ref.iter().find(|(k, _)| k == var_name).unwrap().1,\n term.clone()\n );\n match_node(term, i_node, binds)\n },\n\n // Lists\n (Term::List(ref t_head, ref t_tail),\n PatternNode::List(ref p_head, ref p_tail)) => {\n if t_head.len() < p_head.len() {\n for (pat, term) in p_head.iter().zip(t_head.iter()) {\n if !match_node(term, pat, binds) {\n return false;\n }\n }\n let n_p_head: Vec<_> = p_head.iter().skip(t_head.len())\n .cloned().collect();\n let n_pat = PatternNode::List(n_p_head, p_tail.clone());\n return match_node(t_tail, &n_pat, binds);\n } else if t_head.len() == p_head.len() {\n for (pat, term) in p_head.iter().zip(t_head.iter()) {\n if !match_node(term, pat, binds) {\n return false;\n }\n }\n return match_node(t_tail, p_tail, binds);\n } else { // >\n assert!(t_head.len() > p_head.len());\n for (pat, term) in p_head.iter().zip(t_head.iter()) {\n if !match_node(term, pat, binds) {\n return false;\n }\n }\n let head_rest: Vec<_> = t_head.iter().skip(p_head.len())\n .cloned().collect();\n let rest_term = Term::List(head_rest, t_tail.clone());\n let a = match_node(&rest_term, p_tail, binds);\n return a;\n }\n }\n // List with empty head\n (_, PatternNode::List(ref list, ref tail)) if list.len() == 0 =>\n match_node(term, tail, binds),\n // Nil ([])\n (Term::Nil, PatternNode::Atomic(AtomicTerm::Nil)) => true,\n (Term::Nil, _) => false,\n (_, PatternNode::Atomic(AtomicTerm::Nil)) => false,\n\n // Tuple\n (Term::Tuple(t_entries), PatternNode::Tuple(p_entries)) => {\n if t_entries.len() != p_entries.len() {\n return false;\n }\n for (term, pat) in t_entries.iter().zip(p_entries) {\n if !match_node(term, pat, binds) {\n return false;\n }\n }\n true\n }\n (_, PatternNode::Tuple(_)) => false,\n\n // Atom\n (Term::Atom(v1), PatternNode::Atomic(AtomicTerm::Atom(v2))) => v1 == v2,\n (Term::Atom(_), _) => false,\n (_, PatternNode::Atomic(AtomicTerm::Atom(_))) => false,\n\n (Term::Integer(ref int),\n PatternNode::Atomic(AtomicTerm::Integer(ref pat_int))) => {\n println!(\" Int pattern {} {}\", int, pat_int);\n int == pat_int\n }\n _ => {\n ::trace::warning(\"WARNING: Pattern matching incomplete\".to_string());\n println!(\" Warning: Pattern matching incomplete\");\n false\n },\n }\n}\n\nimpl CaseContext {\n\n pub fn new(vars: Vec, clauses: Vec) -> Self {\n CaseContext {\n state: MatchState::MatchClause(0),\n vars: vars,\n clauses: clauses,\n last_binds: None,\n }\n }\n\n pub fn do_body(&mut self) -> usize {\n let (matched, values) = {\n let clause = &self.clauses[self.state.clause_num()];\n assert!(clause.patterns.len() == self.vars.len());\n\n //println!(\"{:?}\", clause);\n //println!(\" {:?}\", self.vars);\n\n let mut values: HashMap = HashMap::new();\n let matched = self.vars.iter()\n .zip(&clause.patterns)\n .enumerate()\n .all(|(idx, (term, pattern))| {\n let r = match_node(term, &pattern.node,\n &mut values);\n println!(\" Pattern num: {} {}\", idx, r);\n r\n });\n (matched, values)\n };\n\n if matched {\n let clause_num = self.state.clause_num();\n self.state.into_guard();\n self.last_binds = Some(values);\n clause_num + 1\n } else {\n *self.state.clause_num_mut() += 1;\n if self.state.clause_num() >= self.clauses.len() {\n 0\n } else {\n self.do_body()\n }\n }\n\n //println!(\"PAT: {:?}\", self.clauses[0]);\n //println!(\"TERMS: {:?}\", terms);\n }\n\n pub fn case_values(&self) -> HashMap {\n self.last_binds.as_ref().unwrap().clone()\n }\n\n pub fn guard_ok(&mut self) {\n self.state.into_finished();\n }\n\n pub fn guard_fail(&mut self, clause_num: usize) {\n assert!(clause_num == self.state.clause_num());\n self.state.into_body();\n }\n\n}\n" }, { "path": "libeir_interpreter/src/process/match.rs", "content": "use libeir_ir::{BasicType, BinaryEntrySpecifier, Block, Endianness, MatchKind};\n\nuse libeir_util_binary::BitCarrier;\nuse libeir_util_binary::{carrier_to_integer, BitSlice, BitVec, Endian};\n\nuse crate::module::ErlangFunction;\nuse crate::term::ErlExactEq;\nuse crate::Term;\n\nuse super::{CallExecutor, TermCall};\n\npub fn match_op(\n exec: &mut CallExecutor,\n fun: &ErlangFunction,\n branches: &[MatchKind],\n block: Block,\n) -> TermCall {\n let reads = fun.fun.block_reads(block);\n\n let branches_elems = Term::as_value_list(&exec.make_term(fun, reads[0]));\n\n let unpack_term = exec.make_term(fun, reads[1]);\n\n for (idx, kind) in branches.iter().enumerate() {\n let branch_args = Term::as_value_list(&exec.make_term(fun, reads[idx + 2]));\n\n match kind {\n MatchKind::Value => {\n assert!(branch_args.len() == 1);\n\n if unpack_term.erl_exact_eq(&*branch_args[0]) {\n return TermCall {\n fun: branches_elems[idx].clone(),\n args: vec![],\n };\n }\n }\n MatchKind::ListCell => {\n assert!(branch_args.len() == 0);\n match &*unpack_term {\n Term::ListCell(head, tail) => {\n return TermCall {\n fun: branches_elems[idx].clone(),\n args: vec![head.clone(), tail.clone()],\n };\n }\n _ => (),\n }\n }\n MatchKind::Tuple(len) => {\n assert!(branch_args.len() == 0);\n match &*unpack_term {\n Term::Tuple(elems) if elems.len() == *len => {\n return TermCall {\n fun: branches_elems[idx].clone(),\n args: elems.clone(),\n };\n }\n _ => (),\n }\n }\n MatchKind::Type(BasicType::Map) => {\n assert!(branch_args.len() == 0);\n match &*unpack_term {\n Term::Map(_) => {\n return TermCall {\n fun: branches_elems[idx].clone(),\n args: vec![],\n };\n }\n _ => (),\n }\n }\n MatchKind::MapItem => {\n assert!(branch_args.len() == 1);\n match &*unpack_term {\n Term::Map(map) => {\n if let Some(v) = map.get(&branch_args[0]) {\n return TermCall {\n fun: branches_elems[idx].clone(),\n args: vec![v.clone()],\n };\n }\n }\n _ => unreachable!(),\n }\n }\n MatchKind::Binary(BinaryEntrySpecifier::Integer {\n unit,\n endianness,\n signed,\n }) => {\n let size = branch_args[0].as_usize().unwrap();\n let bit_len = (*unit as usize) * size;\n\n let ret = match &*unpack_term {\n Term::Binary(bin) => {\n if (bin.len() * 8) < bit_len {\n continue;\n }\n\n let int_slice = BitSlice::with_offset_length(&**bin, 0, bit_len);\n let endian = match *endianness {\n Endianness::Big => Endian::Big,\n Endianness::Little => Endian::Little,\n Endianness::Native => Endian::Big,\n };\n let int = carrier_to_integer(int_slice, *signed, endian);\n\n TermCall {\n fun: branches_elems[idx].clone(),\n args: vec![\n Term::Integer(int).into(),\n Term::BinarySlice {\n buf: bin.clone(),\n bit_offset: bit_len,\n bit_length: bin.bit_len() - bit_len,\n }\n .into(),\n ],\n }\n }\n Term::BinarySlice {\n buf,\n bit_offset,\n bit_length,\n } => {\n if *bit_length < bit_len {\n continue;\n }\n\n let int_slice = BitSlice::with_offset_length(&**buf, *bit_offset, bit_len);\n let endian = match *endianness {\n Endianness::Big => Endian::Big,\n Endianness::Little => Endian::Little,\n Endianness::Native => Endian::Big,\n };\n let int = carrier_to_integer(int_slice, *signed, endian);\n\n TermCall {\n fun: branches_elems[idx].clone(),\n args: vec![\n Term::Integer(int).into(),\n Term::BinarySlice {\n buf: buf.clone(),\n bit_offset: *bit_offset + bit_len,\n bit_length: *bit_length - bit_len,\n }\n .into(),\n ],\n }\n }\n _ => continue,\n };\n return ret;\n }\n MatchKind::Binary(BinaryEntrySpecifier::Bytes { unit }) => {\n let size = branch_args[0].as_usize().unwrap_or(1);\n let byte_len = (*unit as usize) * size;\n\n match &*unpack_term {\n Term::Binary(bin) => {\n //if bin.bit_len() % 8 != 0 {\n // continue;\n //}\n\n return TermCall {\n fun: branches_elems[idx].clone(),\n args: vec![\n unpack_term.clone(),\n Term::Binary(BitVec::new().into()).into(),\n ],\n };\n }\n Term::BinarySlice { bit_length, .. } => {\n //if *bit_length % 8 != 0 {\n // continue;\n //}\n\n return TermCall {\n fun: branches_elems[idx].clone(),\n args: vec![\n unpack_term.clone(),\n Term::Binary(BitVec::new().into()).into(),\n ],\n };\n }\n _ => (),\n }\n },\n MatchKind::Wildcard => {\n assert!(branch_args.len() == 0);\n return TermCall {\n fun: branches_elems[idx].clone(),\n args: vec![],\n };\n }\n kind => unimplemented!(\"{:?}\", kind),\n }\n }\n\n panic!()\n}\n" }, { "path": "libeir_interpreter/src/process/mod.rs", "content": "use std::any::TypeId;\nuse std::collections::HashMap;\nuse std::rc::Rc;\n\nuse num_traits::cast::ToPrimitive;\n\nuse libeir_intern::Ident;\nuse libeir_ir::constant::{AtomicTerm, Const, ConstKind};\nuse libeir_ir::operation::binary_construct::{\n BinaryConstructFinish, BinaryConstructPush, BinaryConstructStart,\n};\nuse libeir_ir::MapPutUpdate;\nuse libeir_ir::{BinOp, Block, FunctionIdent, LogicOp, OpKind, PrimOpKind, Value, ValueKind};\nuse libeir_ir::{BinaryEntrySpecifier, Endianness};\n\nuse libeir_util_binary::{integer_to_carrier, BitSlice, BitVec, Endian};\n\nuse crate::module::{ErlangFunction, ErlangModule, ModuleType, NativeModule, NativeReturn};\nuse crate::term::{ErlEq, MapTerm, Pid, Term};\nuse crate::vm::VMState;\n\nmod r#match;\n\n#[derive(Debug)]\npub struct TermCall {\n pub fun: Rc,\n pub args: Vec>,\n}\n\npub enum Continuation {\n Term(TermCall),\n ReturnOk(Rc),\n ReturnThrow(Rc, Rc, Rc),\n}\n\npub struct CallExecutor {\n binds: HashMap>,\n}\n\nimpl CallExecutor {\n pub fn new() -> Self {\n CallExecutor {\n binds: HashMap::new(),\n }\n }\n\n pub fn run(&mut self, vm: &VMState, proc: &mut ProcessContext, call: TermCall) -> Continuation {\n self.binds.clear();\n match &*call.fun {\n Term::BoundLambda {\n ident,\n block,\n environment,\n } => {\n let module = &vm.modules[&ident.module.name];\n match module {\n ModuleType::Erlang(erl, _overlay) => Continuation::Term(\n self.run_erlang(vm, erl, ident, Some((*block, &*environment)), &call.args)\n .unwrap(),\n ),\n ModuleType::Native(_native) => unreachable!(),\n }\n }\n Term::CapturedFunction { ident } => {\n let module = &vm.modules[&ident.module.name];\n println!(\"{}\", ident);\n match module {\n ModuleType::Erlang(erl, overlay) => {\n if let Some(native) = overlay {\n if let Some(res) = self.run_native(vm, proc, native, ident, &call.args)\n {\n return Continuation::Term(res);\n }\n }\n Continuation::Term(\n self.run_erlang(vm, erl, ident, None, &call.args).unwrap(),\n )\n }\n ModuleType::Native(native) => Continuation::Term(\n if let Some(res) = self.run_native(vm, proc, native, ident, &call.args) {\n res\n } else {\n panic!(\"Could not find native function {}\", ident);\n },\n ),\n }\n }\n Term::ReturnOk => {\n assert!(call.args.len() == 1);\n Continuation::ReturnOk(call.args[0].clone())\n }\n Term::ReturnThrow => {\n assert!(call.args.len() == 3);\n Continuation::ReturnThrow(\n call.args[0].clone(),\n call.args[1].clone(),\n call.args[2].clone(),\n )\n }\n // TODO can't call term type, throw exception\n _ => unimplemented!(),\n }\n }\n\n pub fn run_native(\n &mut self,\n vm: &VMState,\n proc: &mut ProcessContext,\n native: &NativeModule,\n ident: &FunctionIdent,\n args: &[Rc],\n ) -> Option {\n if let Some(n_fun) = native.functions.get(&(ident.name.name, ident.arity)) {\n match n_fun(vm, proc, &args[2..]) {\n NativeReturn::Return { term } => Some(TermCall {\n fun: args[0].clone(),\n args: vec![term],\n }),\n NativeReturn::Throw { typ, reason } => Some(TermCall {\n fun: args[1].clone(),\n args: vec![typ, reason, Term::Nil.into()],\n }),\n }\n } else {\n None\n }\n }\n\n pub fn run_erlang(\n &mut self,\n vm: &VMState,\n module: &ErlangModule,\n ident: &FunctionIdent,\n state: Option<(Block, &[Rc])>,\n args: &[Rc],\n ) -> Option {\n if let Some(fun) = module.functions.get(&ident) {\n // Environment\n let block = if let Some((block, env)) = state {\n let live = &fun.live.live_at(block);\n\n for (v, t) in live.iter().zip(env.iter()) {\n self.binds.insert(v, t.clone());\n }\n assert!(live.iter().count() == env.len());\n\n block\n } else {\n fun.fun.block_entry()\n };\n\n // Insert arguments\n let block_arg_vals = fun.fun.block_args(block);\n assert!(block_arg_vals.len() == args.len());\n for (v, t) in block_arg_vals.iter().zip(args.iter()) {\n self.binds.insert(*v, t.clone());\n }\n\n // Execute operation\n Some(self.run_erlang_op(vm, fun, block))\n } else {\n None\n }\n }\n\n fn make_const_term(&self, fun: &ErlangFunction, const_val: Const) -> Rc {\n match fun.fun.cons().const_kind(const_val) {\n ConstKind::Atomic(AtomicTerm::Atom(atom)) => Term::Atom(atom.0).into(),\n ConstKind::Atomic(AtomicTerm::Int(int)) => Term::Integer(int.0.into()).into(),\n ConstKind::Atomic(AtomicTerm::BigInt(int)) => Term::Integer(int.0.clone()).into(),\n ConstKind::Atomic(AtomicTerm::Float(flt)) => Term::Float(flt.0.inner().into()).into(),\n ConstKind::Atomic(AtomicTerm::Binary(bin)) => {\n Term::Binary(Rc::new(bin.0.clone().into())).into()\n }\n ConstKind::Atomic(AtomicTerm::Nil) => Term::Nil.into(),\n ConstKind::ListCell { head, tail } => Term::ListCell(\n self.make_const_term(fun, *head),\n self.make_const_term(fun, *tail),\n )\n .into(),\n ConstKind::Tuple { entries } => {\n let vec = entries\n .as_slice(&fun.fun.cons().const_pool)\n .iter()\n .map(|e| self.make_const_term(fun, *e))\n .collect::>();\n Term::Tuple(vec).into()\n }\n ConstKind::Map { keys, values } => {\n assert!(\n keys.len(&fun.fun.cons().const_pool) == values.len(&fun.fun.cons().const_pool)\n );\n\n let mut map = MapTerm::new();\n for (key, val) in keys\n .as_slice(&fun.fun.cons().const_pool)\n .iter()\n .zip(values.as_slice(&fun.fun.cons().const_pool).iter())\n {\n let key_v = self.make_const_term(fun, *key);\n let val_v = self.make_const_term(fun, *val);\n map.insert(key_v, val_v);\n }\n\n Term::Map(map).into()\n }\n }\n }\n\n fn make_term(&self, fun: &ErlangFunction, value: Value) -> Rc {\n match fun.fun.value_kind(value) {\n ValueKind::Block(block) => {\n let live = &fun.live.live_at(block);\n let mut env = Vec::new();\n for v in live.iter() {\n assert!(fun.fun.value_argument(v).is_some());\n env.push(self.make_term(fun, v));\n }\n Term::BoundLambda {\n ident: fun.fun.ident().clone(),\n block,\n environment: env,\n }\n .into()\n }\n ValueKind::Argument(_, _) => self.binds[&value].clone(),\n ValueKind::Const(cons) => self.make_const_term(fun, cons),\n ValueKind::PrimOp(prim) => {\n let reads = fun.fun.primop_reads(prim);\n match fun.fun.primop_kind(prim) {\n PrimOpKind::ValueList => {\n let terms: Vec<_> = reads.iter().map(|r| self.make_term(fun, *r)).collect();\n Term::ValueList(terms).into()\n }\n PrimOpKind::Tuple => {\n let terms: Vec<_> = reads.iter().map(|r| self.make_term(fun, *r)).collect();\n Term::Tuple(terms).into()\n }\n PrimOpKind::ListCell => {\n assert!(reads.len() == 2);\n let head = self.make_term(fun, reads[0]);\n let tail = self.make_term(fun, reads[1]);\n Term::ListCell(head, tail).into()\n }\n PrimOpKind::BinOp(BinOp::Equal) => {\n assert!(reads.len() == 2);\n let lhs = self.make_term(fun, reads[0]);\n let rhs = self.make_term(fun, reads[1]);\n Term::new_bool(lhs.erl_eq(&*rhs)).into()\n }\n PrimOpKind::LogicOp(LogicOp::And) => {\n let mut acc = true;\n for read in reads.iter() {\n let term = self.make_term(fun, *read);\n let res = term.as_boolean().unwrap();\n acc = acc & res;\n }\n Term::new_bool(acc).into()\n }\n PrimOpKind::LogicOp(LogicOp::Or) => {\n let mut acc = false;\n for read in reads.iter() {\n let term = self.make_term(fun, *read);\n let res = term.as_boolean().unwrap();\n acc = acc | res;\n }\n Term::new_bool(acc).into()\n }\n PrimOpKind::CaptureFunction => {\n let module = self.make_term(fun, reads[0]).as_atom().unwrap();\n let name = self.make_term(fun, reads[1]).as_atom().unwrap();\n let arity = self.make_term(fun, reads[2]).as_usize().unwrap();\n\n let ident = FunctionIdent {\n module: Ident::with_empty_span(module),\n name: Ident::with_empty_span(name),\n arity,\n };\n\n Term::CapturedFunction { ident }.into()\n }\n kind => unimplemented!(\"{:?}\", kind),\n }\n }\n }\n }\n\n pub fn run_erlang_op(&mut self, _vm: &VMState, fun: &ErlangFunction, block: Block) -> TermCall {\n let reads = fun.fun.block_reads(block);\n println!(\"OP: {:?}\", fun.fun.block_kind(block).unwrap());\n match fun.fun.block_kind(block).unwrap() {\n OpKind::Call(_) => TermCall {\n fun: self.make_term(fun, reads[0]),\n args: reads\n .iter()\n .skip(1)\n .map(|r| self.make_term(fun, *r))\n .collect(),\n },\n OpKind::UnpackValueList(num) => {\n assert!(reads.len() == 2);\n let term = self.make_term(fun, reads[1]);\n match &*term {\n Term::ValueList(items) => {\n assert!(items.len() == *num);\n TermCall {\n fun: self.make_term(fun, reads[0]),\n args: items.clone(),\n }\n }\n _ => TermCall {\n fun: self.make_term(fun, reads[0]),\n args: vec![term],\n },\n }\n }\n OpKind::IfBool => {\n let call_n = if reads.len() == 4 {\n let bool_term = self.make_term(fun, reads[3]);\n match bool_term.as_boolean() {\n Some(true) => 0,\n Some(false) => 1,\n None => 2,\n }\n } else if reads.len() == 3 {\n let bool_term = self.make_term(fun, reads[2]);\n match bool_term.as_boolean() {\n Some(true) => 0,\n Some(false) => 1,\n None => unreachable!(),\n }\n } else {\n unreachable!()\n };\n\n TermCall {\n fun: self.make_term(fun, reads[call_n]),\n args: vec![],\n }\n }\n OpKind::TraceCaptureRaw => TermCall {\n fun: self.make_term(fun, reads[0]),\n args: vec![Term::Nil.into()],\n },\n OpKind::Match { branches } => self::r#match::match_op(self, fun, branches, block),\n OpKind::Dyn(dyn_op) => {\n let tid = dyn_op.type_id();\n match () {\n _ if tid == TypeId::of::() => TermCall {\n fun: self.make_term(fun, reads[0]),\n args: vec![Term::Binary(Default::default()).into()],\n },\n _ if tid == TypeId::of::() => {\n let ok_cont = reads[0];\n let err_cont = reads[1];\n let bin_ref = reads[2];\n let value = reads[3];\n let size = reads.get(4);\n\n let bin_push = dyn_op.downcast_ref::().unwrap();\n let specifier = bin_push.specifier;\n\n let bin_term = self.make_term(fun, bin_ref);\n let mut bin = match &*bin_term {\n Term::Binary(bin) => (**bin).clone(),\n Term::BinarySlice {\n buf,\n bit_offset,\n bit_length,\n } => {\n let slice =\n BitSlice::with_offset_length(&**buf, *bit_offset, *bit_length);\n let mut new = BitVec::new();\n new.push(slice);\n new\n }\n _ => panic!(),\n };\n\n let val_term = self.make_term(fun, reads[3]);\n\n assert!(reads.len() == 4 || reads.len() == 5);\n let size_term = reads.get(4).map(|r| self.make_term(fun, *r));\n\n match specifier {\n BinaryEntrySpecifier::Integer {\n signed: _,\n unit,\n endianness,\n } => {\n let size = size_term.unwrap().as_usize().unwrap();\n let bit_size = unit as usize * size;\n\n let endian = match endianness {\n Endianness::Big => Endian::Big,\n Endianness::Little => Endian::Little,\n Endianness::Native => Endian::Big,\n };\n\n let val = val_term.as_integer().unwrap().clone();\n let carrier = integer_to_carrier(val, bit_size, endian);\n\n bin.push(carrier);\n }\n BinaryEntrySpecifier::Float {\n endianness: Endianness::Big,\n unit,\n } => {\n let size = size_term.unwrap().as_usize().unwrap();\n let bit_size = unit as usize * size;\n\n assert!(bit_size == 32 || bit_size == 64);\n\n let num = match &*val_term {\n Term::Float(flt) => flt.0,\n Term::Integer(int) => {\n let int_f = int.to_i64().unwrap();\n int_f as f64\n }\n _ => panic!(),\n };\n\n match bit_size {\n 32 => bin.push(&num),\n 64 => bin.push(&num),\n _ => unreachable!(),\n }\n }\n BinaryEntrySpecifier::Bytes { unit: 1 } => {\n let binary = val_term.as_binary().unwrap();\n\n if let Some(size_term) = size_term {\n dbg!(&size_term, &binary);\n assert!(size_term.as_usize().unwrap() == binary.len());\n }\n\n bin.push(binary);\n }\n BinaryEntrySpecifier::Bits { unit: 1 } => {\n let binary = val_term.as_binary().unwrap();\n // TODO validate size\n bin.push(binary);\n }\n k => unimplemented!(\"{:?}\", k),\n }\n\n return TermCall {\n fun: self.make_term(fun, ok_cont),\n args: vec![Term::Binary(bin.into()).into()],\n };\n }\n _ if tid == TypeId::of::() => {\n TermCall {\n fun: self.make_term(fun, reads[0]),\n args: vec![self.make_term(fun, reads[1])],\n }\n },\n _ => unimplemented!(),\n }\n }\n //OpKind::BinaryPush { specifier } => {\n // let bin_term = self.make_term(fun, reads[2]);\n // let mut bin = match &*bin_term {\n // Term::Binary(bin) => (**bin).clone(),\n // Term::BinarySlice { buf, bit_offset, bit_length } => {\n // let slice = BitSlice::with_offset_length(\n // &**buf, *bit_offset, *bit_length);\n // let mut new = BitVec::new();\n // new.push(slice);\n // new\n // }\n // _ => panic!(),\n // };\n\n // let val_term = self.make_term(fun, reads[3]);\n\n // assert!(reads.len() == 4 || reads.len() == 5);\n // let size_term = reads.get(4).map(|r| self.make_term(fun, *r));\n\n // match specifier {\n // BinaryEntrySpecifier::Integer {\n // signed: _, unit, endianness } =>\n // {\n // let size = size_term.unwrap().as_usize().unwrap();\n // let bit_size = *unit as usize * size;\n\n // let endian = match *endianness {\n // Endianness::Big => Endian::Big,\n // Endianness::Little => Endian::Little,\n // Endianness::Native => Endian::Big,\n // };\n\n // let val = val_term.as_integer().unwrap().clone();\n // let carrier = integer_to_carrier(\n // val, bit_size, endian);\n\n // bin.push(carrier);\n // }\n // BinaryEntrySpecifier::Float {\n // endianness: Endianness::Big, unit } =>\n // {\n // let size = size_term.unwrap().as_usize().unwrap();\n // let bit_size = *unit as usize * size;\n\n // assert!(bit_size == 32 || bit_size == 64);\n\n // let num = match &*val_term {\n // Term::Float(flt) => flt.0,\n // Term::Integer(int) => {\n // let int_f = int.to_i64().unwrap();\n // int_f as f64\n // }\n // _ => panic!(),\n // };\n\n // match bit_size {\n // 32 => bin.push(&num),\n // 64 => bin.push(&num),\n // _ => unreachable!(),\n // }\n // }\n // BinaryEntrySpecifier::Bytes { unit: 1 } => {\n // let binary = val_term.as_binary().unwrap();\n\n // if let Some(size_term) = size_term {\n // dbg!(&size_term, &binary);\n // assert!(size_term.as_usize().unwrap() == binary.len());\n // }\n\n // bin.push(binary);\n // }\n // k => unimplemented!(\"{:?}\", k),\n // }\n\n // return TermCall {\n // fun: self.make_term(fun, reads[0]),\n // args: vec![Term::Binary(bin.into()).into()],\n // };\n //}\n OpKind::MapPut { action } => {\n let map_term = self.make_term(fun, reads[2]);\n println!(\"{:#?}\", map_term);\n let mut map = map_term.as_map().unwrap().clone();\n\n let mut idx = 3;\n for action in action.iter() {\n let key = self.make_term(fun, reads[idx]);\n let val = self.make_term(fun, reads[idx + 1]);\n idx += 2;\n\n let replaced = map.insert(key, val);\n if *action == MapPutUpdate::Update {\n assert!(replaced)\n }\n }\n\n TermCall {\n fun: self.make_term(fun, reads[0]),\n args: vec![Term::Map(map).into()],\n }\n }\n OpKind::Unreachable => {\n println!(\"==== Reached OpKind::Unreachable! ====\");\n println!(\"Fun: {} Block: {}\", fun.fun.ident(), block);\n unreachable!();\n }\n kind => unimplemented!(\"{:?}\", kind),\n }\n }\n}\n\npub struct ProcessContext {\n pub pid: Pid,\n pub dict: Vec<(Rc, Rc)>,\n}\n\nimpl ProcessContext {\n pub fn new(pid: Pid) -> Self {\n ProcessContext {\n pid,\n dict: Vec::new(),\n }\n }\n}\n" }, { "path": "libeir_interpreter/src/receive.rs", "content": "use ::term::Term;\n\n#[derive(Debug)]\npub struct ReceiveContext {\n}\n\nimpl ReceiveContext {\n\n pub fn new(timeout: Term) -> Self {\n // TODO: Timeout\n ReceiveContext {\n }\n }\n\n}\n" }, { "path": "libeir_interpreter/src/term.rs", "content": "use std::cmp::{Ord, Ordering};\nuse std::collections::HashMap;\nuse std::hash::{Hash, Hasher};\nuse std::rc::Rc;\n\nuse libeir_intern::{LocalInternedString, Symbol};\n\nuse libeir_ir::{Block, FunctionIdent};\n\nuse libeir_util_binary::{BitSlice, BitVec};\n\nuse num_bigint::BigInt;\nuse num_traits::cast::ToPrimitive;\n\n#[derive(Debug, Copy, Clone, Eq, PartialEq, PartialOrd, Ord, Hash)]\npub struct Pid(pub usize);\n\n#[derive(Debug, Copy, Clone, Eq, PartialEq, PartialOrd, Ord, Hash)]\npub struct Reference(pub usize);\n\n#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]\npub enum TermType {\n Nil,\n Integer,\n Float,\n Atom,\n Tuple,\n ListCell,\n Map,\n Pid,\n Reference,\n\n Binary,\n\n BoundLambda,\n CapturedFunction,\n\n // Internal\n ValueList,\n ReturnOk,\n ReturnThrow,\n}\n\n#[derive(Debug, Copy, Clone, PartialOrd)]\npub struct FloatTerm(pub f64);\nimpl PartialEq for FloatTerm {\n fn eq(&self, other: &FloatTerm) -> bool {\n self.0.to_bits() == other.0.to_bits()\n }\n}\nimpl Ord for FloatTerm {\n fn cmp(&self, other: &FloatTerm) -> Ordering {\n self.partial_cmp(other).unwrap()\n }\n}\nimpl Eq for FloatTerm {}\nimpl Hash for FloatTerm {\n fn hash(&self, state: &mut T) {\n self.0.to_bits().hash(state)\n }\n}\nimpl From for FloatTerm {\n fn from(src: f64) -> Self {\n FloatTerm(src)\n }\n}\n\n#[derive(Debug, Clone)]\npub struct MapTerm {\n map: HashMap, Rc>,\n sorted: Vec<(Rc, Rc)>,\n}\nimpl MapTerm {\n pub fn new() -> MapTerm {\n MapTerm {\n map: HashMap::new(),\n sorted: Vec::new(),\n }\n }\n\n pub fn insert(&mut self, key: Rc, val: Rc) -> bool {\n self.map.insert(key.clone(), val.clone());\n match self.sorted.binary_search_by(|(k, _)| k.cmp(&key)) {\n Ok(idx) => {\n self.sorted[idx] = (key, val);\n true\n }\n Err(idx) => {\n self.sorted.insert(idx, (key, val));\n false\n }\n }\n }\n\n pub fn get(&self, key: &Rc) -> Option> {\n self.map.get(key).cloned()\n }\n\n pub fn len(&self) -> usize {\n self.map.len()\n }\n}\nimpl PartialEq for MapTerm {\n fn eq(&self, other: &MapTerm) -> bool {\n self.sorted == other.sorted\n }\n}\nimpl Eq for MapTerm {}\nimpl PartialOrd for MapTerm {\n fn partial_cmp(&self, other: &MapTerm) -> Option {\n self.sorted.partial_cmp(&other.sorted)\n }\n}\nimpl Ord for MapTerm {\n fn cmp(&self, other: &MapTerm) -> Ordering {\n self.partial_cmp(other).unwrap()\n }\n}\nimpl Hash for MapTerm {\n fn hash(&self, state: &mut H) {\n self.sorted.hash(state)\n }\n}\n\n#[derive(Debug, Clone)]\npub enum Term {\n Nil,\n Integer(BigInt),\n Float(FloatTerm),\n Atom(Symbol),\n Tuple(Vec>),\n ListCell(Rc, Rc),\n Map(MapTerm),\n Pid(Pid),\n Reference(Reference),\n Binary(Rc),\n BinarySlice {\n buf: Rc,\n bit_offset: usize,\n bit_length: usize,\n },\n BoundLambda {\n ident: FunctionIdent,\n block: Block,\n environment: Vec>,\n },\n CapturedFunction {\n ident: FunctionIdent,\n },\n\n // Internal\n ValueList(Vec>),\n ReturnOk,\n ReturnThrow,\n}\n\nimpl Term {\n fn order_idx(&self) -> usize {\n // number < atom < reference < fun < port < pid\n // < tuple < map < nil < list < bit string\n match self {\n Term::Integer(_) => 1,\n Term::Float(_) => 1,\n Term::Atom(_) => 2,\n Term::Reference(_) => 3,\n Term::BoundLambda { .. } => 4,\n Term::CapturedFunction { .. } => 4,\n //Term::Port(_) => 5,\n Term::Pid(_) => 6,\n Term::Tuple(_) => 7,\n Term::Map(_) => 8,\n Term::Nil => 9,\n Term::ListCell(_, _) => 10,\n Term::Binary(_) => 11,\n Term::BinarySlice { .. } => 11,\n _ => panic!(),\n }\n }\n}\n\nimpl Eq for Term {}\nimpl PartialEq for Term {\n fn eq(&self, other: &Self) -> bool {\n use Term::*;\n match (self, other) {\n (Nil, Nil) => true,\n (Integer(l), Integer(r)) => l == r,\n (Float(l), Float(r)) => l == r,\n (Atom(l), Atom(r)) => l == r,\n (Tuple(l), Tuple(r)) => l == r,\n (ListCell(lh, lt), ListCell(rh, rt)) => lh == rh && lt == rt,\n (Map(l), Map(r)) => l == r,\n (Pid(l), Pid(r)) => l == r,\n (Reference(l), Reference(r)) => l == r,\n (Binary(l), Binary(r)) => l == r,\n (\n Binary(l),\n BinarySlice {\n buf,\n bit_offset,\n bit_length,\n },\n ) => {\n let rs = BitSlice::with_offset_length(&**buf, *bit_offset, *bit_length);\n &**l == &rs\n }\n (\n BinarySlice {\n buf,\n bit_offset,\n bit_length,\n },\n Binary(r),\n ) => {\n let ls = BitSlice::with_offset_length(&**buf, *bit_offset, *bit_length);\n &ls == &**r\n }\n (\n BinarySlice {\n buf: lb,\n bit_offset: lo,\n bit_length: ll,\n },\n BinarySlice {\n buf: rb,\n bit_offset: ro,\n bit_length: rl,\n },\n ) => {\n let ls = BitSlice::with_offset_length(&**lb, *lo, *ll);\n let rs = BitSlice::with_offset_length(&**rb, *ro, *rl);\n &ls == &rs\n }\n (\n BoundLambda {\n ident: li,\n block: lb,\n environment: le,\n },\n BoundLambda {\n ident: ri,\n block: rb,\n environment: re,\n },\n ) => li == ri && lb == rb && le == re,\n (CapturedFunction { ident: li }, CapturedFunction { ident: ri }) => li == ri,\n (ValueList(l), ValueList(r)) => l == r,\n (ReturnOk, ReturnOk) => true,\n (ReturnThrow, ReturnThrow) => true,\n _ => false,\n }\n }\n}\n\nimpl Ord for Term {\n fn cmp(&self, other: &Self) -> Ordering {\n self.partial_cmp(other).unwrap()\n }\n}\nimpl PartialOrd for Term {\n fn partial_cmp(&self, other: &Self) -> Option {\n use Term::*;\n match (self, other) {\n (Nil, Nil) => Some(Ordering::Equal),\n (Integer(l), Integer(r)) => l.partial_cmp(r),\n (Float(l), Float(r)) => l.partial_cmp(r),\n (Atom(l), Atom(r)) => l.partial_cmp(r),\n (Tuple(l), Tuple(r)) => l.partial_cmp(r),\n (ListCell(lh, lt), ListCell(rh, rt)) => match lh.partial_cmp(rh) {\n Some(Ordering::Equal) | None => lt.partial_cmp(rt),\n non_eq => non_eq,\n },\n (Map(l), Map(r)) => l.partial_cmp(r),\n (Pid(l), Pid(r)) => l.partial_cmp(r),\n (Reference(l), Reference(r)) => l.partial_cmp(r),\n (Binary(l), Binary(r)) => l.partial_cmp(r),\n (\n Binary(l),\n BinarySlice {\n buf,\n bit_offset,\n bit_length,\n },\n ) => {\n let rs = BitSlice::with_offset_length(&**buf, *bit_offset, *bit_length);\n (&**l).partial_cmp(&rs)\n }\n (\n BinarySlice {\n buf,\n bit_offset,\n bit_length,\n },\n Binary(r),\n ) => {\n let ls = BitSlice::with_offset_length(&**buf, *bit_offset, *bit_length);\n\n ls.partial_cmp(&**r)\n }\n (\n BinarySlice {\n buf: lb,\n bit_offset: lo,\n bit_length: ll,\n },\n BinarySlice {\n buf: rb,\n bit_offset: ro,\n bit_length: rl,\n },\n ) => {\n let ls = BitSlice::with_offset_length(&**lb, *lo, *ll);\n let rs = BitSlice::with_offset_length(&**rb, *ro, *rl);\n ls.partial_cmp(&rs)\n }\n (\n BoundLambda {\n ident: li,\n block: lb,\n environment: le,\n },\n BoundLambda {\n ident: ri,\n block: rb,\n environment: re,\n },\n ) => match li.partial_cmp(ri) {\n Some(Ordering::Equal) | None => match lb.partial_cmp(rb) {\n Some(Ordering::Equal) | None => le.partial_cmp(re),\n non_eq => non_eq,\n },\n non_eq => non_eq,\n },\n (CapturedFunction { ident: li }, CapturedFunction { ident: ri }) => li.partial_cmp(ri),\n (ValueList(l), ValueList(r)) => l.partial_cmp(r),\n (ReturnOk, ReturnOk) => Some(Ordering::Equal),\n (ReturnThrow, ReturnThrow) => Some(Ordering::Equal),\n (l, r) => l.order_idx().partial_cmp(&r.order_idx()),\n }\n }\n}\n\nimpl Hash for Term {\n fn hash(&self, state: &mut H) {\n use Term::*;\n\n self.get_type().hash(state);\n match self {\n Nil => (),\n Integer(i) => i.hash(state),\n Float(f) => f.hash(state),\n Atom(a) => a.hash(state),\n Tuple(t) => t.hash(state),\n ListCell(h, t) => {\n h.hash(state);\n t.hash(state);\n }\n Map(t) => t.hash(state),\n Pid(t) => t.hash(state),\n Reference(t) => t.hash(state),\n Binary(t) => t.hash(state),\n BinarySlice {\n buf,\n bit_offset,\n bit_length,\n } => {\n let ls = BitSlice::with_offset_length(&**buf, *bit_offset, *bit_length);\n ls.hash(state);\n }\n BoundLambda {\n ident,\n block,\n environment,\n } => {\n ident.hash(state);\n block.hash(state);\n environment.hash(state);\n }\n CapturedFunction { ident } => ident.hash(state),\n ValueList(i) => i.hash(state),\n ReturnOk => (),\n ReturnThrow => (),\n }\n }\n}\n\nimpl From for Term {\n fn from(num: i64) -> Self {\n Term::Integer(num.into())\n }\n}\n\npub enum ListIteratorItem {\n Elem(Rc),\n Tail(Rc),\n}\n\npub struct ListTermIterator {\n term: Option>,\n}\nimpl Iterator for ListTermIterator {\n type Item = ListIteratorItem;\n fn next(&mut self) -> Option {\n if let Some(term) = self.term.take() {\n match &*term {\n Term::ListCell(head, tail) => {\n self.term = Some(tail.clone());\n Some(ListIteratorItem::Elem(head.clone()))\n }\n _ => {\n self.term = None;\n Some(ListIteratorItem::Tail(term.clone()))\n }\n }\n } else {\n None\n }\n }\n}\n\nimpl Term {\n pub fn new_i64(num: i64) -> Self {\n Term::Integer(num.into())\n }\n pub fn new_usize(num: usize) -> Self {\n Term::Integer(num.into())\n }\n\n pub fn new_atom(string: &str) -> Self {\n Term::Atom(Symbol::intern(string))\n }\n\n pub fn new_bool(val: bool) -> Self {\n if val {\n Term::new_atom(\"true\")\n } else {\n Term::new_atom(\"false\")\n }\n }\n\n pub fn slice_to_list(head: &[Rc], tail: Rc) -> Rc {\n let mut acc = tail;\n for term in head.iter().rev() {\n acc = Term::ListCell(term.clone(), acc).into();\n }\n acc\n }\n\n fn extend_erl_string(&self, buf: &mut String) -> bool {\n match self {\n Term::Integer(val) => {\n buf.push(val.to_u8().unwrap() as char);\n true\n }\n Term::ListCell(_head, _tail) => {\n unimplemented!()\n //for item in head {\n // if !item.extend_erl_string(buf) {\n // return false;\n // }\n //}\n //return tail.extend_erl_string(buf);\n }\n Term::Nil => true,\n _ => false,\n }\n }\n\n pub fn get_erl_string(&self) -> Option {\n let mut buf = String::new();\n if self.extend_erl_string(&mut buf) {\n Some(buf)\n } else {\n None\n }\n }\n\n pub fn atom_str<'a>(&'a self) -> LocalInternedString {\n if let Term::Atom(ref atom) = *self {\n atom.as_str()\n } else {\n panic!();\n }\n }\n\n pub fn is_nil(&self) -> bool {\n match self {\n Term::Nil => true,\n _ => false,\n }\n }\n\n pub fn get_type(&self) -> TermType {\n match self {\n Term::Binary(_) => TermType::Binary,\n Term::BinarySlice { .. } => TermType::Binary,\n Term::Nil => TermType::Nil,\n Term::Pid(_) => TermType::Pid,\n Term::Reference(_) => TermType::Reference,\n Term::Integer(_) => TermType::Integer,\n Term::Float(_) => TermType::Float,\n Term::Atom(_) => TermType::Atom,\n Term::Tuple(_) => TermType::Tuple,\n Term::ListCell(_, _) => TermType::ListCell,\n Term::Map(_) => TermType::Map,\n Term::BoundLambda { .. } => TermType::BoundLambda,\n Term::CapturedFunction { .. } => TermType::CapturedFunction,\n Term::ValueList(_) => TermType::ValueList,\n Term::ReturnOk => TermType::ReturnOk,\n Term::ReturnThrow => TermType::ReturnThrow,\n }\n }\n\n pub fn as_boolean(&self) -> Option {\n if let Term::Atom(ref val) = self {\n let is_truthy = *val == Symbol::intern(\"true\");\n let is_falsey = *val == Symbol::intern(\"false\");\n if is_truthy ^ is_falsey {\n Some(is_truthy)\n } else {\n None\n }\n } else {\n None\n }\n }\n\n pub fn as_i64(&self) -> Option {\n if let Term::Integer(ref bigint) = self {\n Some(bigint.to_i64().unwrap())\n } else {\n None\n }\n }\n\n pub fn as_usize(&self) -> Option {\n if let Term::Integer(ref bigint) = self {\n Some(bigint.to_usize().unwrap())\n } else {\n None\n }\n }\n\n pub fn as_integer(&self) -> Option<&BigInt> {\n if let Term::Integer(ref bigint) = self {\n Some(bigint)\n } else {\n None\n }\n }\n\n pub fn as_atom(&self) -> Option {\n if let Term::Atom(ref atom) = self {\n Some(atom.clone())\n } else {\n None\n }\n }\n\n pub fn as_tuple(&self) -> Option<&[Rc]> {\n if let Term::Tuple(tup) = self {\n Some(tup)\n } else {\n None\n }\n }\n\n pub fn as_binary(&self) -> Option<&BitVec> {\n if let Term::Binary(bin) = self {\n Some(bin)\n } else {\n None\n }\n }\n\n pub fn as_map(&self) -> Option<&MapTerm> {\n if let Term::Map(bin) = self {\n Some(bin)\n } else {\n None\n }\n }\n\n pub fn list_iter(term: &Rc) -> ListTermIterator {\n ListTermIterator {\n term: Some(term.clone()),\n }\n }\n\n //fn join_list(&self, list: &mut Vec>) -> Term {\n // match self {\n // Term::ListCell(head, tail) => {\n // list.extend(head.iter().cloned());\n // tail.join_list(list)\n // }\n // _ => self.clone()\n // }\n //}\n\n pub fn as_inproper_list(term: &Rc) -> (Vec>, Rc) {\n let mut list = Vec::new();\n for item in Term::list_iter(term) {\n match item {\n ListIteratorItem::Elem(elem) => list.push(elem),\n ListIteratorItem::Tail(tail) => return (list, tail),\n }\n }\n unreachable!()\n }\n\n pub fn as_list(term: &Rc) -> Option>> {\n let (list, tail) = Term::as_inproper_list(term);\n if let Term::Nil = &*tail {\n Some(list)\n } else {\n None\n }\n }\n\n pub fn as_value_list(term: &Rc) -> Vec> {\n match &**term {\n Term::ValueList(val) => val.clone(),\n _ => vec![term.clone()],\n }\n }\n\n pub fn to_doc(_term: Rc) -> pretty::Doc<'static, pretty::BoxDoc<'static>> {\n unimplemented!()\n //use pretty::{ Doc };\n //match &*term {\n // Term::Nil => Doc::text(\"[]\"),\n // Term::Integer(int) => Doc::text(int.to_string()),\n // Term::Float(num) => Doc::text(num.0.to_string()),\n // Term::Atom(atom) => Doc::text(atom.to_string()),\n // Term::Tuple(items) => {\n // let docs: Vec<_> = items.iter().map(|i| Term::to_doc(i.clone())).collect();\n // Doc::text(\"{\")\n // .append(Doc::intersperse(docs, Doc::text(\",\")))\n // .append(Doc::text(\"}\"))\n // },\n // Term::ListCell(_, _) => {\n // let (head, tail) = Term::as_inproper_list(&term);\n // let head_docs: Vec<_> = head.iter().map(|i| Term::to_doc(i.clone())).collect();\n // let tail_doc = Term::to_doc(tail);\n // Doc::text(\"[\")\n // .append(Doc::intersperse(head_docs, Doc::text(\",\")))\n // .append(Doc::text(\"|\"))\n // .append(tail_doc)\n // .append(Doc::text(\"]\"))\n // },\n // //Term::ListCell(head, tail) if head.len() == 0 => tail.to_doc(),\n // //Term::ListCell(head, tail) => {\n // // let head_docs: Vec<_> = head.iter().map(|i| i.to_doc()).collect();\n // // let tail_doc = tail.to_doc();\n // // Doc::text(\"[\")\n // // .append(Doc::intersperse(head_docs, Doc::text(\",\")))\n // // .append(Doc::text(\"|\"))\n // // .append(tail_doc)\n // // .append(Doc::text(\"]\"))\n // //},\n // Term::Map(map) => {\n // let entries_doc: Vec<_> = map.sorted.iter()\n // .map(|(k, v)| {\n // Doc::group(\n // Term::to_doc(k.clone())\n // .append(Doc::text(\"=>\"))\n // .append(Term::to_doc(v.clone()))\n // )\n // }).collect();\n // Doc::text(\"%{\")\n // .append(Doc::intersperse(entries_doc, Doc::text(\",\")))\n // .append(Doc::text(\"}\"))\n // },\n // Term::Pid(pid) => Doc::text(format!(\"Pid<{}>\", pid.0)),\n // Term::Reference(refe) => Doc::text(format!(\"Reference<{}>\", refe.0)),\n // Term::Binary(bin) => {\n // if let Some(slice) = bin.try_as_byte_aligned_slice() {\n // if let Ok(utf) = std::str::from_utf8(slice) {\n // return Doc::text(\"\\\"\")\n // .append(Doc::text(utf.to_string()))\n // .append(Doc::text(\"\\\"\"));\n // }\n // }\n\n // // TODO bit length\n // let items: Vec<_> = bin.iter_bytes()\n // .map(|v| Doc::text(v.to_string()))\n // .collect();\n // Doc::text(\"<\")\n // .append(Doc::intersperse(items, Doc::text(\",\")))\n // .append(Doc::text(\">\"))\n // },\n // Term::BinarySlice { buf, bit_offset, bit_length } => {\n // if bit_length % 8 == 0 {\n // let from = BitSlice::with_offset_length(\n // &**buf, *bit_offset, *bit_length);\n\n // let byte_len = bit_length / 8;\n // let mut bin = vec![0; byte_len];\n // bit_copy(&from, &mut bin as &mut [u8]);\n\n // if let Ok(utf) = std::str::from_utf8(&bin) {\n // return Doc::text(\"\\\"\")\n // .append(Doc::text(utf.to_string()))\n // .append(Doc::text(\"\\\"\"));\n // } else {\n // let items: Vec<_> = bin.iter()\n // .map(|v| Doc::text(v.to_string()))\n // .collect();\n // Doc::text(\"<\")\n // .append(Doc::intersperse(items, Doc::text(\",\")))\n // .append(Doc::text(\">\"))\n // }\n // } else {\n // let items: Vec<_> = buf.iter_words()\n // .map(|v| Doc::text(v.to_string()))\n // .collect();\n // Doc::text(\"<\")\n // .append(Doc::intersperse(items, Doc::text(\",\")))\n // .append(Doc::text(\">\"))\n // }\n // },\n // Term::BoundLambda { ident, block, .. } => {\n // Doc::text(format!(\"Bound<{}:{}/{}@{}>\", ident.module.name, ident.name.name,\n // ident.arity, block))\n // },\n // Term::CapturedFunction { ident } => {\n // Doc::text(format!(\"Captured<{}:{}/{}>\", ident.module.name, ident.name.name, ident.arity))\n // },\n // Term::ValueList(items) => {\n // let docs: Vec<_> = items.iter().map(|i| Term::to_doc(i.clone())).collect();\n // Doc::text(\"<\")\n // .append(Doc::intersperse(docs, Doc::text(\",\")))\n // .append(Doc::text(\">\"))\n // }\n // Term::ReturnOk => {\n // Doc::text(format!(\"ReturnOk\"))\n // }\n // Term::ReturnThrow => {\n // Doc::text(format!(\"ReturnThrow\"))\n // }\n //}\n }\n}\n\npub trait ErlEq {\n fn erl_eq(&self, other: &Rhs) -> bool;\n}\n\npub trait ErlExactEq {\n fn erl_exact_eq(&self, other: &Rhs) -> bool;\n}\n\npub trait ErlOrd {\n fn erl_ord(&self, other: &Rhs) -> ::std::cmp::Ordering;\n}\n\nimpl ErlEq for f64 {\n fn erl_eq(&self, other: &f64) -> bool {\n (*self) == (*other)\n }\n}\n\nimpl ErlEq for Term {\n fn erl_eq(&self, other: &Term) -> bool {\n match (self, other) {\n (Term::BoundLambda { .. }, _) => unreachable!(),\n (_, Term::BoundLambda { .. }) => unreachable!(),\n (Term::ValueList(_), _) => unimplemented!(),\n (_, Term::ValueList(_)) => unimplemented!(),\n\n (Term::Nil, Term::Nil) => true,\n (Term::ListCell(h1, t1), Term::ListCell(h2, t2)) => h1.erl_eq(h2) && t1.erl_eq(t2),\n //(Term::List(h1, t1), Term::Nil) if h1.len() == 0 =>\n // if let Term::Nil = **t1 { true } else { false },\n //(Term::Nil, Term::List(h2, t2)) if h2.len() == 0 =>\n // if let Term::Nil = **t2 { true } else { false },\n //(Term::List(h1, t1), Term::List(h2, t2)) => {\n // let head_ok = h1.iter().zip(h2.iter())\n // .all(|(v1, v2)| v1.erl_eq(v2));\n // if !head_ok { return false; }\n // if h1.len() == h2.len() {\n // t1.erl_eq(t2)\n // } else if h1.len() > h2.len() {\n // let h1_new_head: Vec<_> = h1.iter().skip(h2.len())\n // .cloned().collect();\n // let h1_new = Term::List(h1_new_head, t1.clone());\n // h1_new.erl_eq(t2)\n // } else {\n // let h2_new_head: Vec<_> = h2.iter().skip(h1.len())\n // .cloned().collect();\n // let h2_new = Term::List(h2_new_head, t2.clone());\n // t1.erl_eq(&h2_new)\n // }\n //}\n (Term::Nil, _) => false,\n (_, Term::Nil) => false,\n\n (Term::Integer(ref i1), Term::Integer(ref i2)) => i1 == i2,\n (Term::Float(ref f1), Term::Float(ref f2)) => f1 == f2,\n (Term::Integer(_), Term::Float(_)) => unimplemented!(),\n (Term::Float(_), Term::Integer(_)) => unimplemented!(),\n (Term::Atom(ref a1), Term::Atom(ref a2)) => a1 == a2,\n (Term::Tuple(ref v1), Term::Tuple(ref v2)) => {\n v1.iter().zip(v2).all(|(e1, e2)| e1.erl_eq(e2))\n }\n (\n Term::CapturedFunction { ident: ref ident1 },\n Term::CapturedFunction { ident: ref ident2 },\n ) => ident1 == ident2,\n _ => {\n //crate::trace::warning_args(\n // \"WARNING: ErlEq might be unimplemented\".to_string(),\n // || {\n // let mut event_args = std::collections::HashMap::new();\n // event_args.insert(\n // \"lhs\".to_string(),\n // ::serde_json::Value::String(format!(\"{:?}\", self))\n // );\n // event_args.insert(\n // \"rhs\".to_string(),\n // ::serde_json::Value::String(format!(\"{:?}\", other))\n // );\n // event_args\n // }\n //);\n println!(\"WARNING: ErlEq might be unimplemented\");\n println!(\" {:?} == {:?}\", self, other);\n false\n }\n }\n }\n}\n\nimpl ErlExactEq for Term {\n fn erl_exact_eq(&self, other: &Term) -> bool {\n self == other\n }\n}\n\nimpl ErlOrd for Term {\n fn erl_ord(&self, other: &Term) -> ::std::cmp::Ordering {\n match (self, other) {\n (Term::Integer(val1), Term::Integer(val2)) => val1.cmp(val2),\n //(Term::Float(val1), Term::Float(val2)) =>\n // val1.cmp(val2),\n (_, _) => unimplemented!(),\n }\n }\n}\n" }, { "path": "libeir_interpreter/src/trace/dummy.rs", "content": "use std::rc::Rc;\nuse std::collections::HashMap;\n\nuse crate::term::{ Term, Pid };\n\nuse libeir_ir::{ FunctionIdent, Block };\n\npub fn set_pid(_pid: Pid) {}\npub fn enter_function(_ident: &FunctionIdent, _lambda: Option, _args: &[Rc]) {}\n//pub fn exit_function(ident: &FunctionIdent, ret: Option<&CallReturn>) {}\n//pub fn start_basic_block(module: &Atom, ident: &FunctionIdent, block: LabelN) {\n//pub fn end_basic_block() {\npub fn warning(_text: String) {}\npub fn warning_args(_text: String, _make_args: F) where F: FnOnce() -> HashMap {}\n" }, { "path": "libeir_interpreter/src/trace/mod.rs", "content": "\n//#[cfg(not(feature = \"trace\"))]\n//#[macro_use]\nmod dummy;\n//#[cfg(not(feature = \"trace\"))]\nuse self::dummy as trace;\n\n//#[cfg(feature = \"trace\")]\n//#[macro_use]\n//mod trace;\n\npub use self::trace::*;\n" }, { "path": "libeir_interpreter/src/trace/trace.rs", "content": "\nuse std::rc::Rc;\nuse crate::term::{ Term, Pid };\n\nuse libeir_ir::{ FunctionIdent, Block, Value };\nuse libeir_intern::Symbol;\n\nuse std::sync::{ Mutex, RwLock };\nuse std::collections::HashMap;\nuse std::borrow::BorrowMut;\n\nuse ::serde::{ Serialize };\n\n#[derive(Serialize)]\n#[serde(tag = \"ph\")]\nenum TraceEntry {\n #[serde(rename = \"B\")]\n DurationStart {\n name: String,\n #[serde(rename = \"cat\")]\n categories: String,\n #[serde(rename = \"ts\")]\n timestamp: u64,\n pid: u64,\n tid: u64,\n cname: Option,\n args: HashMap,\n },\n #[serde(rename = \"E\")]\n DurationEnd {\n #[serde(rename = \"ts\")]\n timestamp: u64,\n pid: u64,\n tid: u64,\n args: HashMap,\n },\n #[serde(rename = \"i\")]\n Instant {\n name: String,\n #[serde(rename = \"ts\")]\n timestamp: u64,\n pid: u64,\n tid: u64,\n #[serde(rename = \"s\")]\n scope: &'static str,\n args: HashMap,\n }\n}\n\nlazy_static::lazy_static! {\n static ref VM_ID_COUNTER: Mutex = Mutex::new(0);\n}\n\nstd::thread_local! {\n static VM_ID: RwLock> = RwLock::new(None);\n static TRACE_COLLECTOR: Mutex = Mutex::new(TraceCollector::new());\n}\n\npub fn gen_vm_id() {\n let counter = VM_ID_COUNTER.lock().unwrap();\n VM_ID.with(|v| {\n let mut vm_id = v.write().unwrap();\n *vm_id = Some(*counter);\n });\n}\n\nfn vm_id() -> usize {\n VM_ID.with(|v| {\n v.read().unwrap().unwrap()\n })\n}\n\nstruct StackEntry {\n pid: Pid,\n module: Symbol,\n ident: FunctionIdent,\n args: Vec,\n}\n\nstruct TraceEvent {\n pid: Pid,\n typ: TraceEventType,\n}\n\nenum TraceEventType {\n FunctionEnter {\n ident: FunctionIdent,\n lambda: Option,\n args: Vec>,\n },\n FunctionTailCall,\n FunctionReturn {\n kind: usize,\n ret: Rc,\n },\n BlockStart {\n ident: FunctionIdent,\n block: Block,\n },\n BlockEnd,\n Warning {\n text: String,\n args: HashMap,\n },\n}\n\nstruct TraceCollector {\n current_pid: Pid,\n pid_stacks: HashMap>,\n events: Vec,\n}\n\nimpl TraceCollector {\n\n fn new() -> Self {\n TraceCollector {\n current_pid: Pid(0),\n pid_stacks: HashMap::new(),\n events: Vec::new(),\n }\n }\n\n}\n\npub fn set_pid(pid: Pid) {\n TRACE_COLLECTOR.with(|c| {\n let mut c = c.lock().unwrap();\n c.current_pid = pid;\n })\n}\n\npub fn get_pid() -> Pid {\n TRACE_COLLECTOR.with(|c| {\n let c = c.lock().unwrap();\n c.current_pid\n })\n}\n\npub fn enter_function(ident: &FunctionIdent, lambda: Option, args: &[Rc]) {\n TRACE_COLLECTOR.with(|c| {\n let mut c = c.lock().unwrap();\n let pid = c.current_pid;\n if !c.pid_stacks.contains_key(&pid) {\n c.pid_stacks.insert(pid, Vec::new());\n }\n {\n let stack = c.pid_stacks.get_mut(&pid).unwrap();\n stack.push(StackEntry {\n pid: pid,\n module: module.clone(),\n ident: ident.clone(),\n args: args.to_vec(),\n });\n }\n c.events.push(TraceEvent {\n pid: pid,\n typ: TraceEventType::FunctionEnter {\n ident: ident.clone(),\n args: args.to_vec(),\n },\n });\n })\n}\n\npub fn exit_function(ident: &FunctionIdent, ret: Option<&CallReturn>) {\n TRACE_COLLECTOR.with(|c| {\n let mut c = c.lock().unwrap();\n let pid = c.current_pid;\n {\n let stack = c.pid_stacks.get_mut(&pid).unwrap();\n let removed = stack.pop().unwrap();\n assert!(&removed.module == module);\n assert!(&removed.ident == ident);\n }\n c.events.push(TraceEvent {\n pid: pid,\n typ: TraceEventType::FunctionExit {\n ret: ret.cloned(),\n },\n });\n })\n}\n\npub fn start_basic_block(module: &Atom, ident: &FunctionIdent, block: LabelN) {\n TRACE_COLLECTOR.with(|c| {\n let mut c = c.lock().unwrap();\n let pid = c.current_pid;\n c.events.push(TraceEvent{\n pid: pid,\n typ: TraceEventType::BasicBlockStart {\n module: module.clone(),\n ident: ident.clone(),\n block: block,\n },\n });\n })\n}\n\npub fn end_basic_block() {\n TRACE_COLLECTOR.with(|c| {\n let mut c = c.lock().unwrap();\n let pid = c.current_pid;\n c.events.push(TraceEvent{\n pid: pid,\n typ: TraceEventType::BasicBlockEnd,\n });\n })\n}\n\npub fn warning(text: String) {\n TRACE_COLLECTOR.with(|c| {\n let mut c = c.lock().unwrap();\n let pid = c.current_pid;\n c.events.push(TraceEvent {\n pid: pid,\n typ: TraceEventType::Warning {\n text: text,\n args: HashMap::new(),\n }\n });\n })\n}\n\npub fn warning_args(text: String, make_args: F) where F: FnOnce() -> HashMap {\n TRACE_COLLECTOR.with(|c| {\n let mut c = c.lock().unwrap();\n let pid = c.current_pid;\n c.events.push(TraceEvent {\n pid: pid,\n typ: TraceEventType::Warning {\n text: text,\n args: (make_args)()\n }\n });\n })\n}\n\npub fn dump_trace(filename: String) {\n let json = TRACE_COLLECTOR.with(|c| {\n let c = c.lock().unwrap();\n let mut idx = 0;\n let json_events: Vec<_> = c.events.iter()\n .map(|event| {\n match &event.typ {\n TraceEventType::FunctionEnter { ident, args, .. } => {\n let mut event_args = HashMap::new();\n let fun_args: Vec<_> = args.iter()\n .map(|a| ::serde_json::Value::String(\n format!(\"{}\", a.to_doc().pretty(40))))\n .collect();\n event_args.insert(\n \"Call Arguments\".to_string(),\n ::serde_json::Value::Array(fun_args)\n );\n TraceEntry::DurationStart {\n timestamp: idx as u64,\n pid: event.pid.0 as u64,\n tid: 0,\n cname: None,\n args: event_args,\n name: format!(\"{}\", ident),\n categories: \"\".to_string(),\n }\n }\n TraceEventType::FunctionExit { ret } => {\n if ret.is_some() { idx += 1; }\n let mut event_args = HashMap::new();\n event_args.insert(\n \"Call Return\".to_string(),\n match ret {\n None => ::serde_json::Value::String(\n \"TailCall\".to_string()),\n Some(CallReturn::Return{ term: val }) =>\n ::serde_json::Value::String(\n format!(\"{}\", val.to_doc().pretty(40))),\n Some(CallReturn::Throw) =>\n ::serde_json::Value::String(\"Throw\".to_string()),\n }\n );\n TraceEntry::DurationEnd {\n timestamp: idx as u64,\n pid: event.pid.0 as u64,\n tid: 0,\n args: event_args,\n }\n }\n TraceEventType::BasicBlockStart { module, ident, block } => {\n TraceEntry::DurationStart {\n timestamp: idx as u64,\n pid: event.pid.0 as u64,\n tid: 1,\n cname: None,\n args: HashMap::new(),\n name: format!(\"{} ({}:{})\", block, module, ident),\n categories: \"\".to_string(),\n }\n }\n TraceEventType::BasicBlockEnd => {\n idx += 1;\n TraceEntry::DurationEnd {\n timestamp: idx as u64,\n pid: event.pid.0 as u64,\n tid: 1,\n args: HashMap::new(),\n }\n }\n TraceEventType::Warning { text, args } => {\n TraceEntry::Instant {\n name: text.clone(),\n timestamp: idx as u64,\n pid: event.pid.0 as u64,\n tid: 0,\n scope: \"p\",\n args: args.clone(),\n }\n }\n }\n }).collect();\n serde_json::to_string(&json_events)\n });\n\n ::std::fs::write(filename, json.unwrap()).unwrap();\n}\n\n\n\n\n\n" }, { "path": "libeir_interpreter/src/vm.rs", "content": "use std::cell::RefCell;\nuse std::collections::HashMap;\nuse std::rc::Rc;\n\nuse crate::module::{ErlangModule, ModuleType, NativeModule};\nuse crate::process::{CallExecutor, Continuation, ProcessContext, TermCall};\nuse crate::term::{Pid, Reference, Term};\n\nuse libeir_intern::Symbol;\nuse libeir_ir::{FunctionIdent, Module};\n\n#[derive(Debug, Clone, Copy, Eq, PartialEq)]\npub enum WatchType {\n Link,\n Monitor(Reference),\n}\n\n#[derive(Debug)]\npub struct ReferenceGenerator(Reference);\nimpl ReferenceGenerator {\n fn new() -> Self {\n ReferenceGenerator(Reference(0))\n }\n\n pub fn next(&mut self) -> Reference {\n let r = self.0;\n (self.0).0 += 1;\n r\n }\n}\n\npub struct VMState {\n pub modules: HashMap,\n pub processes: RefCell>>>,\n\n pub ref_gen: RefCell,\n // Hashmap of all watches a process has placed on it.\n //pub watches: RefCell>>,\n\n //pub mailboxes: RefCell>,\n}\n\nimpl VMState {\n pub fn new() -> Self {\n VMState {\n modules: HashMap::new(),\n processes: RefCell::new(Vec::new()),\n ref_gen: RefCell::new(ReferenceGenerator::new()),\n //watches: RefCell::new(HashMap::new()),\n //mailboxes: RefCell::new(HashMap::new()),\n }\n }\n\n pub fn add_erlang_module(&mut self, module: Module) {\n let erl_mod = ErlangModule::from_eir(module);\n match self.modules.remove(&erl_mod.name) {\n None => {\n self.modules\n .insert(erl_mod.name, ModuleType::Erlang(erl_mod, None));\n }\n Some(ModuleType::Native(native)) => {\n self.modules\n .insert(erl_mod.name, ModuleType::Erlang(erl_mod, Some(native)));\n }\n _ => panic!(),\n }\n }\n\n pub fn add_native_module(&mut self, module: NativeModule) {\n match self.modules.remove(&module.name) {\n None => {\n self.modules.insert(module.name, ModuleType::Native(module));\n }\n Some(ModuleType::Erlang(erl, None)) => {\n self.modules\n .insert(module.name, ModuleType::Erlang(erl, Some(module)));\n }\n _ => panic!(),\n }\n }\n\n pub fn add_nif_overlay(&mut self, module: NativeModule) {\n let existing = self.modules.get_mut(&module.name).unwrap();\n if let ModuleType::Erlang(_, ref mut overlay) = existing {\n assert!(overlay.is_none());\n *overlay = Some(module);\n } else {\n panic!();\n }\n }\n\n pub fn add_builtin_modules(&mut self) {\n self.add_native_module(crate::erl_lib::make_erlang());\n self.add_native_module(crate::erl_lib::make_lists());\n self.add_native_module(crate::erl_lib::make_math());\n self.add_native_module(crate::erl_lib::make_maps());\n }\n\n pub fn call(\n &mut self,\n fun: &FunctionIdent,\n args: &[Term],\n ) -> Result, (Rc, Rc, Rc)> {\n let self_pid = {\n let processes = self.processes.borrow();\n Pid(processes.len())\n };\n\n let mut process = ProcessContext::new(self_pid);\n\n let fun_term = Term::CapturedFunction { ident: fun.clone() };\n\n let mut n_args = Vec::new();\n n_args.push(Term::ReturnOk.into());\n n_args.push(Term::ReturnThrow.into());\n n_args.extend(args.iter().cloned().map(|v| v.into()));\n\n let mut continuation = TermCall {\n fun: fun_term.into(),\n args: n_args,\n };\n\n let mut executor = CallExecutor::new();\n loop {\n match executor.run(self, &mut process, continuation) {\n Continuation::Term(call) => continuation = call,\n Continuation::ReturnOk(ret) => return Ok(ret),\n Continuation::ReturnThrow(r1, r2, r3) => return Err((r1, r2, r3)),\n }\n }\n }\n\n //pub fn call(&mut self, module_name: &str, fun_name: &str, args: Vec)\n // -> CallReturn {\n // let fun_ident = FunctionIdent {\n // module: Atom::from_str(module_name),\n // name: Atom::from_str(fun_name),\n // arity: args.len(),\n // lambda: None,\n // };\n\n // let self_pid = {\n // let processes = self.processes.borrow();\n // Pid(processes.len())\n // };\n // ::trace::set_pid(self_pid);\n\n // let process = ProcessContext::new(self_pid);\n\n // let frame = process.make_call_stackframe(\n // self,\n // Atom::from_str(module_name),\n // fun_ident,\n // args\n // );\n\n // {\n // let mut processes = self.processes.borrow_mut();\n // {\n // let mut stack = process.stack.borrow_mut();\n // stack.push(frame);\n // }\n // processes.push(Rc::new(RefCell::new(process)));\n // }\n // {\n // let mut mailboxes = self.mailboxes.borrow_mut();\n // mailboxes.insert(self_pid, ::mailbox::Mailbox::new());\n // }\n\n // loop {\n // let processes_len = self.processes.borrow().len();\n // for process_num in 0..processes_len {\n // println!(\"=====================================\");\n // println!(\"======== SWITCH TO PROCESS {} ========\", process_num);\n // println!(\"=====================================\");\n // ::trace::set_pid(Pid(process_num));\n\n // let process_rc = self.processes.borrow()[process_num].clone();\n // let mut process = process_rc.borrow_mut();\n // process.run_reductions(self, 4000);\n // }\n\n // let processes_borrow = self.processes.borrow();\n // let process_borrow = processes_borrow[self_pid.0].borrow();\n // if process_borrow.stack.borrow().len() == 0 {\n // break;\n // }\n // }\n\n // let processes_borrow = self.processes.borrow();\n // let mut process = processes_borrow[self_pid.0].borrow_mut();\n // process.return_val.take().unwrap()\n //}\n}\n" }, { "path": "libeir_ir/Cargo.toml", "content": "[package]\nname = \"libeir_ir\"\nversion = \"0.1.0\"\nauthors = [\"Hans Elias B. Josephsen \"]\nedition = \"2018\"\nbuild = \"build.rs\"\nlicense = \"MIT OR Apache-2.0\"\n\n[features]\nbinary_serialization = [\"bincode\"]\n\n[dependencies]\nlibeir_intern = { path = \"../libeir_intern\" }\nlibeir_diagnostics = { path = \"../libeir_diagnostics\" }\nlibeir_util_datastructures = { path = \"../util/libeir_util_datastructures\" }\nlibeir_util_parse = { path = \"../util/libeir_util_parse\" }\nlibeir_util_number = { path = \"../util/libeir_util_number\" }\nlibeir_util_binary = { path = \"../util/libeir_util_binary\" }\nlibeir_util_dot_graph = { path = \"../util/libeir_util_dot_graph\" }\nmeta_table = { path = \"../util/meta_table\" }\n\nstack_dst = { version = \"0.6.0\", features = [\"unsize\"] }\n\nstring-intern = { version = \"0.1.7\", default-features = false }\npretty = \"0.7\"\nlazy_static = \"1.2.0\"\nitertools = \"0.8.0\"\nlog = \"0.4\"\n\ncranelift-entity = \"0.56.0\"\ncranelift-bforest = { git = \"https://github.com/hansihe/wasmtime.git\", branch = \"main\" }\n\nbumpalo = { git = \"https://github.com/hansihe/bumpalo\", branch = \"master\", features = [\"nightly\"] }\n\npetgraph = \"0.4\"\n\nmatches = \"0.1.8\"\nregex = \"1\"\n\nserde = { version = \"1.0\", features = [\"derive\"] }\nbincode = { version = \"1.1\", optional = true }\n\nlalrpop-util = \"0.17\"\n\nsnafu = \"0.5\"\n\nfnv = \"1.0.3\"\nhashbrown = { git = \"https://github.com/rust-lang/hashbrown.git\", features = [\"raw\", \"nightly\"] }\n\n[dev-dependencies]\npretty_assertions = \"0.6\"\n\n[build-dependencies]\nlalrpop = \"0.17\"\n\n#[dependencies.rug]\n#version = \"1.2\"\n#default-features = false\n#features = [\"integer\", \"float\", \"rand\"]\n" }, { "path": "libeir_ir/build.rs", "content": "extern crate lalrpop;\n\nfn main() {\n lalrpop::Configuration::new()\n .use_cargo_dir_conventions()\n .process_file(\"src/text/parser/grammar.lalrpop\")\n .unwrap();\n\n println!(\"cargo:rerun-if-changed=src/text/parser/grammar.lalrpop\");\n}\n" }, { "path": "libeir_ir/src/algo/equality.rs", "content": "use std::collections::{BTreeMap, VecDeque};\n\nuse snafu::Snafu;\n\nuse crate::Function;\nuse crate::ValueKind;\nuse crate::{Block, Const, Location, PrimOp, Value};\n\n#[derive(Snafu, Debug, PartialEq, Eq)]\npub enum EqualityFail {\n BlockArity {\n left: Block,\n right: Block,\n },\n\n BlockOp {\n left: Block,\n right: Block,\n },\n\n BlockReadsLength {\n left: Block,\n right: Block,\n },\n\n MismatchingValue {\n left: Value,\n right: Value,\n },\n\n PrimReadsLength {\n left: PrimOp,\n right: PrimOp,\n },\n\n MismatchingConst {\n left: Const,\n right: Const,\n },\n\n MismatchingBlockLocation {\n left_block: Block,\n right_block: Block,\n left_loc: Location,\n right_loc: Location,\n\n left_desc: String,\n right_desc: String,\n },\n}\n\nstruct EqCtx<'a> {\n lf: &'a Function,\n rf: &'a Function,\n to_walk: VecDeque<(Block, Block)>,\n to_check: Vec<(Value, Value)>,\n map: BTreeMap,\n}\n\n#[derive(Debug, Copy, Clone)]\npub struct GraphEqOptions {\n pub check_block_locations: bool,\n}\n\nimpl Default for GraphEqOptions {\n fn default() -> Self {\n GraphEqOptions {\n check_block_locations: false,\n }\n }\n}\n\nimpl Function {\n pub fn graph_eq_opts(\n &self,\n lhs_block: Block,\n rhs: &Function,\n rhs_block: Block,\n opts: &GraphEqOptions,\n ) -> Result<(), EqualityFail> {\n let mut ctx = EqCtx {\n lf: self,\n rf: rhs,\n\n map: BTreeMap::new(),\n\n to_walk: VecDeque::new(),\n to_check: Vec::new(),\n };\n\n // 1.\n // Walk block graph and validate basic cfg isomorphism.\n // We can't just use normal block graph DFS when iterating here\n // because search order is not defined.\n // In this case we need to discover the mapping between blocks\n // in the two block scopes we are comparing, so order of values\n // is critical.\n ctx.to_walk.push_back((lhs_block, rhs_block));\n ctx.map\n .insert(ctx.lf.block_value(lhs_block), ctx.rf.block_value(rhs_block));\n\n while let Some((l_b, r_b)) = ctx.to_walk.pop_front() {\n // The mapping for the blocks should always have been created\n // when inserting it into the `to_walk` list.\n let l_block_val = ctx.lf.block_value(l_b);\n let r_block_val = ctx.rf.block_value(r_b);\n debug_assert_eq!(ctx.map.get(&l_block_val), Some(&r_block_val));\n\n // Insert mappings between the block args.\n let l_args = ctx.lf.block_args(l_b);\n let r_args = ctx.rf.block_args(r_b);\n if l_args.len() != r_args.len() {\n return Result::Err(EqualityFail::BlockArity {\n left: l_b,\n right: r_b,\n });\n }\n for (l, r) in l_args.iter().zip(r_args.iter()) {\n ctx.map.insert(*l, *r);\n }\n\n // Check equality between the operations themselves\n if !ctx.lf.block_op_eq(l_b, &ctx.rf, r_b) {\n return Result::Err(EqualityFail::BlockOp {\n left: l_b,\n right: r_b,\n });\n }\n\n // Traverse the block OP read values\n let l_reads = ctx.lf.block_reads(l_b);\n let r_reads = ctx.rf.block_reads(r_b);\n if l_reads.len() != r_reads.len() {\n return Result::Err(EqualityFail::BlockReadsLength {\n left: l_b,\n right: r_b,\n });\n }\n for (l, r) in l_reads.iter().zip(r_reads.iter()) {\n traverse_value(&mut ctx, *l, *r)?;\n }\n }\n\n // 2. Check all remaining values that are arguments\n for (l, r) in ctx.to_check.iter() {\n if ctx.map.get(l) != Some(r) {\n return Result::Err(EqualityFail::MismatchingValue {\n left: *l,\n right: *r,\n });\n }\n }\n\n for (lhs_v, rhs_v) in ctx.map.iter() {\n match (self.value_block(*lhs_v), rhs.value_block(*rhs_v)) {\n (Some(lhs_b), Some(rhs_b)) => {\n if opts.check_block_locations {\n let l_loc = self.block_location(lhs_b);\n let r_loc = rhs.block_location(rhs_b);\n if !self.locations.location_eq(l_loc, &rhs.locations, r_loc) {\n return Result::Err(EqualityFail::MismatchingBlockLocation {\n left_block: lhs_b,\n right_block: rhs_b,\n left_loc: l_loc,\n right_loc: r_loc,\n left_desc: self.locations.format_loc(l_loc),\n right_desc: rhs.locations.format_loc(r_loc),\n });\n }\n }\n }\n _ => (),\n }\n }\n\n Ok(())\n }\n\n pub fn graph_eq(\n &self,\n lhs_block: Block,\n rhs: &Function,\n rhs_block: Block,\n ) -> Result<(), EqualityFail> {\n self.graph_eq_opts(lhs_block, rhs, rhs_block, &GraphEqOptions::default())\n }\n}\n\nfn traverse_value<'a>(ctx: &mut EqCtx<'a>, l: Value, r: Value) -> Result<(), EqualityFail> {\n if let Some(nr) = ctx.map.get(&l) {\n if *nr == r {\n return Ok(());\n } else {\n return Err(EqualityFail::MismatchingValue { left: l, right: r });\n }\n }\n\n match (ctx.lf.value_kind(l), ctx.rf.value_kind(r)) {\n (ValueKind::Block(lb), ValueKind::Block(rb)) => {\n ctx.map.insert(l, r);\n ctx.to_walk.push_back((lb, rb));\n Ok(())\n }\n (ValueKind::Argument(_, _), ValueKind::Argument(_, _)) => {\n ctx.to_check.push((l, r));\n Ok(())\n }\n (ValueKind::Const(lc), ValueKind::Const(rc)) => {\n if !ctx.lf.cons().eq_other(lc, ctx.rf.cons(), rc) {\n return Err(EqualityFail::MismatchingConst {\n left: lc,\n right: rc,\n });\n }\n Ok(())\n }\n (ValueKind::PrimOp(lp), ValueKind::PrimOp(rp)) => {\n let l_reads = ctx.lf.primop_reads(lp);\n let r_reads = ctx.rf.primop_reads(rp);\n if l_reads.len() != r_reads.len() {\n return Err(EqualityFail::PrimReadsLength {\n left: lp,\n right: rp,\n });\n }\n for (l, r) in l_reads.iter().zip(r_reads.iter()) {\n traverse_value(ctx, *l, *r)?;\n }\n Ok(())\n }\n _ => Err(EqualityFail::MismatchingValue { left: l, right: r }),\n }\n}\n\n#[cfg(test)]\nmod tests {\n use crate::parse_function_unwrap;\n\n #[test]\n fn basic_equality() {\n let ir1 = parse_function_unwrap(\n \"\na'foo':a'bar'/1 {\n entry(%ret, %thr, %arg1):\n block2(%arg1);\n block2(%b):\n block3(%b);\n block3(%a):\n %ret(%a);\n}\n\",\n );\n\n let ir2 = parse_function_unwrap(\n \"\na'a':a'b'/1 {\n entry(%ret, %thr, %arg1):\n block2(%arg1);\n block3(%a):\n %ret(%a);\n block2(%b):\n block3(%b);\n}\n\",\n );\n\n assert!(ir1\n .graph_eq(ir1.block_entry(), &ir2, ir2.block_entry())\n .is_ok());\n }\n\n #[test]\n fn args_length_inequality() {\n let ir1 = parse_function_unwrap(\n \"\na'foo':a'bar'/2 {\n entry(%ret, %thr, %arg1, %arg2):\n %ret(%arg1);\n}\n\",\n );\n\n let ir2 = parse_function_unwrap(\n \"\na'foo':a'bar'/1 {\n entry(%ret, %thr, %arg1):\n %ret(%arg1);\n}\n\",\n );\n\n assert!(ir1\n .graph_eq(ir1.block_entry(), &ir2, ir2.block_entry())\n .is_err());\n }\n\n #[test]\n fn args_read_inequality() {\n let ir1 = parse_function_unwrap(\n \"\na'foo':a'bar'/2 {\n entry(%ret, %thr, %arg1, %arg2):\n %ret(%arg1);\n}\n\",\n );\n\n let ir2 = parse_function_unwrap(\n \"\na'foo':a'bar'/2 {\n entry(%ret, %thr, %arg1, %arg2):\n %ret(%arg2);\n}\n\",\n );\n\n assert!(ir1\n .graph_eq(ir1.block_entry(), &ir2, ir2.block_entry())\n .is_err());\n }\n\n #[test]\n fn args_read_const_equality() {\n let ir1 = parse_function_unwrap(\n \"\na'foo':a'bar'/2 {\n entry(%ret, %thr, %arg1, %arg2):\n %ret(a'a');\n}\n\",\n );\n\n let ir2 = parse_function_unwrap(\n \"\na'foo':a'bar'/2 {\n entry(%ret, %thr, %arg1, %arg2):\n %ret(a'a');\n}\n\",\n );\n\n assert!(ir1\n .graph_eq(ir1.block_entry(), &ir2, ir2.block_entry())\n .is_ok());\n }\n\n #[test]\n fn args_read_const_inequality() {\n let ir1 = parse_function_unwrap(\n \"\na'foo':a'bar'/2 {\n entry(%ret, %thr, %arg1, %arg2):\n %ret(a'a');\n}\n\",\n );\n\n let ir2 = parse_function_unwrap(\n \"\na'foo':a'bar'/2 {\n entry(%ret, %thr, %arg1, %arg2):\n %ret(a'b');\n}\n\",\n );\n\n assert!(ir1\n .graph_eq(ir1.block_entry(), &ir2, ir2.block_entry())\n .is_err());\n }\n\n #[test]\n fn args_prim_inequality() {\n let ir1 = parse_function_unwrap(\n \"\na'foo':a'bar'/1 {\n entry(%ret, %thr, %arg1):\n %fun = a'a':a'a'/1;\n %fun(%ret, %thr, %arg1);\n}\n\",\n );\n\n let ir2 = parse_function_unwrap(\n \"\na'foo':a'bar'/1 {\n entry(%ret, %thr, %arg1):\n %fun = a'a':a'b'/1;\n %fun(%ret, %thr, %arg1);\n}\n\",\n );\n\n assert!(ir1\n .graph_eq(ir1.block_entry(), &ir2, ir2.block_entry())\n .is_err());\n }\n\n #[test]\n fn block_location_equality() {\n let opts = super::GraphEqOptions {\n check_block_locations: true,\n };\n\n let ir1 = parse_function_unwrap(\n \"\na'foo':a'bar'/1 {\n !location [\\\"foo\\\":\\\"bar\\\"@\\\"foo.erl\\\":12];\n entry(%ret, %thr, %arg1):\n %ret(%arg1);\n}\n\",\n );\n\n let ir2 = parse_function_unwrap(\n \"\na'foo':a'bar'/1 {\n !location [\\\"foo\\\":\\\"bar\\\"@\\\"foo.erl\\\":12];\n entry(%ret, %thr, %arg1):\n %ret(%arg1);\n}\n\",\n );\n\n assert!(ir1\n .graph_eq_opts(ir1.block_entry(), &ir2, ir2.block_entry(), &opts)\n .is_ok());\n }\n}\n" }, { "path": "libeir_ir/src/algo/func_tree.rs", "content": "use std::collections::{BTreeMap, BTreeSet};\n\nuse petgraph::visit::{Dfs, DfsPostOrder};\nuse petgraph::visit::{GraphBase, IntoNeighbors, Visitable, Walker};\n\nuse crate::graph::EntityVisitMap;\nuse crate::{Block, CallKind, Function, LiveValues, OpKind, Value};\n\n#[derive(Debug, Clone)]\npub struct FunctionTree {\n /// The root function, specified by the entry block of the function\n /// container.\n pub root_fun: Block,\n\n /// The descriptions of the different functions contained within this\n /// container.\n /// This is guaranteed to contain at least one entry, the root function.\n pub functions: BTreeMap,\n}\n\n#[derive(Debug, Clone)]\npub struct FunctionEntry {\n /// The entry point of the function.\n /// The continuations are always the first arguments of this block.\n /// * If both `ret` and `thr` are `Some`, the first two are those\n /// continuations respectively.\n /// * If only one of `ret` and `thr` are `Some`, only the first argument\n /// is that continuation.\n /// * If both are `None`, this function never returns.\n /// At the moment both will always be `Some`, but this may change in the\n /// future.\n pub entry: Block,\n\n /// The return continuation for this function.\n /// This value is always either:\n /// * Called with a `CallKind::ControlFlow` operation, this is a return.\n /// * Passed as argument 1 to a `CallKind::Function`, this is a tail call.\n pub ret: Option,\n /// The throw continuation for this function.\n /// This value is always either:\n /// * Called with a `CallKind::ControlFlow` operation, this is a throw.\n /// * Passed as argument 2 to a `CallKind::Function`, this is a tail call.\n pub thr: Option,\n\n /// This is the scope of the function.\n /// This includes all blocks that can be reached by control flow within\n /// the current stack frame.\n /// Does not include calls to functions, those create a new stack frame.\n pub scope: BTreeSet,\n\n /// The children function entries of this function.\n pub children: BTreeSet,\n}\n\nenum Escape {\n Return,\n Throw,\n}\n\nimpl Function {\n pub fn func_tree(&self, live: &LiveValues, resolve_continuations: bool) -> FunctionTree {\n let graph = self.block_graph();\n\n // Identify which blocks get captured.\n // At at least one location in the IR, these are not branched to directly\n // by an operation, but instead captured as a value.\n // For a capture to be valid, it needs to only return through one of its\n // arguments.\n let mut blocks = BTreeSet::new();\n\n let mut captured_blocks = BTreeSet::new();\n captured_blocks.insert(self.block_entry());\n {\n let mut branched = BTreeSet::new();\n for block in graph.dfs_iter() {\n blocks.insert(block);\n\n branched.clear();\n branched.extend(self.op_branch_iter(block));\n\n self.block_walk_nested_values::<_, Result<(), ()>>(block, &mut |v| {\n if let Some(v_block) = self.value_block(v) {\n if !branched.contains(&v) {\n captured_blocks.insert(v_block);\n }\n }\n Ok(())\n })\n .unwrap();\n }\n }\n\n if resolve_continuations {\n // Find all escape continuations for all captures\n let mut escapes = BTreeMap::new();\n for block in captured_blocks.iter() {\n let args = self.block_args(*block);\n assert!(args.len() >= 2);\n escapes.insert(args[0], Escape::Return);\n escapes.insert(args[1], Escape::Throw);\n }\n\n // Validate that at every point only the escape continuations for\n // the current functions are live.\n for block in captured_blocks.iter() {\n let live_at = live.live_at(*block);\n for live_val in live_at.iter() {\n assert!(!escapes.contains_key(&live_val));\n }\n }\n\n // Validate that escapes are only either:\n // * Called as control flow\n // * Passed as an escape to a function call\n // More specifically, escapes should NEVER be:\n // * Passed as a regular argument to a function call\n // * Passed as an argument to a control flow call\n for (value, escape) in escapes.iter() {\n for usage in self.value_usages(*value).iter() {\n if !blocks.contains(&usage) {\n continue;\n }\n\n let check: &dyn Fn(&[Value]) = &|values| {\n for read in values.iter() {\n self.value_walk_nested_values::<_, Result<(), ()>>(*read, &mut |v| {\n assert!(v != *value);\n Ok(())\n })\n .unwrap();\n }\n };\n\n let reads = self.block_reads(usage);\n match self.block_kind(usage).unwrap() {\n OpKind::Call(CallKind::ControlFlow) => {\n assert!(reads[0] == *value);\n check(&reads[1..]);\n }\n OpKind::Call(CallKind::Function) => {\n check(&[reads[0]]);\n match *escape {\n Escape::Return => {\n assert!(reads[1] == *value);\n check(&[reads[2]]);\n }\n Escape::Throw => {\n check(&[reads[1]]);\n assert!(reads[2] == *value);\n }\n }\n check(&reads[3..]);\n }\n _ => (),\n }\n }\n }\n }\n\n // Generate the scopes for all of the functions\n let mut functions = BTreeMap::new();\n let mut cfg_graph = self.control_flow_graph();\n for block in captured_blocks.iter() {\n cfg_graph.calculate(self, self.block_value(*block));\n\n let mut function_scope = BTreeSet::new();\n let mut to_walk = Vec::new();\n to_walk.push(*block);\n\n while let Some(block) = to_walk.pop() {\n if function_scope.contains(&block) {\n continue;\n }\n function_scope.insert(block);\n\n let block_val = self.block_value(block);\n\n for out in cfg_graph.neighbors(block_val) {\n if let Some(out_block) = self.value_block(out) {\n if !captured_blocks.contains(&out_block) {\n to_walk.push(out_block);\n }\n }\n }\n }\n\n let args = self.block_args(*block);\n\n let mut children = function_scope\n .intersection(&captured_blocks)\n .cloned()\n .collect::>();\n children.remove(block);\n\n let mut ret = None;\n let mut thr = None;\n if resolve_continuations {\n ret = Some(args[0]);\n thr = Some(args[1]);\n }\n\n functions.insert(\n *block,\n FunctionEntry {\n entry: *block,\n\n ret,\n thr,\n\n children,\n\n scope: function_scope,\n },\n );\n }\n\n let tree = FunctionTree {\n root_fun: self.block_entry(),\n functions,\n };\n\n assert!(tree\n .validate_no_cycles(tree.root_fun, 0, tree.functions.len())\n .is_some());\n\n tree\n }\n}\n\nimpl FunctionTree {\n fn validate_no_cycles(&self, entry: Block, mut curr: usize, limit: usize) -> Option {\n if curr > limit {\n return None;\n }\n for child in self.functions[&entry].children.iter() {\n curr = self.validate_no_cycles(*child, curr + 1, limit)?;\n }\n Some(curr)\n }\n\n pub fn dfs(&self) -> Dfs> {\n Dfs::new(self, self.root_fun)\n }\n pub fn dfs_iter<'a>(&'a self) -> impl Iterator + 'a {\n self.dfs().iter(self)\n }\n\n pub fn dfs_post_order(&self) -> DfsPostOrder> {\n DfsPostOrder::new(self, self.root_fun)\n }\n pub fn dfs_post_order_iter<'a>(&'a self) -> impl Iterator + 'a {\n self.dfs_post_order().iter(self)\n }\n}\n\nimpl GraphBase for FunctionTree {\n type NodeId = Block;\n type EdgeId = (Block, Block);\n}\n\nimpl<'a> IntoNeighbors for &'a FunctionTree {\n type Neighbors = std::iter::Cloned>;\n fn neighbors(self, block: Block) -> Self::Neighbors {\n self.functions[&block].children.iter().cloned()\n }\n}\n\nimpl Visitable for FunctionTree {\n type Map = EntityVisitMap;\n fn visit_map(&self) -> EntityVisitMap {\n EntityVisitMap::new(self.functions.len())\n }\n fn reset_map(&self, map: &mut EntityVisitMap) {\n map.reset(self.functions.len());\n }\n}\n" }, { "path": "libeir_ir/src/algo/live.rs", "content": "use std::collections::HashMap;\n\nuse crate::Function;\nuse crate::{Block, Value};\n\nuse cranelift_bforest::{BoundSet, Set, SetForest};\nuse libeir_util_datastructures::aux_traits::{AuxDebug, AuxImpl, HasAux};\n\nimpl Function {\n pub fn live_values(&self) -> LiveValues {\n calculate_live_values(self)\n }\n}\n\n/// # Value liveness calculation\n/// Utility for calculating live values at every point in a functions\n/// CFG.\n///\n/// TODO\n/// Right now this uses a (probably) bad algorithm I made up on the spot.\n/// I am sure there are better and more efficient ways of doing this,\n/// but this should work for now.\n/// For CFGs that are acyclic, this algorithm will complete in a single\n/// iteration. For cyclic CFGs, this should take (around) 1 extra iteration\n/// for every additional nested cycle.\n#[derive(Clone)]\npub struct LiveValues {\n /// Values that need to exist at every block.\n /// Before block arguments.\n live_at: HashMap>,\n /// Values that need to exist within every block.\n /// After block arguments, before operation.\n live_in: HashMap>,\n /// The pool where `ebb_live` and `flow_live` is allocated.\n forest: SetForest,\n}\n\nimpl HasAux> for LiveValues {\n fn get_aux(&self) -> &SetForest {\n &self.forest\n }\n}\n\nimpl>> AuxDebug for LiveValues {\n fn aux_fmt(&self, f: &mut std::fmt::Formatter<'_>, _aux: &C) -> std::fmt::Result {\n let mut b = f.debug_struct(\"LiveValues\");\n b.field(\"live_at\", &AuxImpl(&self.live_at, self));\n b.field(\"live_in\", &AuxImpl(&self.live_in, self));\n b.finish()\n }\n}\n\nimpl std::fmt::Debug for LiveValues {\n fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {\n self.aux_fmt(f, self)\n }\n}\n\nimpl LiveValues {\n pub fn live_at<'a>(&'a self, block: Block) -> BoundSet<'a, Value, ()> {\n self.live_at[&block].bind(&self.forest, &())\n }\n pub fn live_in<'a>(&'a self, block: Block) -> BoundSet<'a, Value, ()> {\n self.live_in[&block].bind(&self.forest, &())\n }\n\n pub fn is_live_at(&self, block: Block, value: Value) -> bool {\n self.live_at[&block].contains(value, &self.forest, &())\n }\n pub fn is_live_in(&self, block: Block, value: Value) -> bool {\n self.live_in[&block].contains(value, &self.forest, &())\n }\n}\n\nfn dataflow_pass(\n fun: &Function,\n pool: &mut SetForest,\n live: &mut HashMap>,\n live_in: &mut HashMap>,\n) -> bool {\n let graph = fun.block_graph();\n let mut visitor = graph.dfs_post_order();\n\n let mut stable = true;\n\n // For each Op node in the cfg\n while let Some(block) = visitor.next(&graph) {\n let mut set: Set = Set::new();\n\n // For each of the outgoing branches, add its live values to the current set\n for branch in graph.outgoing(block) {\n if let Some(vals) = live.get(&branch) {\n set.union_from(vals, pool, &());\n }\n }\n\n // Add the reads for the block OP to the current set\n for read in fun.block_reads(block) {\n // Only insert if it actually is a variable, not a block or constant\n fun.value_walk_nested_values::<_, ()>(*read, &mut |v| {\n if fun.value_argument(v).is_some() {\n set.insert(v, pool, &());\n }\n Ok(())\n })\n .unwrap();\n }\n\n // Update the live_after values\n if !live_in.contains_key(&block) {\n live_in.insert(block, Set::new());\n }\n live_in.get_mut(&block).unwrap().union_from(&set, pool, &());\n\n // Remove the block arguments from the current set\n for arg in fun.block_args(block) {\n set.remove(*arg, pool, &());\n }\n\n // If we don't have a previous live calculation for this block, or if\n // the live set has changed, we are not yet stable.\n if let Some(mut old_set) = live.remove(&block) {\n if !old_set.iter(pool).eq(set.iter(pool)) {\n stable = false;\n }\n old_set.clear(pool);\n } else {\n stable = false;\n }\n\n // Insert the new calculated live variables\n live.insert(block, set);\n }\n\n stable\n}\n\npub fn calculate_live_values(fun: &Function) -> LiveValues {\n let mut forest = SetForest::new();\n\n let mut live_at: HashMap> = HashMap::new();\n let mut live_in: HashMap> = HashMap::new();\n\n // Iterate dataflow until all dependencies have been resolved\n loop {\n let res = dataflow_pass(fun, &mut forest, &mut live_at, &mut live_in);\n if res {\n break;\n }\n }\n\n // Validate that the live set at entry is empty\n {\n let entry = fun.block_entry();\n assert!(\n live_at[&entry].iter(&forest).count() == 0,\n \"{:?}\",\n live_at[&entry].bind(&forest, &())\n );\n }\n\n LiveValues {\n forest,\n live_at,\n live_in,\n }\n}\n\n#[cfg(test)]\nmod tests {\n\n #[test]\n fn test_simple() {\n let (ir, map) = crate::parse_function_map_unwrap(\n \"\na'foo':a'bar'/1 {\n b1(%ret, %thr):\n b2();\n b2():\n b3();\n b3():\n %ret([]);\n}\n\",\n );\n\n let b1 = map.get_block(\"b1\");\n let b2 = map.get_block(\"b2\");\n let b3 = map.get_block(\"b3\");\n\n let b1_ret = map.get_value(\"ret\");\n\n let live = ir.live_values();\n\n let b1_live = live.live_at(b1);\n assert!(b1_live.iter().count() == 0);\n\n let b2_live = live.live_at(b2);\n assert!(b2_live.iter().count() == 1);\n assert!(b2_live.contains(b1_ret));\n\n let b3_live = live.live_at(b3);\n assert!(b3_live.iter().count() == 1);\n assert!(b3_live.contains(b1_ret));\n }\n\n #[test]\n fn test_cycle() {\n let (ir, map) = crate::parse_function_map_unwrap(\n \"\na'foo':a'bar'/1 {\n b1(%ret, %thr, %a):\n b2(%a, []);\n b2(%b, %c):\n b3();\n b3():\n b4();\n b4():\n b5(b6, %c);\n b5(%e, %f):\n b2(%e, %f);\n b6():\n %ret();\n}\n\",\n );\n\n let b1 = map.get_block(\"b1\");\n let b3 = map.get_block(\"b3\");\n let b5 = map.get_block(\"b5\");\n let b6 = map.get_block(\"b6\");\n\n let b1_ret = map.get_value(\"ret\");\n let b2_c = map.get_value(\"c\");\n\n let live = ir.live_values();\n\n let b1_live = live.live_at(b1);\n assert!(b1_live.iter().count() == 0);\n\n let b3_live = live.live_at(b3);\n assert!(b3_live.iter().count() == 2);\n assert!(b3_live.contains(b1_ret));\n assert!(b3_live.contains(b2_c));\n\n let b5_live = live.live_at(b5);\n assert!(b5_live.iter().count() == 1);\n assert!(b5_live.contains(b1_ret));\n\n let b6_live = live.live_at(b6);\n assert!(b6_live.iter().count() == 1);\n assert!(b6_live.contains(b1_ret));\n }\n}\n" }, { "path": "libeir_ir/src/algo/mangle/datatypes.rs", "content": "#![allow(dead_code)]\nuse crate::Function;\nuse crate::{Block, Value};\n\nuse super::MangleReceiver;\n\n#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]\npub struct FromT(pub T);\nimpl FromT {\n pub(super) fn map_fun<'a, 'b, R, F, V>(self, recv: &'a R, mut f: F) -> FromT\n where\n R: MangleReceiver<'b>,\n F: FnMut(&Function, T) -> V + 'a,\n {\n let fun = recv.from();\n let val = f(fun, self.inner());\n FromT(val)\n }\n\n pub fn inner(self) -> T {\n self.0\n }\n}\nimpl From for FromT {\n fn from(f: T) -> Self {\n FromT(f)\n }\n}\nimpl std::fmt::Display for FromT\nwhere\n T: std::fmt::Display,\n{\n fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {\n write!(f, \"From({})\", self.0)\n }\n}\npub(super) type FromValue = FromT;\npub(super) type FromBlock = FromT;\n\n#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]\npub struct ToT(pub T);\nimpl ToT {\n pub(super) fn map_fun<'a, 'b, R, F, V>(self, recv: &'a R, mut f: F) -> ToT\n where\n R: MangleReceiver<'b>,\n F: FnMut(&Function, T) -> V + 'a,\n {\n let fun = recv.to_fun();\n let val = f(fun, self.inner());\n ToT(val)\n }\n\n pub fn inner(self) -> T {\n self.0\n }\n}\nimpl From for ToT {\n fn from(f: T) -> Self {\n ToT(f)\n }\n}\nimpl std::fmt::Display for ToT\nwhere\n T: std::fmt::Display,\n{\n fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {\n write!(f, \"To({})\", self.0)\n }\n}\npub type ToValue = ToT;\npub type ToBlock = ToT;\n\n/// Because the mangler code supports operating across function containers,\n/// we need a mechanism to keep track of when a value is referenced in the\n/// old container or when it is referenced in the new one.\n#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]\npub enum MangleTarget {\n From(FromT),\n To(ToT),\n}\nimpl std::fmt::Display for MangleTarget\nwhere\n T: std::fmt::Display,\n{\n fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {\n write!(f, \"To({})\", self.inner_ref())\n }\n}\nimpl MangleTarget {\n pub fn inner(self) -> T {\n match self {\n MangleTarget::From(i) => i.0,\n MangleTarget::To(i) => i.0,\n }\n }\n pub fn inner_ref(&self) -> &T {\n match self {\n MangleTarget::From(i) => &i.0,\n MangleTarget::To(i) => &i.0,\n }\n }\n\n pub(super) fn fun<'a, 'b, R>(&self, recv: &'a R) -> &'a Function\n where\n R: MangleReceiver<'b>,\n {\n match self {\n MangleTarget::From(_) => recv.from(),\n MangleTarget::To(_) => recv.to_fun(),\n }\n }\n\n pub fn map(self, mut f: F) -> MangleTarget\n where\n F: FnMut(T) -> V,\n {\n match self {\n MangleTarget::From(i) => {\n let val = f(i.inner());\n MangleTarget::From(val.into())\n }\n MangleTarget::To(i) => {\n let val = f(i.inner());\n MangleTarget::To(val.into())\n }\n }\n }\n\n pub(super) fn map_fun<'a, 'b, R, F, V>(self, recv: &'a R, mut f: F) -> MangleTarget\n where\n R: MangleReceiver<'b>,\n F: FnMut(&Function, T) -> V + 'a,\n {\n let fun = self.fun(recv);\n match self {\n MangleTarget::From(i) => {\n let val = f(fun, i.inner());\n MangleTarget::From(val.into())\n }\n MangleTarget::To(i) => {\n let val = f(fun, i.inner());\n MangleTarget::To(val.into())\n }\n }\n }\n\n pub fn new_with(&self, new: N) -> MangleTarget {\n match self {\n MangleTarget::From(_) => MangleTarget::From(FromT(new)),\n MangleTarget::To(_) => MangleTarget::To(ToT(new)),\n }\n }\n\n pub fn from(self) -> Option> {\n match self {\n MangleTarget::From(inner) => Some(inner),\n MangleTarget::To(_) => None,\n }\n }\n pub fn to(self) -> Option> {\n match self {\n MangleTarget::From(_) => None,\n MangleTarget::To(inner) => Some(inner),\n }\n }\n}\nimpl MangleTarget> {\n pub fn transpose_opt(self) -> Option> {\n match self {\n MangleTarget::From(FromT(None)) => None,\n MangleTarget::To(ToT(None)) => None,\n MangleTarget::From(FromT(Some(v))) => Some(MangleTarget::From(v.into())),\n MangleTarget::To(ToT(Some(v))) => Some(MangleTarget::To(v.into())),\n }\n }\n}\nimpl MangleTarget<&T>\nwhere\n T: Clone,\n{\n pub fn cloned(&self) -> MangleTarget {\n self.map(|v| v.clone())\n }\n}\nimpl MangleTarget\nwhere\n I: IntoIterator,\n{\n pub fn transpose_iter(self) -> impl Iterator> {\n let constructor = match self {\n MangleTarget::From(_) => {\n fn a(v: V) -> MangleTarget {\n MangleTarget::From(FromT(v))\n }\n a\n }\n MangleTarget::To(_) => {\n fn a(v: V) -> MangleTarget {\n MangleTarget::To(ToT(v))\n }\n a\n }\n };\n self.inner().into_iter().map(constructor)\n }\n}\nimpl From> for MangleTarget {\n fn from(i: FromT) -> MangleTarget {\n MangleTarget::From(i)\n }\n}\nimpl From> for MangleTarget {\n fn from(i: ToT) -> MangleTarget {\n MangleTarget::To(i)\n }\n}\npub(super) type MangleValue = MangleTarget;\npub(super) type MangleBlock = MangleTarget;\n" }, { "path": "libeir_ir/src/algo/mangle/mod.rs", "content": "use std::collections::{BTreeMap, BTreeSet};\n\nuse bumpalo::Bump;\n\nuse libeir_diagnostics::SourceSpan;\n\nuse crate::Block;\nuse crate::ValueKind;\nuse crate::{Function, FunctionBuilder};\n\nmod receiver;\nuse receiver::MangleReceiver;\n\nmod datatypes;\n#[allow(unused_imports)]\nuse datatypes::{FromBlock, FromT, FromValue, MangleBlock, MangleValue, ToBlock, ToT, ToValue};\n\npub use datatypes::FromT as MangleFrom;\npub use datatypes::MangleTarget;\npub use datatypes::ToT as MangleTo;\n\n#[cfg(test)]\nmod tests;\n\n/// Utility struct implementing the lambda mangling primitive.\n/// Supports both mangling within a single function container, and\n/// across function containers, implemented by `run` and `run_across`\n/// respectively.\npub struct Mangler {\n entry: Option,\n new_entry: Option,\n\n /// Cache to reduce time complexity of `Self::map`\n actually_mapped: BTreeMap,\n\n pub values_map: BTreeMap,\n\n value_buf: Vec,\n\n values: Option>,\n\n scope: Option>,\n to_walk: Vec,\n\n bump: Option,\n}\n\nimpl Mangler {\n pub fn new() -> Self {\n Mangler {\n entry: None,\n new_entry: None,\n\n actually_mapped: BTreeMap::new(),\n values_map: BTreeMap::new(),\n\n value_buf: Vec::new(),\n\n values: Some(BTreeSet::new()),\n\n scope: Some(BTreeSet::new()),\n to_walk: Vec::new(),\n\n bump: Some(Bump::new()),\n }\n }\n\n /// Clears the mangler for a new use.\n /// This is automatically done by the `start` method.\n fn clear(&mut self) {\n self.entry = None;\n self.new_entry = None;\n\n self.actually_mapped.clear();\n self.values_map.clear();\n\n self.value_buf.clear();\n\n self.values.as_mut().unwrap().clear();\n\n self.scope.as_mut().unwrap().clear();\n self.to_walk.clear();\n\n self.bump.as_mut().unwrap().reset();\n }\n\n pub fn value_map<'a>(&'a self) -> &'a BTreeMap {\n &self.values_map\n }\n\n /// Clears the mangler of all existing data, and starts a new transaction\n /// for the given entry block.\n pub fn start(&mut self, from_block: F)\n where\n F: Into,\n {\n self.clear();\n self.entry = Some(from_block.into());\n }\n\n pub fn add_rename(&mut self, old: O, new: N)\n where\n O: Into,\n N: Into,\n {\n self.values_map.insert(old.into(), (new.into(), true));\n }\n\n /// Adds a value rename that should not be followed in the mangling process.\n /// This is extremely useful in that it allows you to limit the scope of the\n /// mangle.\n /// An example would be allowing you to only mangle the relevant parts when\n /// inlining a closure.\n pub fn add_rename_nofollow(&mut self, old: O, new: N)\n where\n O: Into,\n N: Into,\n {\n self.values_map.insert(old.into(), (new.into(), false));\n }\n\n /// Runs lambda mangling on a single function container\n pub fn run(&mut self, fun: &mut FunctionBuilder) -> Block {\n let mut recv = receiver::SingleMangleReceiver { fun };\n self.run_inner(&mut recv)\n }\n\n // Runs lambda mangling while copying across function containers\n pub fn run_across(&mut self, from: &Function, to: &mut FunctionBuilder) -> Block {\n let mut recv = receiver::CopyMangleReceiver { from, to };\n self.run_inner(&mut recv)\n }\n\n fn propagate_values(&mut self) {\n self.value_buf.clear();\n self.value_buf.extend(self.values_map.keys());\n for key in self.value_buf.iter() {\n let mut acc = *key;\n let mut follow = true;\n while let Some((target, n_follow)) = self.values_map.get(&acc) {\n if acc == *target {\n break;\n }\n acc = *target;\n follow = follow && *n_follow;\n }\n if *key == acc {\n self.values_map.remove(key);\n } else {\n *self.values_map.get_mut(key).unwrap() = (acc, follow);\n }\n }\n }\n\n fn run_inner<'a, 'b, R>(&mut self, recv: &'a mut R) -> Block\n where\n R: MangleReceiver<'b>,\n {\n let bump = self.bump.take().unwrap();\n\n let mut scope = self.scope.take().unwrap();\n let mut to_map_values = self.values.take().unwrap();\n\n // Propagate values\n self.propagate_values();\n\n // Get the mapped entry block\n let mut entry = self.entry.unwrap();\n if let Some((value, follow)) = self\n .values_map\n .get(&entry.map_fun(recv, |f, v| f.block_value(v)))\n {\n if !follow {\n panic!(\"WARNING: Mangle mapped to entry block due to no-follow\");\n //return entry;\n }\n if let Some(b) = value.map_fun(recv, |f, v| f.value_block(v)).transpose_opt() {\n entry = b;\n } else {\n // TODO: In this case, we need to directly return the value the\n // entry block has been mapped to.\n unimplemented!();\n }\n }\n\n // Walk scope\n {\n self.to_walk.push(entry);\n\n while let Some(start_block) = self.to_walk.pop() {\n if scope.contains(&start_block) {\n continue;\n }\n\n let block_value = start_block.map_fun(recv, |f, v| f.block_value(v));\n let block_value_mapped = self\n .values_map\n .get(&block_value)\n .map(|(v, _)| *v)\n .unwrap_or(block_value);\n\n let block_mapped_opt = block_value_mapped\n .map_fun(recv, |f, v| f.value_block(v))\n .transpose_opt();\n if block_mapped_opt.is_none() {\n continue;\n }\n\n let block = block_mapped_opt.unwrap();\n if scope.contains(&block) {\n continue;\n }\n\n scope.insert(block);\n\n let block_fun = block.fun(recv);\n for read in block_fun\n .block_reads(block.inner())\n .iter()\n .map(|b| block.new_with(b))\n {\n let fun = read.fun(recv);\n fun.value_walk_nested_values::<_, ()>(*read.inner(), &mut |val| {\n let val = read.new_with(val);\n if let Some((mapped, follow)) = self.values_map.get(&val) {\n if *follow {\n if let Some(block) = mapped\n .map_fun(recv, |f, v| f.value_block(v))\n .transpose_opt()\n {\n self.to_walk.push(block);\n }\n }\n }\n\n to_map_values.insert(val);\n Ok(())\n })\n .unwrap();\n }\n\n let block_fun = block.fun(recv);\n for out in block_fun.block_graph().outgoing(block.inner()) {\n self.to_walk.push(block.new_with(out));\n }\n }\n }\n\n // Insert new blocks\n {\n for block in scope.iter().cloned() {\n let block_val = block.map_fun(recv, |f, b| f.block_value(b));\n assert!(!self.values_map.contains_key(&block_val));\n\n let new_block = recv.to().block_insert();\n let new_block_val = ToT(recv.to().fun().block_value(new_block));\n self.values_map\n .insert(block_val, (new_block_val.into(), true));\n\n self.value_buf.clear();\n let block_fun = block.fun(recv);\n self.value_buf.extend(\n block_fun\n .block_args(block.inner())\n .iter()\n .map(|v| block.new_with(*v)),\n );\n\n // Insert new arguments\n let to = recv.to();\n for arg in self.value_buf.iter().cloned() {\n let new_arg = to.block_arg_insert(new_block);\n if !self.values_map.contains_key(&arg) {\n self.values_map.insert(arg, (ToT(new_arg).into(), true));\n }\n }\n }\n }\n\n // Propagate values\n self.propagate_values();\n\n // Map values\n to_map_values.extend(self.values_map.values().map(|(v, _)| *v));\n for val in to_map_values.iter() {\n self.map(&bump, recv, *val);\n }\n\n // Propagate values\n self.propagate_values();\n\n let copy_body =\n |mang: &mut Mangler, recv: &mut R, from_block: MangleBlock, to_block: ToBlock| {\n let to_op = recv.map_block_op(from_block);\n let loc = from_block.map_fun(recv, |f, b| f.block_location(b)).inner();\n\n // Get and map reads to new values\n mang.value_buf.clear();\n let from_block_fun = from_block.fun(recv);\n mang.value_buf.extend(\n from_block_fun\n .block_reads(from_block.inner())\n .iter()\n .map(|v| from_block.new_with(*v)),\n );\n for n in 0..mang.value_buf.len() {\n let v = mang.value_buf[n];\n let mapped = mang.values_map.get(&v).map(|v| v.0).unwrap_or(v);\n mang.value_buf[n] = mapped;\n }\n\n // Update the new block with kind, span and reads\n let to = recv.to();\n let to_fun = to.fun_mut();\n let data = &mut to_fun.blocks[to_block.inner()];\n\n data.op = Some(to_op);\n data.location = loc;\n\n for read in mang.value_buf.iter() {\n data.reads\n .push(read.to().unwrap().inner(), &mut to_fun.pool.value);\n }\n\n recv.to().graph_update_block(to_block.inner());\n };\n\n // Set new bodies\n for block in scope.iter().cloned() {\n let block_val = block.map_fun(recv, |f, b| f.block_value(b));\n let new_block_val_either = self.values_map.get(&block_val).unwrap().0;\n let new_block_val = new_block_val_either\n .to()\n .expect(\"attempted to set body on from block\");\n let new_block = new_block_val.map_fun(recv, |f, b| f.value_block(b).unwrap());\n\n copy_body(self, recv, block, new_block);\n }\n\n let entry = self.entry.unwrap();\n let entry_val = entry.map_fun(recv, |f, v| f.block_value(v));\n let new_entry_val = self\n .values_map\n .get(&entry_val)\n .map(|v| v.0)\n .unwrap_or(entry_val)\n .to()\n .unwrap();\n let new_entry = new_entry_val.map_fun(recv, |f, v| f.value_block(v).unwrap());\n\n self.values = Some(to_map_values);\n self.scope = Some(scope);\n self.bump = Some(bump);\n self.clear();\n\n new_entry.inner()\n }\n\n fn map<'a, 'b, R>(&mut self, bump: &Bump, recv: &'a mut R, mut val: MangleValue) -> ToValue\n where\n R: MangleReceiver<'b>,\n {\n if let Some(to) = self.actually_mapped.get(&val) {\n return *to;\n }\n if let Some(to) = self.values_map.get(&val) {\n val = to.0;\n }\n\n let kind = val.map_fun(recv, |f, v| f.value_kind(v));\n let locs = val.map_fun(recv, |f, v| f.value_locations(v));\n let dest: ToValue = match kind.inner() {\n ValueKind::Const(_) => recv.map_const(val),\n ValueKind::PrimOp(prim) => {\n let prim = val.new_with(prim);\n let kind = prim\n .map_fun(recv, |f, _v| *f.primop_kind(prim.inner()))\n .inner();\n\n let span = locs\n .inner()\n .map(|spans| spans.first().copied().unwrap_or(SourceSpan::UNKNOWN))\n .unwrap_or(SourceSpan::UNKNOWN);\n\n let mut buf = Vec::new_in(bump);\n {\n let fun = prim.fun(recv);\n buf.extend(fun.primop_reads(prim.inner()).iter().cloned())\n }\n\n for value in buf.iter_mut() {\n let value_m = prim.new_with(*value);\n *value = self.map(bump, recv, value_m).inner();\n }\n\n recv.to().prim_from_kind(span, kind, &buf).into()\n }\n ValueKind::Block(block) => {\n let block = val.new_with(block);\n let block_val = block.map_fun(recv, |f, b| f.block_value(b));\n let new = if let Some((new_block_val, _)) = self.values_map.get(&block_val).cloned()\n {\n new_block_val\n } else {\n block.map_fun(recv, |f, b| f.block_value(b))\n };\n\n new.to()\n .expect(\"mangle reached block in target with nofollow and no replacement\")\n }\n ValueKind::Argument(_block, _num) => recv.map_free_value(val).into(),\n };\n self.values_map.insert(val, (dest.into(), true));\n self.actually_mapped.insert(val, dest);\n dest\n }\n}\n" }, { "path": "libeir_ir/src/algo/mangle/receiver.rs", "content": "use crate::OpKind;\nuse crate::{Function, FunctionBuilder};\n\nuse super::{MangleBlock, MangleValue, ToValue};\n\n/// Trait used to generalize a single mangling implementation over\n/// both mangling within a single function container, and across\n/// two different containers.\n/// Not exposed to user, only used internally.\npub(super) trait MangleReceiver<'b> {\n // NOTE: Would like to do some things differently here, mainly\n // generalizing the either/from/to variants, but not having\n // GATs makes this way to painful.\n\n /// The function container that is the source of the mangle.\n fn from<'a>(&'a self) -> &'a Function;\n\n /// The function builder that is the destination of the mangle.\n fn to<'a>(&'a mut self) -> &'a mut FunctionBuilder<'b>;\n fn to_fun<'a>(&'a self) -> &'a Function;\n\n /// Maps a constant.\n /// This should return a value that is usable in the destination\n /// function.\n fn map_const(&mut self, val: MangleValue) -> ToValue;\n\n /// Maps a free value.\n /// A free value in this context is a value from outside\n /// the scope of the mangle.\n fn map_free_value(&mut self, val: MangleValue) -> ToValue;\n\n /// Maps a block operation. This should return an OpKind that is\n /// usable in the destination function.\n fn map_block_op(&mut self, block: MangleBlock) -> OpKind;\n}\n\n/// This receiver performs a mangle within a single function container.\npub(super) struct SingleMangleReceiver<'a, 'b> {\n pub fun: &'a mut FunctionBuilder<'b>,\n}\nimpl<'b, 'c> MangleReceiver<'b> for SingleMangleReceiver<'c, 'b> {\n fn from<'a>(&'a self) -> &'a Function {\n // Since only the `To` branch should ever be used here,\n // this should never be called.\n unreachable!()\n }\n fn to<'a>(&'a mut self) -> &'a mut FunctionBuilder<'b> {\n self.fun\n }\n fn to_fun<'a>(&'a self) -> &'a Function {\n self.fun.fun()\n }\n fn map_const(&mut self, val: MangleValue) -> ToValue {\n val.to().unwrap()\n }\n fn map_free_value(&mut self, val: MangleValue) -> ToValue {\n val.to().unwrap()\n }\n fn map_block_op(&mut self, block: MangleBlock) -> OpKind {\n let block = block.to().unwrap().inner();\n self.fun.fun().block_kind(block).unwrap().clone()\n }\n}\n\n/// This receiver performs a mangle across to another function container.\n/// In the basic case, this is simply a copy across function containers.\npub(super) struct CopyMangleReceiver<'a, 'b> {\n pub from: &'a Function,\n pub to: &'a mut FunctionBuilder<'b>,\n}\nimpl<'b, 'c> MangleReceiver<'b> for CopyMangleReceiver<'c, 'b> {\n fn from<'a>(&'a self) -> &'a Function {\n self.from\n }\n fn to<'a>(&'a mut self) -> &'a mut FunctionBuilder<'b> {\n self.to\n }\n fn to_fun<'a>(&'a self) -> &'a Function {\n self.to.fun()\n }\n fn map_const(&mut self, _val: MangleValue) -> ToValue {\n unimplemented!()\n }\n fn map_free_value(&mut self, _val: MangleValue) -> ToValue {\n panic!()\n }\n fn map_block_op(&mut self, _block: MangleBlock) -> OpKind {\n unimplemented!()\n }\n}\n" }, { "path": "libeir_ir/src/algo/mangle/tests.rs", "content": "use crate::{NilTerm, StandardFormatConfig};\n\nuse super::Mangler;\nuse super::ToT;\n\n#[test]\nfn simple_mangle() {\n let (mut ir, map) = crate::parse_function_map_unwrap(\n \"\na'foo':a'bar'/1 {\n entry(%ret, %thr, %a):\n b1();\n b1():\n %ret(%a);\n}\n\",\n );\n\n let mut b = ir.builder();\n\n let mut mangler = Mangler::new();\n\n let b1 = map.get_block(\"entry\");\n let b1_ret = map.get_value(\"ret\");\n let b1_arg = map.get_value(\"a\");\n\n let new_entry = b.block_insert();\n let ret_narg = b.block_arg_insert(new_entry);\n let nil_term = b.value(NilTerm);\n b.block_copy_body_map(b1, new_entry, |v| Some(v));\n\n mangler.start(ToT(new_entry));\n mangler.add_rename(ToT(b1_ret), ToT(ret_narg));\n mangler.add_rename(ToT(b1_arg), ToT(nil_term));\n let new_b1 = mangler.run(&mut b);\n b.block_set_entry(new_b1);\n\n let after = crate::parse_function_unwrap(\n \"\na'foo':a'bar'/1 {\n entry(%ret):\n b1();\n b1():\n %ret([]);\n}\n\",\n );\n\n assert!(b\n .fun()\n .graph_eq(new_b1, &after, after.block_entry())\n .is_ok());\n}\n\n#[test]\nfn preserves_block_locations() {\n let eir_str = \"\na'foo':a'bar'/1 {\n !location [\\\"foo\\\":\\\"foo\\\"@\\\"foo.erl\\\":1];\n entry(%ret):\n b1();\n !location [\\\"foo\\\":\\\"foo\\\"@\\\"foo.erl\\\":2];\n b1():\n %ret([]);\n}\n\";\n\n let (mut ir, map) = crate::parse_function_map_unwrap(eir_str);\n\n let mut b = ir.builder();\n\n let mut mangler = Mangler::new();\n\n let b1 = map.get_block(\"entry\");\n let b1_ret = map.get_value(\"ret\");\n\n mangler.start(ToT(b1));\n let new_b1 = mangler.run(&mut b);\n b.block_set_entry(new_b1);\n\n let after = crate::parse_function_unwrap(eir_str);\n\n let opts = crate::GraphEqOptions {\n check_block_locations: true,\n };\n\n let res = b\n .fun()\n .graph_eq_opts(b.fun().block_entry(), &after, after.block_entry(), &opts);\n\n println!(\"{:?}\", res);\n assert!(res.is_ok());\n}\n\n#[test]\nfn mangle_primop() {\n let (mut ir, map) = crate::parse_function_map_unwrap(\n \"\na'foo':a'bar'/1 {\n entry(%ret, %thr, %a):\n %ret({%a});\n}\n\",\n );\n\n let mut b = ir.builder();\n\n let mut mangler = Mangler::new();\n\n let b1 = map.get_block(\"entry\");\n let b1_arg = map.get_value(\"a\");\n\n let nil_term = b.value(NilTerm);\n mangler.start(ToT(b1));\n mangler.add_rename(ToT(b1_arg), ToT(nil_term));\n let new_b1 = mangler.run(&mut b);\n\n let after = crate::parse_function_unwrap(\n \"\na'foo':a'bar'/1 {\n entry(%ret, %thr, %a):\n %ret({[]});\n}\n\",\n );\n\n assert!(b\n .fun()\n .graph_eq(new_b1, &after, after.block_entry())\n .is_ok());\n}\n\n#[test]\nfn mangle_recursive() {\n let (mut ir, map) = crate::parse_function_map_unwrap(\n \"\na'foo':a'bar'/2 {\n entry(%ret, %thr, %a, %b):\n b2(%a);\n b1(%m):\n %ret(%t);\n b2(%p):\n %ret(%p);\n\n # This just exists to have a dummy variable available\n dummy(%t):\n %t();\n}\n\",\n );\n\n let mut b = ir.builder();\n println!(\"{}\", b.fun().to_text(&mut StandardFormatConfig::default()));\n\n let mut mangler = Mangler::new();\n\n let entry = map.get_block(\"entry\");\n let b1 = map.get_block(\"b1\");\n let b1_val = b.fun().block_value(b1);\n let b2 = map.get_block(\"b2\");\n let b2_val = b.fun().block_value(b2);\n let vb = map.get_value(\"b\");\n let vt = map.get_value(\"t\");\n\n mangler.start(ToT(entry));\n mangler.add_rename(ToT(b2_val), ToT(b1_val));\n mangler.add_rename(ToT(vt), ToT(vb));\n let new_entry = mangler.run(&mut b);\n\n b.block_set_entry(new_entry);\n println!(\"{}\", b.fun().to_text(&mut StandardFormatConfig::default()));\n\n let after = crate::parse_function_unwrap(\n \"\na'foo':a'bar'/2 {\n entry(%ret, %thr, %a, %b):\n b1(%a);\n b1(%m):\n %ret(%b);\n}\n\",\n );\n\n assert!(b\n .fun()\n .graph_eq(new_entry, &after, after.block_entry())\n .is_ok());\n}\n\n#[test]\nfn mangle_entry() {\n let (mut ir, map) = crate::parse_function_map_unwrap(\n \"\na'foo':a'bar'/0 {\n block0(%1, %2):\n unreachable;\n block1(%4, %5):\n block2(%5);\n block2(%7):\n %4();\n}\n\",\n );\n let entry = map.get_block(\"block0\");\n\n let mut b = ir.builder();\n\n let mut mangler = Mangler::new();\n mangler.start(ToT(entry));\n\n mangler.add_rename(\n ToT(b.fun().block_value(map.get_block(\"block0\"))),\n ToT(b.fun().block_value(map.get_block(\"block1\"))),\n );\n\n let new_entry = mangler.run(&mut b);\n\n b.block_set_entry(new_entry);\n println!(\"{}\", b.fun().to_text(&mut StandardFormatConfig::default()));\n\n let mut errors = Vec::new();\n b.fun().validate(&mut errors);\n assert_eq!(errors.len(), 0, \"{:#?}\", errors);\n\n let after = crate::parse_function_unwrap(\n \"\na'foo':a'bar'/0 {\n block3(%9, %10):\n block4(%10);\n block4(%12):\n %9();\n}\n\",\n );\n assert!(b\n .fun()\n .graph_eq(new_entry, &after, after.block_entry())\n .is_ok());\n\n //{\n // value0#block0: (\n // value17#block5,\n // true,\n // ),\n //# value1#block0[0]: (\n //# value26#block7[0],\n //# true,\n //# ),\n //# value2#block0[1]: (\n //# value27#block7[1],\n //# true,\n //# ),\n //# value3#block0[2]: (\n //# value28#block7[2],\n //# true,\n //# ),\n // value5#block1[0]: (\n // value15#block4[0],\n // true,\n // ),\n // value6#block1[1]: (\n // value16#block4[1],\n // true,\n // ),\n // value8#block3: (\n // value21#block6,\n // true,\n // ),\n //}\n}\n" }, { "path": "libeir_ir/src/algo/mod.rs", "content": "pub mod equality;\npub mod func_tree;\npub mod live;\npub mod mangle;\npub mod op_branches;\npub mod validate;\n" }, { "path": "libeir_ir/src/algo/op_branches.rs", "content": "use crate::Function;\nuse crate::{Block, CallKind, OpKind, Value};\n\npub struct BranchIter<'a> {\n fun: &'a Function,\n block: Block,\n num: usize,\n len: usize,\n}\nimpl<'a> Iterator for BranchIter<'a> {\n type Item = Value;\n fn next(&mut self) -> Option {\n if self.num == self.len {\n None\n } else {\n let res = self.fun.op_branch_target(self.block, self.num);\n self.num += 1;\n Some(res)\n }\n }\n}\n\n/// These functions provide knowledge about what branches an operation can\n/// perform at specific locations in the IR.\n///\n/// This is different from the information you get from the block graph in\n/// several ways:\n/// * If one operation has several branches to the same destination block,\n/// the block graph tells us nothing about that.\n/// * The block graph can contain an outgoing edge to a block that is not\n/// truly a direct call, but instead a function capture, this looks only\n/// at direct branches.\n/// * Likewise, the block graph will not have edges for calls to values,\n/// this does.\n/// * The block graph gives no information about the expected arity of the\n/// destination, and has no information about what those arguments are.\nimpl Function {\n pub fn op_branch_iter<'a>(&'a self, block: Block) -> BranchIter<'a> {\n BranchIter {\n fun: self,\n block,\n num: 0,\n len: self.op_branch_len(block).unwrap(),\n }\n }\n\n pub fn op_branch_len(&self, block: Block) -> Option {\n let res = match self.block_kind(block)? {\n OpKind::Call(CallKind::ControlFlow) => 1,\n OpKind::Call(CallKind::Function) => 2,\n\n OpKind::Unreachable => 0,\n\n OpKind::IfBool => {\n let reads = self.block_reads(block);\n match reads.len() {\n 3 => 2,\n 4 => 3,\n _ => unreachable!(),\n }\n }\n\n OpKind::TraceCaptureRaw => 1,\n OpKind::TraceConstruct => 1,\n OpKind::UnpackValueList(_) => 1,\n OpKind::MapPut { .. } => 2,\n\n OpKind::Match { branches } => branches.len(),\n\n OpKind::Dyn(dyn_op) => {\n let op_branches = self.dialect().get_op_branches(&**dyn_op).unwrap();\n op_branches.branches_len()\n }\n };\n\n Some(res)\n }\n\n pub fn op_branch_target(&self, block: Block, n: usize) -> Value {\n let reads = self.block_reads(block);\n match (self.block_kind(block).unwrap(), reads.len(), n) {\n // For a control flow call, the only control flow branch\n // is the target.\n (OpKind::Call(CallKind::ControlFlow), _, 0) => reads[0],\n\n // For a function call, the only control flow branches are\n // the return and escape continuations.\n (OpKind::Call(CallKind::Function), _, 0) => reads[1],\n (OpKind::Call(CallKind::Function), _, 1) => reads[2],\n\n (OpKind::IfBool, 3, n) if n < 2 => reads[n],\n (OpKind::IfBool, 4, n) if n < 3 => reads[n],\n\n (OpKind::TraceCaptureRaw, _, 0) => reads[0],\n (OpKind::TraceConstruct, _, 0) => reads[0],\n (OpKind::UnpackValueList(_), _, 0) => reads[0],\n (OpKind::MapPut { .. }, _, n) if n < 2 => reads[n],\n\n (OpKind::Match { .. }, _, n) => self.value_list_get_n(reads[0], n).unwrap(),\n\n (OpKind::Dyn(dyn_op), _, _) => {\n let op_branches = self.dialect().get_op_branches(&**dyn_op).unwrap();\n op_branches.branch_num(self, block, n)\n }\n _ => panic!(),\n }\n }\n}\n" }, { "path": "libeir_ir/src/algo/validate.rs", "content": "use std::collections::HashSet;\n\nuse fnv::FnvBuildHasher;\nuse hashbrown::HashMap;\ntype FnvHashMap = HashMap;\n\nuse petgraph::algo::dominators::Dominators;\n\nuse cranelift_bforest::{Set, SetForest};\n\nuse crate::{Block, Value};\nuse crate::{CallKind, Function, MatchKind, OpKind};\n\n#[derive(Debug)]\npub enum ValidationError {\n /// There was an empty block in the function, this is illegal\n EmptyBlock {\n block: Block,\n },\n\n /// Tried to call a block with wrong arity\n BlockCallArity {\n caller: Block,\n callee: Block,\n attempted: usize,\n actual: usize,\n },\n\n ValueCallArity {\n caller: Block,\n callee: Value,\n attempted: usize,\n actual: usize,\n },\n\n /// The arity of the block marked as entry did not match with the identifier\n EntryArityMismatch,\n\n /// Tried to read a SSA variable that was not visible.\n InvalidRead {\n value: Value,\n block: Block,\n },\n\n UnfinishedBlock {\n block: Block,\n },\n}\n\nfn get_value_list<'a>(fun: &'a Function, value: Value) -> Option<&'a [Value]> {\n if let Some(prim) = fun.value_primop(value) {\n match fun.primop_kind(prim) {\n crate::PrimOpKind::ValueList => return Some(fun.primop_reads(prim)),\n _ => (),\n }\n }\n None\n}\n\nimpl Function {\n pub fn validate(&self, errors: &mut Vec) {\n let block_graph = self.block_graph();\n let doms = petgraph::algo::dominators::simple_fast(&block_graph, self.block_entry());\n\n // Validate internal graph invariants\n self.graph_validate_global();\n\n self.validate_entry_invariants(errors);\n self.validate_blocks(errors);\n self.validate_ssa_visibility(&doms, errors);\n }\n\n fn validate_call_to(\n &self,\n errors: &mut Vec,\n caller: Block,\n val: Value,\n arity: usize,\n ) {\n if let Some(block) = self.value_block(val) {\n let actual = self.block_args(block).len();\n if actual != arity {\n errors.push(ValidationError::BlockCallArity {\n caller,\n callee: block,\n attempted: arity,\n actual,\n });\n }\n }\n }\n\n fn validate_blocks(&self, errors: &mut Vec) {\n let block_graph = self.block_graph();\n\n let entry = self.block_entry();\n let ret_val = self.block_args(entry)[0];\n let thr_val = self.block_args(entry)[1];\n\n let mut dfs = block_graph.dfs();\n while let Some(block) = dfs.next(&block_graph) {\n if let Some(kind) = self.block_kind(block) {\n let reads = self.block_reads(block);\n\n match kind {\n OpKind::Call(CallKind::ControlFlow) => {\n self.validate_call_to(errors, block, reads[0], reads.len() - 1);\n }\n OpKind::Call(CallKind::Function) => {\n self.validate_call_to(errors, block, reads[0], reads.len() - 1);\n self.validate_call_to(errors, block, reads[1], 1);\n self.validate_call_to(errors, block, reads[2], 3);\n if reads[0] == ret_val {\n if reads.len() != 2 {\n errors.push(ValidationError::ValueCallArity {\n caller: block,\n callee: ret_val,\n attempted: reads.len() - 1,\n actual: 1,\n });\n }\n }\n if reads[0] == thr_val {\n if reads.len() != 4 {\n errors.push(ValidationError::ValueCallArity {\n caller: block,\n callee: thr_val,\n attempted: reads.len() - 1,\n actual: 3,\n });\n }\n }\n }\n OpKind::IfBool => {\n self.validate_call_to(errors, block, reads[0], 0);\n self.validate_call_to(errors, block, reads[1], 0);\n if reads.len() == 4 {\n self.validate_call_to(errors, block, reads[2], 0);\n } else {\n assert!(reads.len() == 3);\n }\n }\n OpKind::UnpackValueList(n) => {\n self.validate_call_to(errors, block, reads[0], *n);\n }\n OpKind::Match { branches } => {\n let targets_opt = get_value_list(self, reads[0]);\n let other_targets = &[reads[0]];\n let targets = targets_opt.unwrap_or(other_targets);\n\n assert!(targets.len() == branches.len());\n for (branch, target) in branches.iter().zip(targets.iter()) {\n match branch {\n MatchKind::ListCell => {\n self.validate_call_to(errors, block, *target, 2);\n }\n MatchKind::MapItem => {\n self.validate_call_to(errors, block, *target, 1);\n }\n MatchKind::Tuple(n) => {\n self.validate_call_to(errors, block, *target, *n);\n }\n MatchKind::Type(_) => {\n self.validate_call_to(errors, block, *target, 0);\n }\n MatchKind::Value => {\n self.validate_call_to(errors, block, *target, 0);\n }\n MatchKind::Wildcard => {\n self.validate_call_to(errors, block, *target, 0);\n }\n _ => (),\n }\n }\n }\n _ => (), // TODO validate more types\n }\n } else {\n errors.push(ValidationError::EmptyBlock { block });\n }\n }\n }\n\n fn validate_entry_invariants(&self, errors: &mut Vec) {\n let entry = self.block_entry();\n let arity = self.block_args(entry).len();\n\n // In the calling convention, the first two arguments are (ok_cont, err_cont)\n if arity != self.ident().arity + 2 {\n errors.push(ValidationError::EntryArityMismatch);\n }\n }\n}\n\nimpl Function {\n /// Strictly validate SSA visibility\n ///\n /// It operates on the following principle:\n /// * The set of SSA variables visible at the beginning of a block is\n /// (the SSA variables visible at its immediate dominator)\n /// + (the set of SSA variables declared in the arguments).\n ///\n /// More specifically:\n /// * Seed the live variable map with the entry node.\n /// * While there are basic blocks missing from our live variable map:\n /// * Loop through the set of missing blocks:\n /// * Calculate the live variables in the block if its\n /// immediate dominator has already been calculated, otherwise\n /// skip.\n /// * Go through each basic block in the cfg and validate that it only\n /// references live variables.\n fn validate_ssa_visibility(&self, doms: &Dominators, errors: &mut Vec) {\n let entry_block = self.block_entry();\n\n let mut pool = SetForest::new();\n\n // Live variables on block entry and exit\n let mut live_variables: FnvHashMap> =\n FnvHashMap::with_hasher(Default::default());\n\n // Seed entry node\n let entry_vals = Set::new();\n self.insert_live_for_node(entry_block, entry_vals, &mut pool, &mut live_variables);\n\n // Iterate until all calculated\n let mut missing_nodes: HashSet<_> = self.block_graph().dfs_iter().collect();\n missing_nodes.remove(&entry_block);\n let mut processed = Vec::new();\n\n while !missing_nodes.is_empty() {\n for node in missing_nodes.iter() {\n if let Some(idom) = doms.immediate_dominator(*node) {\n // If the immediate dominator is already processed, process this block.\n if let Some(idom_live) = live_variables.get(&idom) {\n let live = idom_live.make_copy(&mut pool);\n self.insert_live_for_node(*node, live, &mut pool, &mut live_variables);\n processed.push(*node);\n }\n } else {\n // Since we only go through nodes that are alive, that is, reachable\n // from the entry point, all nodes (except the entry itself), should\n // have an idom\n unreachable!()\n }\n }\n\n // Remove processed\n if !missing_nodes.is_empty() {\n assert!(!processed.is_empty());\n }\n for proc in processed.iter() {\n missing_nodes.remove(proc);\n }\n processed.clear();\n }\n\n // Go through all blocks and validate visibility\n for block in self.block_graph().dfs_iter() {\n let visible = &live_variables[&block];\n for read in self.block_reads(block) {\n self.value_walk_nested_values::<_, ()>(*read, &mut |val| {\n if self.value_argument(val).is_some() && !visible.contains(val, &pool, &()) {\n errors.push(ValidationError::InvalidRead { value: val, block });\n }\n Ok(())\n })\n .unwrap();\n }\n }\n }\n\n fn insert_live_for_node(\n &self,\n block: Block,\n mut base_set: Set,\n pool: &mut SetForest,\n live: &mut FnvHashMap>,\n ) {\n for arg in self.block_args(block) {\n base_set.insert(*arg, pool, &());\n }\n live.insert(block, base_set);\n }\n}\n" }, { "path": "libeir_ir/src/binary.rs", "content": "use serde::{Deserialize, Serialize};\nuse std::default::Default;\n\n#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]\npub enum Endianness {\n Big,\n Little,\n Native,\n}\n\n#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]\npub enum BinaryEntrySpecifier {\n Integer {\n signed: bool,\n endianness: Endianness,\n unit: i64,\n },\n Float {\n endianness: Endianness,\n unit: i64,\n },\n Bytes {\n unit: i64,\n },\n Bits {\n unit: i64,\n },\n Utf8,\n Utf16 {\n endianness: Endianness,\n },\n Utf32 {\n endianness: Endianness,\n },\n}\n\nimpl BinaryEntrySpecifier {\n pub fn has_size(&self) -> bool {\n match self {\n BinaryEntrySpecifier::Utf8 => false,\n BinaryEntrySpecifier::Utf16 { .. } => false,\n BinaryEntrySpecifier::Utf32 { .. } => false,\n _ => true,\n }\n }\n pub fn is_native_endian(&self) -> bool {\n match self {\n BinaryEntrySpecifier::Integer {\n endianness: Endianness::Native,\n ..\n } => true,\n BinaryEntrySpecifier::Float {\n endianness: Endianness::Native,\n ..\n } => true,\n BinaryEntrySpecifier::Utf16 {\n endianness: Endianness::Native,\n ..\n } => true,\n BinaryEntrySpecifier::Utf32 {\n endianness: Endianness::Native,\n ..\n } => true,\n _ => false,\n }\n }\n}\n\nimpl Default for BinaryEntrySpecifier {\n fn default() -> Self {\n BinaryEntrySpecifier::Integer {\n signed: false,\n endianness: Endianness::Big,\n unit: 1,\n }\n }\n}\n" }, { "path": "libeir_ir/src/constant/atomic.rs", "content": "use std::fmt::{Display, Formatter, Result as FmtResult};\nuse std::hash::{Hash, Hasher};\n\nuse libeir_util_number::{cast, BigInt, Float, NumCast, Number};\nuse libeir_util_binary::BitVec;\n\nuse libeir_intern::Symbol;\n\nuse super::float::raw_double_bits;\nuse super::Integer;\n\nimpl From for AtomicTerm {\n fn from(int: Integer) -> AtomicTerm {\n match int {\n Integer::Big(n) => AtomicTerm::BigInt(BigIntTerm(n)),\n Integer::Small(n) => AtomicTerm::Int(IntTerm(n)),\n }\n }\n}\n\n#[derive(Debug, Clone, PartialEq, Eq, Hash)]\npub struct BigIntTerm(pub BigInt);\nimpl BigIntTerm {\n #[inline]\n pub fn value(&self) -> &BigInt {\n &self.0\n }\n}\nimpl Into for BigIntTerm {\n #[inline]\n fn into(self) -> BigInt {\n self.0\n }\n}\nimpl From for AtomicTerm {\n fn from(data: BigIntTerm) -> Self {\n AtomicTerm::BigInt(data)\n }\n}\nimpl From for AtomicTerm {\n fn from(data: BigInt) -> Self {\n AtomicTerm::BigInt(BigIntTerm(data))\n }\n}\nimpl Display for BigIntTerm {\n fn fmt(&self, fmt: &mut Formatter) -> FmtResult {\n write!(fmt, \"{}\", self.0)\n }\n}\n\n#[derive(Debug, Clone, PartialEq, Eq, Hash)]\npub struct IntTerm(pub i64);\nimpl IntTerm {\n #[inline]\n pub fn value(&self) -> i64 {\n self.0\n }\n}\nimpl Into for IntTerm {\n #[inline]\n fn into(self) -> i64 {\n self.0\n }\n}\nimpl From for AtomicTerm {\n fn from(data: IntTerm) -> Self {\n AtomicTerm::Int(data)\n }\n}\nimpl Display for IntTerm {\n fn fmt(&self, fmt: &mut Formatter) -> FmtResult {\n write!(fmt, \"{}\", self.0)\n }\n}\n\nfn from_num(n: N) -> AtomicTerm\nwhere\n N: NumCast,\n{\n if let Some(int) = cast(n) {\n AtomicTerm::Int(IntTerm(int))\n } else {\n // TODO bigint\n unimplemented!()\n }\n}\nmacro_rules! impl_from_num {\n ($typ:ty) => {\n impl From<$typ> for AtomicTerm {\n fn from(data: $typ) -> Self {\n from_num(data)\n }\n }\n };\n}\nimpl_from_num!(usize);\nimpl_from_num!(i32);\nimpl_from_num!(i64);\nimpl_from_num!(u32);\nimpl_from_num!(u64);\n\nimpl From for AtomicTerm {\n fn from(data: char) -> Self {\n from_num(data as i64)\n }\n}\n\n#[derive(Debug, Clone, PartialEq)]\npub struct FloatTerm(pub Float);\nimpl FloatTerm {\n #[inline]\n pub fn value(&self) -> f64 {\n self.0.inner()\n }\n}\nimpl Eq for FloatTerm {}\n#[allow(clippy::derive_hash_xor_eq)]\nimpl Hash for FloatTerm {\n fn hash(&self, state: &mut H)\n where\n H: Hasher,\n {\n raw_double_bits(&self.value()).hash(state)\n }\n}\nimpl From for AtomicTerm {\n fn from(data: FloatTerm) -> Self {\n AtomicTerm::Float(data)\n }\n}\nimpl From for AtomicTerm {\n fn from(data: f64) -> Self {\n AtomicTerm::Float(FloatTerm(Float::new(data).unwrap()))\n }\n}\nimpl From for AtomicTerm {\n fn from(data: Float) -> Self {\n AtomicTerm::Float(FloatTerm(data))\n }\n}\nimpl From for AtomicTerm {\n fn from(data: Number) -> Self {\n match data {\n Number::Float(float) => float.into(),\n Number::Integer(int) => int.into(),\n }\n }\n}\nimpl Display for FloatTerm {\n fn fmt(&self, fmt: &mut Formatter) -> FmtResult {\n write!(fmt, \"f{}\", self.0)\n }\n}\n\n#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]\npub struct AtomTerm(pub Symbol);\nimpl From for AtomicTerm {\n fn from(data: AtomTerm) -> Self {\n AtomicTerm::Atom(data)\n }\n}\nimpl From for AtomicTerm {\n fn from(data: Symbol) -> Self {\n AtomTerm(data).into()\n }\n}\nimpl From for AtomicTerm {\n fn from(data: bool) -> Self {\n let sym = if data {\n Symbol::intern(\"true\")\n } else {\n Symbol::intern(\"false\")\n };\n\n AtomTerm(sym).into()\n }\n}\nimpl PartialEq for AtomTerm {\n fn eq(&self, other: &str) -> bool {\n self.0 == other\n }\n}\nimpl Display for AtomTerm {\n fn fmt(&self, fmt: &mut Formatter) -> FmtResult {\n write!(fmt, \"a'{}'\", self.0) // TODO escape\n }\n}\n\n#[derive(Debug, Clone, PartialEq, Eq, Hash)]\npub struct BinaryTerm(pub BitVec);\nimpl BinaryTerm {\n #[inline]\n pub fn value(&self) -> &BitVec {\n &self.0\n }\n}\nimpl From for AtomicTerm {\n fn from(data: BinaryTerm) -> Self {\n AtomicTerm::Binary(data)\n }\n}\nimpl From> for AtomicTerm {\n fn from(data: Vec) -> Self {\n AtomicTerm::Binary(BinaryTerm(data.into()))\n }\n}\nimpl From for AtomicTerm {\n fn from(data: BitVec) -> Self {\n AtomicTerm::Binary(BinaryTerm(data))\n }\n}\n\n#[derive(Debug, Clone, PartialEq, Eq, Hash)]\npub struct NilTerm;\nimpl From for AtomicTerm {\n fn from(_data: NilTerm) -> Self {\n AtomicTerm::Nil\n }\n}\n\n#[derive(Debug, Clone, PartialEq, Eq, Hash)]\npub enum AtomicTerm {\n Int(IntTerm),\n BigInt(BigIntTerm),\n Float(FloatTerm),\n Atom(AtomTerm),\n Binary(BinaryTerm),\n Nil,\n}\n\nimpl Display for AtomicTerm {\n fn fmt(&self, fmt: &mut Formatter) -> FmtResult {\n match self {\n AtomicTerm::Int(int) => write!(fmt, \"{}\", int),\n AtomicTerm::BigInt(int) => write!(fmt, \"{}\", int),\n AtomicTerm::Float(float) => write!(fmt, \"{}\", float),\n AtomicTerm::Atom(atom) => write!(fmt, \"{}\", atom),\n AtomicTerm::Nil => write!(fmt, \"[]\"),\n AtomicTerm::Binary(_bin) => write!(fmt, \"bin\"),\n }\n }\n}\n" }, { "path": "libeir_ir/src/constant/float.rs", "content": "use libeir_util_number::traits::Float;\n\n// Copied from https://github.com/reem/rust-ordered-float\n\n// masks for the parts of the IEEE 754 float\nconst SIGN_MASK: u64 = 0x8000_0000_0000_0000u64;\nconst EXP_MASK: u64 = 0x7ff0_0000_0000_0000u64;\nconst MAN_MASK: u64 = 0x000f_ffff_ffff_ffffu64;\n\n// canonical raw bit patterns (for hashing)\nconst CANONICAL_NAN_BITS: u64 = 0x7ff8_0000_0000_0000u64;\nconst CANONICAL_ZERO_BITS: u64 = 0x0u64;\n\n#[inline]\npub fn raw_double_bits(f: &F) -> u64 {\n if f.is_nan() {\n return CANONICAL_NAN_BITS;\n }\n\n let (man, exp, sign) = f.integer_decode();\n if man == 0 {\n return CANONICAL_ZERO_BITS;\n }\n\n //let exp_u64 = unsafe { mem::transmute::(exp) } as u64;\n let exp_u64 = exp as u64;\n let sign_u64 = if sign > 0 { 1u64 } else { 0u64 };\n (man & MAN_MASK) | ((exp_u64 << 52) & EXP_MASK) | ((sign_u64 << 63) & SIGN_MASK)\n}\n" }, { "path": "libeir_ir/src/constant/mod.rs", "content": "use std::hash::{Hash, Hasher};\n\nuse libeir_intern::Ident;\n\nuse libeir_util_datastructures::aux_hash_map::AuxHashMap;\nuse libeir_util_datastructures::aux_traits::{AuxEq, AuxHash};\n\nuse cranelift_entity::{entity_impl, EntityList, ListPool, PrimaryMap};\n\nmod atomic;\npub use atomic::*;\nmod float;\npub use libeir_util_number::{FromPrimitive, Integer, ToPrimitive};\n\n/// These entities has the property that if they are equal, they\n/// represent the same value.\n#[derive(Copy, Clone, Hash, PartialEq, Eq, PartialOrd, Ord)]\npub struct Const(u32);\nentity_impl!(Const, \"const_value\");\n\n#[derive(Debug, Clone)]\npub enum ConstKind {\n Atomic(AtomicTerm),\n ListCell {\n head: Const,\n tail: Const,\n },\n Tuple {\n entries: EntityList,\n },\n Map {\n /// Key/value pairs are ALWAYS ordered by key constant index\n keys: EntityList,\n values: EntityList,\n },\n}\nimpl AuxHash> for ConstKind {\n fn aux_hash(&self, state: &mut H, container: &ListPool) {\n match self {\n ConstKind::Atomic(atomic) => {\n 0.hash(state);\n atomic.hash(state);\n }\n ConstKind::ListCell { head, tail } => {\n 1.hash(state);\n head.hash(state);\n tail.hash(state);\n }\n ConstKind::Tuple { entries } => {\n 2.hash(state);\n entries.as_slice(container).hash(state);\n }\n ConstKind::Map { keys, values } => {\n 3.hash(state);\n keys.as_slice(container).hash(state);\n values.as_slice(container).hash(state);\n }\n }\n }\n}\nimpl AuxEq> for ConstKind {\n fn aux_eq(\n &self,\n rhs: &ConstKind,\n self_aux: &ListPool,\n other_aux: &ListPool,\n ) -> bool {\n match (self, rhs) {\n (ConstKind::Atomic(l), ConstKind::Atomic(r)) => l == r,\n (\n ConstKind::ListCell { head: lh, tail: lt },\n ConstKind::ListCell { head: rh, tail: rt },\n ) => lh == rh && lt == rt,\n (ConstKind::Tuple { entries: l }, ConstKind::Tuple { entries: r }) => {\n l.as_slice(self_aux) == r.as_slice(other_aux)\n }\n (\n ConstKind::Map {\n keys: lk,\n values: lv,\n },\n ConstKind::Map {\n keys: rk,\n values: rv,\n },\n ) => {\n lk.as_slice(self_aux) == rk.as_slice(other_aux)\n && lv.as_slice(self_aux) == rv.as_slice(other_aux)\n }\n _ => false,\n }\n }\n}\n\nimpl ConstKind {\n pub fn is_map(&self) -> bool {\n match self {\n ConstKind::Map { .. } => true,\n _ => false,\n }\n }\n}\n\n#[derive(Debug, Clone)]\npub struct ConstantContainer {\n const_values: PrimaryMap,\n value_map: AuxHashMap>,\n pub const_pool: ListPool,\n}\n\nimpl Default for ConstantContainer {\n fn default() -> Self {\n ConstantContainer {\n const_values: PrimaryMap::new(),\n value_map: AuxHashMap::new(),\n const_pool: ListPool::new(),\n }\n }\n}\n\nimpl ConstantContainer {\n pub fn new() -> Self {\n Self::default()\n }\n\n pub fn const_kind(&self, value: Const) -> &ConstKind {\n &self.const_values[value]\n }\n\n pub fn list_cell(&mut self, head: Const, tail: Const) -> Const {\n self.from(ConstKind::ListCell { head, tail })\n }\n\n pub fn nil(&mut self) -> Const {\n self.from(NilTerm)\n }\n\n pub fn from(&mut self, val: T) -> Const\n where\n T: IntoConst,\n {\n val.into_const(self)\n }\n\n pub fn get(&self, val: T) -> Option\n where\n T: IntoConst,\n {\n val.get_const(self)\n }\n\n //pub fn print(&self, val: Const, fmt: &mut T)\n //where T: crate::text::TextFormatter\n //{\n // match &self.const_values[val] {\n // ConstKind::Atomic(atomic) => {\n // fmt.write(&format!(\"{}\", atomic));\n // }\n // _ => unimplemented!()\n // }\n //}\n\n pub fn as_bool(&self, val: Const) -> Option {\n let kind = &self.const_values[val];\n match kind {\n ConstKind::Atomic(AtomicTerm::Atom(atom)) if atom == \"true\" => Some(true),\n ConstKind::Atomic(AtomicTerm::Atom(atom)) if atom == \"false\" => Some(false),\n _ => None,\n }\n }\n\n pub fn write(&self, val: Const, out: &mut dyn std::io::Write) {\n match &self.const_values[val] {\n ConstKind::Atomic(atomic) => {\n write!(out, \"{}\", atomic).unwrap();\n }\n ConstKind::ListCell { head, tail } => {\n write!(out, \"[\").unwrap();\n self.write(*head, out);\n write!(out, \" | \").unwrap();\n self.write(*tail, out);\n write!(out, \"]\").unwrap();\n }\n ConstKind::Tuple { entries } => {\n write!(out, \"{{\").unwrap();\n for (n, entry) in entries.as_slice(&self.const_pool).iter().enumerate() {\n if n != 0 {\n write!(out, \", \").unwrap();\n }\n self.write(*entry, out);\n }\n write!(out, \"}}\").unwrap();\n }\n ConstKind::Map { keys, values } => {\n write!(out, \"%{{\").unwrap();\n for (n, (key, val)) in keys\n .as_slice(&self.const_pool)\n .iter()\n .zip(values.as_slice(&self.const_pool))\n .enumerate()\n {\n if n != 0 {\n write!(out, \", \").unwrap();\n }\n self.write(*key, out);\n write!(out, \": \").unwrap();\n self.write(*val, out);\n }\n write!(out, \"}}\").unwrap();\n }\n }\n }\n\n pub fn tuple_builder(&self) -> TupleBuilder {\n TupleBuilder::new()\n }\n\n pub fn eq_other(&self, l: Const, r_cont: &ConstantContainer, r: Const) -> bool {\n match (&self.const_values[l], &r_cont.const_values[r]) {\n (ConstKind::Atomic(la), ConstKind::Atomic(ra)) if la == ra => true,\n (ConstKind::Atomic(_), ConstKind::Atomic(_)) => false,\n (ConstKind::Tuple { entries: t1 }, ConstKind::Tuple { entries: t2 }) => {\n let s1 = t1.as_slice(&self.const_pool);\n let s2 = t2.as_slice(&r_cont.const_pool);\n if s1.len() != s2.len() {\n return false;\n }\n for (e1, e2) in s1.iter().zip(s2.iter()) {\n if !self.eq_other(*e1, r_cont, *e2) {\n return false;\n }\n }\n true\n }\n l => unimplemented!(\"{:?}\", l),\n }\n }\n}\n\npub trait IntoConst {\n fn into_const(self, c: &mut ConstantContainer) -> Const;\n fn get_const(self, fun: &ConstantContainer) -> Option;\n}\n\npub struct EmptyMap;\nimpl IntoConst for EmptyMap {\n fn into_const(self, c: &mut ConstantContainer) -> Const {\n c.from(ConstKind::Map {\n keys: EntityList::new(),\n values: EntityList::new(),\n })\n }\n fn get_const(self, c: &ConstantContainer) -> Option {\n c.get(ConstKind::Map {\n keys: EntityList::new(),\n values: EntityList::new(),\n })\n }\n}\n\nimpl IntoConst for T\nwhere\n T: Into,\n{\n fn into_const(self, c: &mut ConstantContainer) -> Const {\n c.from(ConstKind::Atomic(self.into()))\n }\n fn get_const(self, c: &ConstantContainer) -> Option {\n c.get(ConstKind::Atomic(self.into()))\n }\n}\n\nimpl IntoConst for ConstKind {\n fn into_const(self, c: &mut ConstantContainer) -> Const {\n if let Some(val) = c.value_map.get(&self, &c.const_pool) {\n *val\n } else {\n let val = c.const_values.push(self.clone());\n c.value_map.try_insert(self, val, &c.const_pool).unwrap();\n val\n }\n }\n fn get_const(self, c: &ConstantContainer) -> Option {\n c.value_map.get(&self, &c.const_pool).cloned()\n }\n}\n\nimpl IntoConst for Const {\n fn into_const(self, _c: &mut ConstantContainer) -> Const {\n self\n }\n fn get_const(self, _c: &ConstantContainer) -> Option {\n Some(self)\n }\n}\n\nimpl IntoConst for Ident {\n fn into_const(self, c: &mut ConstantContainer) -> Const {\n self.name.into_const(c)\n }\n fn get_const(self, c: &ConstantContainer) -> Option {\n self.name.get_const(c)\n }\n}\n\npub struct TupleBuilder {\n elements: EntityList,\n}\nimpl TupleBuilder {\n pub fn new() -> Self {\n TupleBuilder {\n elements: EntityList::new(),\n }\n }\n\n pub fn push(&mut self, elem: Const, c: &mut ConstantContainer) {\n self.elements.push(elem, &mut c.const_pool);\n }\n\n pub fn clear(mut self, c: &mut ConstantContainer) {\n self.elements.clear(&mut c.const_pool);\n }\n\n pub fn finish(self, c: &mut ConstantContainer) -> Const {\n c.from(ConstKind::Tuple {\n entries: self.elements,\n })\n }\n}\n\n//struct TupleTerm>(I);\n//impl> IntoConst for TupleTerm {\n// fn into_const(self, c: &mut ConstantContainer) -> Const {\n// for typ\n// }\n//}\n" }, { "path": "libeir_ir/src/dialect/mod.rs", "content": "use std::any::TypeId;\nuse std::collections::{HashMap, HashSet};\nuse std::fmt::{self, Debug, Formatter};\nuse std::sync::Arc;\n\nuse lazy_static::lazy_static;\nuse libeir_intern::Symbol;\nuse meta_table::{MetaEntry, MetaTable};\n\nuse crate::operation::{self as op, Op};\nuse crate::traits::{OpBranches, OpParser, OpPrinter};\n\nlazy_static! {\n pub static ref NORMAL: ArcDialect = {\n let mut d = Dialect::new();\n op::receive::register(&mut d);\n op::binary_construct::register(&mut d);\n op::case::register(&mut d);\n Arc::new(d)\n };\n}\n\npub type ArcDialect = Arc;\n\n// TODO: Expose better interface for registering trait implementations.\n\npub struct Dialect {\n /// This is the full set of operations that are registered for this dialect.\n operations: HashSet,\n\n op_branches: MetaTable,\n\n op_printer: MetaTable,\n op_parser: HashMap>,\n}\nimpl Debug for Dialect {\n fn fmt(&self, fmt: &mut Formatter) -> Result<(), fmt::Error> {\n write!(fmt, \"{:?}\", self.operations)\n }\n}\n\nimpl Dialect {\n pub fn new() -> Self {\n Self {\n operations: HashSet::new(),\n op_branches: MetaTable::new(),\n op_printer: MetaTable::new(),\n op_parser: HashMap::new(),\n }\n }\n\n pub fn contains_op(&self) -> bool {\n self.operations.contains(&TypeId::of::())\n }\n\n pub fn register_op(&mut self) {\n self.operations.insert(TypeId::of::());\n }\n\n pub fn register_op_branches_impl(&mut self) {\n assert!(self.operations.contains(&TypeId::of::()));\n self.op_branches.register::();\n }\n\n pub fn get_op_branches<'a>(&self, obj: &'a dyn Op) -> Option<&'a dyn OpBranches> {\n self.op_branches.get(obj.meta_entry())\n }\n\n pub fn register_op_printer_impl(&mut self) {\n assert!(self.operations.contains(&TypeId::of::()));\n self.op_printer.register::();\n }\n\n pub fn get_op_printer<'a>(&self, obj: &'a dyn Op) -> Option<&'a dyn OpPrinter> {\n self.op_printer.get(obj.meta_entry())\n }\n\n pub fn register_op_parser(&mut self, sym: Symbol, parser: Box) {\n self.op_parser.insert(sym, parser);\n }\n\n pub fn get_op_parser(&self, sym: Symbol) -> Option<&dyn OpParser> {\n self.op_parser.get(&sym).map(|v| &**v)\n }\n}\n" }, { "path": "libeir_ir/src/function/builder/mod.rs", "content": "use libeir_diagnostics::SourceSpan;\n\nuse super::Function;\nuse super::ValueKind;\nuse super::{Block, Const, Location, OpKind, PrimOp, Value};\nuse super::{PrimOpData, PrimOpKind};\n\nuse crate::constant::{ConstantContainer, IntoConst};\nuse crate::BinOp;\n\nuse cranelift_entity::EntityList;\n\nmod op;\nmod primop;\n\nimpl Function {\n pub fn builder(&mut self) -> FunctionBuilder<'_> {\n FunctionBuilder::new(self)\n }\n}\n\npub trait IntoValue {\n fn into_value<'a>(self, b: &mut FunctionBuilder<'a>) -> Value;\n fn get_value(self, fun: &Function) -> Option;\n}\nimpl IntoValue for Value {\n fn into_value<'a>(self, _b: &mut FunctionBuilder<'a>) -> Value {\n self\n }\n fn get_value(self, _fun: &Function) -> Option {\n Some(self)\n }\n}\nimpl IntoValue for Block {\n fn into_value<'a>(self, b: &mut FunctionBuilder<'a>) -> Value {\n b.fun.values.push(ValueKind::Block(self))\n }\n fn get_value(self, fun: &Function) -> Option {\n fun.values.get(ValueKind::Block(self))\n }\n}\nimpl IntoValue for PrimOp {\n fn into_value<'a>(self, b: &mut FunctionBuilder<'a>) -> Value {\n b.fun.values.push(ValueKind::PrimOp(self))\n }\n fn get_value(self, fun: &Function) -> Option {\n fun.values.get(ValueKind::PrimOp(self))\n }\n}\nimpl IntoValue for T\nwhere\n T: IntoConst,\n{\n fn into_value<'a>(self, b: &mut FunctionBuilder<'a>) -> Value {\n let constant = b.fun.constant_container.from(self);\n let value = b.fun.values.push(ValueKind::Const(constant));\n b.fun.constant_values.insert(value);\n value\n }\n fn get_value(self, fun: &Function) -> Option {\n let constant = fun.constant_container.get(self);\n constant.and_then(|v| fun.values.get(ValueKind::Const(v)))\n }\n}\n\npub enum DynValue {\n Value(Value),\n Block(Block),\n PrimOp(PrimOp),\n Const(Const),\n}\nimpl Into for Value {\n fn into(self) -> DynValue {\n DynValue::Value(self)\n }\n}\nimpl Into for Block {\n fn into(self) -> DynValue {\n DynValue::Block(self)\n }\n}\nimpl Into for PrimOp {\n fn into(self) -> DynValue {\n DynValue::PrimOp(self)\n }\n}\nimpl Into for Const {\n fn into(self) -> DynValue {\n DynValue::Const(self)\n }\n}\nimpl IntoValue for DynValue {\n fn into_value<'a>(self, b: &mut FunctionBuilder<'a>) -> Value {\n match self {\n DynValue::Value(val) => val,\n DynValue::Block(block) => b.value(block),\n DynValue::PrimOp(prim) => b.value(prim),\n DynValue::Const(cons) => b.value(cons),\n }\n }\n fn get_value(self, fun: &Function) -> Option {\n match self {\n DynValue::Value(val) => Some(val),\n DynValue::Block(block) => fun.value_get(block),\n DynValue::PrimOp(prim) => fun.value_get(prim),\n DynValue::Const(cons) => fun.value_get(cons),\n }\n }\n}\n\npub struct FunctionBuilder<'a> {\n fun: &'a mut Function,\n\n block_buf: Option>,\n value_buf: Option>,\n const_pair_buf: Option>,\n value_pair_buf: Option>,\n //mangler: Mangler,\n}\n\nimpl<'a> FunctionBuilder<'a> {\n pub fn new(fun: &'a mut Function) -> FunctionBuilder<'a> {\n // TODO separate allocated data structures into separate\n // reusable struct\n FunctionBuilder {\n fun,\n\n block_buf: Some(Vec::new()),\n value_buf: Some(Vec::new()),\n const_pair_buf: Some(Vec::new()),\n value_pair_buf: Some(Vec::new()),\n }\n }\n\n pub fn fun(&self) -> &Function {\n &self.fun\n }\n pub fn fun_mut(&mut self) -> &mut Function {\n &mut self.fun\n }\n\n pub fn cons(&self) -> &ConstantContainer {\n &self.fun.constant_container\n }\n pub fn cons_mut(&mut self) -> &mut ConstantContainer {\n &mut self.fun.constant_container\n }\n}\n\n/// Values\nimpl<'a> FunctionBuilder<'a> {\n pub fn value(&mut self, v: T) -> Value\n where\n T: IntoValue,\n {\n v.into_value(self)\n }\n\n pub fn value_map(&mut self, mut value: Value, map: &mut F) -> Value\n where\n F: FnMut(Value) -> Option,\n {\n if let Some(new) = map(value) {\n value = new;\n }\n\n match self.fun().value_kind(value) {\n ValueKind::PrimOp(prim) => {\n let mut values = self.fun().primop_reads(prim).to_owned();\n for val in values.iter_mut() {\n debug_assert!(*val != value);\n let new_val = self.value_map(*val, map);\n *val = new_val;\n }\n\n let kind = self.fun().primop_kind(prim).clone();\n let span = self\n .fun()\n .value_locations(value)\n .map(|spans| spans.first().copied().unwrap_or(SourceSpan::UNKNOWN))\n .unwrap_or(SourceSpan::UNKNOWN);\n self.prim_from_kind(span, kind, &values)\n }\n _ => value,\n }\n }\n}\n\n/// Graph\nimpl<'a> FunctionBuilder<'a> {\n /// Updates the successors in the graph from the reads.\n /// Mainly used in the builder.\n pub(crate) fn graph_update_block(&mut self, block: Block) {\n let mut block_buf = self.block_buf.take().unwrap();\n let mut value_buf = self.value_buf.take().unwrap();\n debug_assert!(block_buf.is_empty());\n debug_assert!(value_buf.is_empty());\n\n // 1. Remove the block from all previous successors predecessor sets\n {\n let block_data = &self.fun.blocks[block];\n for successor in block_data.successors.iter(&self.fun.pool.block_set) {\n block_buf.push(successor);\n }\n }\n for successor in block_buf.iter() {\n let block_data = &mut self.fun.blocks[*successor];\n block_data\n .predecessors\n .remove(*successor, &mut self.fun.pool.block_set, &());\n }\n\n // 2. Add new successors to block\n block_buf.clear();\n {\n self.fun\n .block_walk_nested_values::<_, ()>(block, &mut |val| {\n value_buf.push(val);\n Ok(())\n })\n .unwrap();\n\n let block_data = &mut self.fun.blocks[block];\n block_data.successors.clear(&mut self.fun.pool.block_set);\n\n for value in value_buf.iter() {\n let value_data = &mut self.fun.values[*value];\n // Insert block as usage of value\n value_data\n .usages\n .insert(block, &mut self.fun.pool.block_set, &());\n\n // If the value is a block capture, insert into successors\n // for current block\n if let ValueKind::Block(dest_block) = &value_data.kind {\n block_data\n .successors\n .insert(*dest_block, &mut self.fun.pool.block_set, &());\n block_buf.push(*dest_block);\n }\n }\n }\n\n // 3. Add block as predecessor to all successors\n for dest_block in block_buf.iter() {\n let block_data = &mut self.fun.blocks[*dest_block];\n block_data\n .predecessors\n .insert(block, &mut self.fun.pool.block_set, &());\n }\n\n block_buf.clear();\n value_buf.clear();\n self.block_buf = Some(block_buf);\n self.value_buf = Some(value_buf);\n }\n}\n\n/// Block modifiers\nimpl<'a> FunctionBuilder<'a> {\n pub fn block_insert(&mut self) -> Block {\n self.fun.block_insert()\n }\n\n pub fn block_insert_with_span(&mut self, span: Option) -> Block {\n self.fun.block_insert_with_span(span)\n }\n\n /// Inserts a new block and get its value\n pub fn block_insert_get_val(&mut self) -> (Block, Value) {\n let block = self.block_insert();\n let val = self.value(block);\n (block, val)\n }\n\n pub fn block_arg_insert(&mut self, block: Block) -> Value {\n self.fun.block_arg_insert(block)\n }\n\n pub fn block_args(&self, block: Block) -> &[Value] {\n self.fun.block_args(block)\n }\n\n pub fn block_reads(&self, block: Block) -> &[Value] {\n self.fun.block_reads(block)\n }\n\n pub fn block_set_entry(&mut self, block: Block) {\n self.fun.entry_block = Some(block);\n }\n\n pub fn block_set_location(&mut self, block: Block, loc: Location) {\n self.fun.blocks[block].location = loc;\n }\n\n pub fn block_clear_take(&mut self, block: Block) -> Option {\n #[cfg(debug_assertions)]\n self.fun().graph_validate_block(block);\n\n let mut value_buf = self.value_buf.take().unwrap();\n debug_assert!(value_buf.is_empty());\n\n let op;\n\n {\n let data = self.fun.blocks.get_mut(block).unwrap();\n\n op = data.op.take();\n for read in data.reads.as_slice(&self.fun.pool.value) {\n value_buf.push(*read);\n }\n data.successors.clear(&mut self.fun.pool.block_set);\n data.reads.clear(&mut self.fun.pool.value);\n }\n\n for value in value_buf.iter() {\n let data = &mut self.fun.values[*value];\n data.usages.remove(block, &mut self.fun.pool.block_set, &());\n\n if let ValueKind::Block(successor_block) = data.kind {\n let data = self.fun.blocks.get_mut(successor_block).unwrap();\n data.predecessors\n .remove(block, &mut self.fun.pool.block_set, &());\n }\n }\n\n value_buf.clear();\n self.value_buf = Some(value_buf);\n\n op\n }\n\n /// This will explicitly clear the operation contained in the\n /// block. This will remove all successors, and will cause\n /// this block to be removed from their predecessors.\n pub fn block_clear(&mut self, block: Block) {\n self.block_clear_take(block);\n }\n\n pub fn block_value_map(&mut self, block: Block, mut map: F)\n where\n F: FnMut(Value) -> Value,\n {\n let num_reads = self.fun.block_reads(block).len();\n\n let mut new_reads = EntityList::new();\n for val_num in 0..num_reads {\n let val = self.fun.block_reads(block)[val_num];\n let new_val = self.value_map(val, &mut |v| Some(map(v)));\n new_reads.push(new_val, &mut self.fun.pool.value);\n }\n\n self.fun.blocks[block].reads = new_reads;\n }\n\n pub fn block_copy_body_map(&mut self, from: Block, to: Block, mut map: F)\n where\n F: FnMut(Value) -> Option,\n {\n let op;\n let loc;\n {\n let from_data = &self.fun.blocks[from];\n op = from_data.op.clone();\n loc = from_data.location;\n }\n\n let mut reads = EntityList::new();\n {\n let len = self.fun.block_reads(from).len();\n for n in 0..len {\n let val = self.fun.block_reads(from)[n];\n let new = self.value_map(val, &mut map);\n reads.push(new, &mut self.fun.pool.value);\n }\n }\n\n let to_data = &mut self.fun.blocks[to];\n to_data.op = op;\n to_data.reads = reads;\n to_data.location = loc;\n\n self.graph_update_block(to);\n }\n}\n\n#[cfg(test)]\nmod tests {\n use super::*;\n use crate::FunctionIdent;\n\n use libeir_diagnostics::SourceSpan;\n use libeir_intern::Ident;\n\n #[test]\n fn graph_impl() {\n let ident = FunctionIdent {\n module: Ident::from_str(\"test\"),\n name: Ident::from_str(\"test\"),\n arity: 1,\n };\n let mut fun = Function::new(SourceSpan::UNKNOWN, ident);\n let mut b = fun.builder();\n\n {\n let ba = b.block_insert();\n let bb = b.block_insert();\n b.op_call_flow(ba, bb, &[]);\n b.block_clear(ba);\n\n b.fun().graph_validate_global();\n\n let bc = b.block_insert();\n b.op_call_flow(ba, bc, &[]);\n\n b.fun().graph_validate_global();\n }\n }\n}\n" }, { "path": "libeir_ir/src/function/builder/op.rs", "content": "use cranelift_entity::EntityList;\nuse libeir_diagnostics::SourceSpan;\n\nuse crate::binary::BinaryEntrySpecifier;\nuse crate::operation::{DynOp, OpBuild};\nuse crate::IntoValue;\nuse crate::{BasicType, CallKind, MapPutUpdate, MatchKind, OpKind};\nuse crate::{Block, Value};\n\nuse super::FunctionBuilder;\n\n/// Operation constructors\nimpl<'a> FunctionBuilder<'a> {\n pub fn op_call_flow<'b, V>(&'b mut self, block: Block, target: V, args: &[Value])\n where\n V: IntoValue,\n {\n let target_val = self.value(target);\n\n let data = self.fun.blocks.get_mut(block).unwrap();\n assert!(data.op.is_none());\n assert!(data.reads.is_empty());\n\n data.op = Some(OpKind::Call(CallKind::ControlFlow));\n data.reads.push(target_val, &mut self.fun.pool.value);\n data.reads\n .extend(args.iter().cloned(), &mut self.fun.pool.value);\n\n self.graph_update_block(block);\n }\n\n pub fn op_call_function_next<'b, V>(\n &'b mut self,\n span: SourceSpan,\n block: Block,\n target: V,\n ret: Value,\n thr: Value,\n args: &[Value],\n ) where\n V: IntoValue,\n {\n let target_val = self.value(target);\n\n let data = self.fun.blocks.get_mut(block).unwrap();\n assert!(data.op.is_none());\n assert!(data.reads.is_empty());\n\n data.op = Some(OpKind::Call(CallKind::Function));\n data.reads.push(target_val, &mut self.fun.pool.value);\n data.reads.push(ret, &mut self.fun.pool.value);\n data.reads.push(thr, &mut self.fun.pool.value);\n data.reads\n .extend(args.iter().cloned(), &mut self.fun.pool.value);\n\n self.graph_update_block(block);\n }\n pub fn op_call_function<'b, V>(\n &'b mut self,\n span: SourceSpan,\n block: Block,\n target: V,\n args: &[Value],\n ) -> (Block, Block)\n where\n V: IntoValue,\n {\n let (ret, ret_val) = self.block_insert_get_val();\n self.block_arg_insert(ret);\n let (thr, thr_val) = self.block_insert_get_val();\n self.block_arg_insert(thr);\n self.block_arg_insert(thr);\n self.block_arg_insert(thr);\n\n self.op_call_function_next(span, block, target, ret_val, thr_val, args);\n\n (ret, thr)\n }\n\n pub fn op_trace_capture_raw_next(&mut self, span: SourceSpan, block: Block, next: Value) {\n let data = self.fun.blocks.get_mut(block).unwrap();\n assert!(data.op.is_none());\n assert!(data.reads.is_empty());\n\n data.op = Some(OpKind::TraceCaptureRaw);\n data.reads.push(next, &mut self.fun.pool.value);\n\n self.graph_update_block(block);\n }\n pub fn op_trace_capture_raw(&mut self, span: SourceSpan, block: Block) -> Block {\n let cont = self.fun.block_insert();\n let cont_val = self.value(cont);\n self.fun.block_arg_insert(cont);\n\n self.op_trace_capture_raw_next(span, block, cont_val);\n\n cont\n }\n\n pub fn op_intrinsic<'b, O: OpBuild>(\n &'b mut self,\n block: Block,\n op: O,\n args: &[Value],\n _token: O::Token,\n ) {\n assert!(self.fun.dialect.contains_op::());\n\n let data = self.fun.blocks.get_mut(block).unwrap();\n assert!(data.op.is_none());\n assert!(data.reads.is_empty());\n\n let dyn_op = DynOp::new(op);\n data.op = Some(OpKind::Dyn(dyn_op));\n data.reads\n .extend(args.iter().cloned(), &mut self.fun.pool.value);\n\n self.graph_update_block(block);\n }\n\n pub fn op_map_put_build(&mut self, span: SourceSpan, value: Value) -> MapPutBuilder {\n MapPutBuilder::new(span, value, self)\n }\n\n pub fn op_unpack_value_list_next(\n &mut self,\n block: Block,\n target: Value,\n list: Value,\n num: usize,\n ) {\n let data = self.fun.blocks.get_mut(block).unwrap();\n assert!(data.op.is_none());\n assert!(data.reads.is_empty());\n\n data.op = Some(OpKind::UnpackValueList(num));\n data.reads.push(target, &mut self.fun.pool.value);\n data.reads.push(list, &mut self.fun.pool.value);\n\n self.graph_update_block(block);\n }\n pub fn op_unpack_value_list(&mut self, block: Block, list: Value, num: usize) -> Block {\n let cont = self.fun.block_insert();\n let cont_val = self.value(cont);\n for _ in 0..num {\n self.fun.block_arg_insert(cont);\n }\n self.op_unpack_value_list_next(block, cont_val, list, num);\n cont\n }\n\n pub fn op_if_bool_next(\n &mut self,\n span: SourceSpan,\n block: Block,\n t: Value,\n f: Value,\n o: Value,\n value: Value,\n ) {\n let data = self.fun.blocks.get_mut(block).unwrap();\n assert!(data.op.is_none());\n assert!(data.reads.is_empty());\n\n data.op = Some(OpKind::IfBool);\n data.reads.push(t, &mut self.fun.pool.value);\n data.reads.push(f, &mut self.fun.pool.value);\n data.reads.push(o, &mut self.fun.pool.value);\n data.reads.push(value, &mut self.fun.pool.value);\n\n self.graph_update_block(block);\n }\n pub fn op_if_bool(\n &mut self,\n span: SourceSpan,\n block: Block,\n value: Value,\n ) -> (Block, Block, Block) {\n let true_cont = self.fun.block_insert();\n let true_cont_val = self.value(true_cont);\n let false_cont = self.fun.block_insert();\n let false_cont_val = self.value(false_cont);\n let non_cont = self.fun.block_insert();\n let non_cont_val = self.value(non_cont);\n\n self.op_if_bool_next(\n span,\n block,\n true_cont_val,\n false_cont_val,\n non_cont_val,\n value,\n );\n\n (true_cont, false_cont, non_cont)\n }\n\n pub fn op_if_bool_strict_next(\n &mut self,\n span: SourceSpan,\n block: Block,\n t: Value,\n f: Value,\n value: Value,\n ) {\n let data = self.fun.blocks.get_mut(block).unwrap();\n assert!(data.op.is_none());\n assert!(data.reads.is_empty());\n\n data.op = Some(OpKind::IfBool);\n data.reads.push(t, &mut self.fun.pool.value);\n data.reads.push(f, &mut self.fun.pool.value);\n data.reads.push(value, &mut self.fun.pool.value);\n\n self.graph_update_block(block);\n }\n pub fn op_if_bool_strict(\n &mut self,\n span: SourceSpan,\n block: Block,\n value: Value,\n ) -> (Block, Block) {\n let true_cont = self.fun.block_insert();\n let true_cont_val = self.value(true_cont);\n let false_cont = self.fun.block_insert();\n let false_cont_val = self.value(false_cont);\n\n self.op_if_bool_strict_next(span, block, true_cont_val, false_cont_val, value);\n\n (true_cont, false_cont)\n }\n\n pub fn op_unreachable(&mut self, span: SourceSpan, block: Block) {\n let data = self.fun.blocks.get_mut(block).unwrap();\n assert!(data.op.is_none());\n assert!(data.reads.is_empty());\n\n data.op = Some(OpKind::Unreachable);\n\n self.graph_update_block(block);\n }\n\n pub fn op_match_build(&mut self, span: SourceSpan) -> MatchBuilder {\n MatchBuilder::new(span)\n }\n}\n\npub struct MatchBuilder {\n span: SourceSpan,\n branches: EntityList,\n branch_args: EntityList,\n\n kinds: Vec,\n}\nimpl Default for MatchBuilder {\n fn default() -> Self {\n MatchBuilder {\n span: SourceSpan::UNKNOWN,\n branches: EntityList::new(),\n branch_args: EntityList::new(),\n\n kinds: Vec::new(),\n }\n }\n}\nimpl MatchBuilder {\n pub fn new(span: SourceSpan) -> Self {\n let mut this = Self::default();\n this.span = span;\n this\n }\n\n pub fn push_value_next(&mut self, next: Value, val: Value, b: &mut FunctionBuilder) {\n self.kinds.push(MatchKind::Value);\n\n self.branches.push(next, &mut b.fun.pool.value);\n\n let args = b.prim_value_list(&[val]);\n self.branch_args.push(args, &mut b.fun.pool.value);\n }\n pub fn push_value(&mut self, val: Value, b: &mut FunctionBuilder) -> Block {\n let (block, block_val) = b.block_insert_get_val();\n self.push_value_next(block_val, val, b);\n block\n }\n\n pub fn push_type_next(&mut self, next: Value, typ: BasicType, b: &mut FunctionBuilder) {\n self.kinds.push(MatchKind::Type(typ));\n\n self.branches.push(next, &mut b.fun.pool.value);\n\n let args = b.prim_value_list(&[]);\n self.branch_args.push(args, &mut b.fun.pool.value);\n }\n pub fn push_type(&mut self, typ: BasicType, b: &mut FunctionBuilder) -> Block {\n let (block, block_val) = b.block_insert_get_val();\n self.push_type_next(block_val, typ, b);\n block\n }\n\n pub fn push_tuple_next(&mut self, next: Value, arity: usize, b: &mut FunctionBuilder) {\n self.kinds.push(MatchKind::Tuple(arity));\n\n self.branches.push(next, &mut b.fun.pool.value);\n\n let args = b.prim_value_list(&[]);\n self.branch_args.push(args, &mut b.fun.pool.value);\n }\n pub fn push_tuple(&mut self, arity: usize, b: &mut FunctionBuilder) -> Block {\n let (block, block_val) = b.block_insert_get_val();\n for _ in 0..arity {\n b.block_arg_insert(block);\n }\n\n self.push_tuple_next(block_val, arity, b);\n\n block\n }\n\n pub fn push_binary(\n &mut self,\n specifier: BinaryEntrySpecifier,\n size: Option,\n b: &mut FunctionBuilder,\n ) -> Block {\n let (block, block_val) = b.block_insert_get_val();\n b.block_arg_insert(block);\n b.block_arg_insert(block);\n\n self.kinds.push(MatchKind::Binary(specifier));\n\n self.branches.push(block_val, &mut b.fun.pool.value);\n\n let args = if let Some(size) = size {\n b.prim_value_list(&[size])\n } else {\n b.prim_value_list(&[])\n };\n self.branch_args.push(args, &mut b.fun.pool.value);\n\n block\n }\n\n pub fn push_list_cell_next(&mut self, next: Value, b: &mut FunctionBuilder) {\n self.kinds.push(MatchKind::ListCell);\n\n self.branches.push(next, &mut b.fun.pool.value);\n\n let args = b.prim_value_list(&[]);\n self.branch_args.push(args, &mut b.fun.pool.value);\n }\n pub fn push_list_cell(&mut self, b: &mut FunctionBuilder) -> Block {\n let (block, block_val) = b.block_insert_get_val();\n b.block_arg_insert(block);\n b.block_arg_insert(block);\n\n self.push_list_cell_next(block_val, b);\n\n block\n }\n\n pub fn push_map_item_next(&mut self, next: Value, key: Value, b: &mut FunctionBuilder) {\n self.kinds.push(MatchKind::MapItem);\n\n self.branches.push(next, &mut b.fun.pool.value);\n\n let args = b.prim_value_list(&[key]);\n self.branch_args.push(args, &mut b.fun.pool.value);\n }\n pub fn push_map_item(&mut self, key: Value, b: &mut FunctionBuilder) -> Block {\n let (block, block_val) = b.block_insert_get_val();\n b.block_arg_insert(block);\n\n self.push_map_item_next(block_val, key, b);\n\n block\n }\n\n pub fn push_wildcard_next(&mut self, next: Value, b: &mut FunctionBuilder) {\n self.kinds.push(MatchKind::Wildcard);\n\n self.branches.push(next, &mut b.fun.pool.value);\n\n let args = b.prim_value_list(&[]);\n self.branch_args.push(args, &mut b.fun.pool.value);\n }\n pub fn push_wildcard(&mut self, span: SourceSpan, b: &mut FunctionBuilder) -> Block {\n let (block, block_val) = b.block_insert_get_val();\n {\n let mut block_data = b.fun.blocks.get_mut(block).unwrap();\n }\n self.push_wildcard_next(block_val, b);\n block\n }\n\n pub fn finish(self, block: Block, value: Value, b: &mut FunctionBuilder) {\n let branches = b.prim_value_list_from_entity_list(self.branches);\n\n let data = b.fun.blocks.get_mut(block).unwrap();\n assert!(data.op.is_none());\n assert!(data.reads.is_empty());\n\n let mut reads = EntityList::new();\n reads.push(branches, &mut b.fun.pool.value);\n reads.push(value, &mut b.fun.pool.value);\n\n let branches_num = self.branch_args.len(&b.fun.pool.value);\n for n in 0..branches_num {\n let branch_val = self.branch_args.get(n, &b.fun.pool.value).unwrap();\n reads.push(branch_val, &mut b.fun.pool.value);\n }\n\n data.op = Some(OpKind::Match {\n branches: self.kinds,\n });\n data.reads = reads;\n\n b.graph_update_block(block);\n b.fun.graph_validate_block(block);\n }\n}\n\npub struct MapPutBuilder {\n span: SourceSpan,\n ok: Block,\n fail: Block,\n reads: EntityList,\n actions: Vec,\n}\nimpl MapPutBuilder {\n pub fn new(span: SourceSpan, value: Value, b: &mut FunctionBuilder) -> Self {\n let (ok, ok_val) = b.block_insert_get_val();\n b.block_arg_insert(ok);\n\n let (fail, fail_val) = b.block_insert_get_val();\n b.block_arg_insert(fail);\n\n let mut reads = EntityList::new();\n reads.push(ok_val, &mut b.fun.pool.value);\n reads.push(fail_val, &mut b.fun.pool.value);\n\n reads.push(value, &mut b.fun.pool.value);\n\n MapPutBuilder {\n span,\n ok,\n fail,\n reads,\n actions: Vec::new(),\n }\n }\n\n pub fn push_kv(\n &mut self,\n key: Value,\n val: Value,\n action: MapPutUpdate,\n b: &mut FunctionBuilder,\n ) {\n self.actions.push(action);\n\n self.reads.push(key, &mut b.fun.pool.value);\n self.reads.push(val, &mut b.fun.pool.value);\n }\n\n pub fn finish(self, block: Block, b: &mut FunctionBuilder) -> (Block, Block) {\n let data = b.fun.blocks.get_mut(block).unwrap();\n assert!(data.op.is_none());\n assert!(data.reads.is_empty());\n\n data.op = Some(OpKind::MapPut {\n action: self.actions,\n });\n data.reads = self.reads;\n\n b.graph_update_block(block);\n\n (self.ok, self.fail)\n }\n}\n" }, { "path": "libeir_ir/src/function/builder/primop.rs", "content": "use cranelift_entity::EntityList;\n\nuse libeir_diagnostics::SourceSpan;\n\nuse super::{BinOp, FunctionBuilder, PrimOpData, PrimOpKind};\nuse crate::{ConstKind, IntoValue, LogicOp, Value, ValueKind};\n\n/// PrimOp constructors\nimpl<'a> FunctionBuilder<'a> {\n pub fn prim_binop(&mut self, span: SourceSpan, op: BinOp, lhs: Value, rhs: Value) -> Value {\n let loc = self.fun.locations.location(None, None, None, None, span);\n let mut reads = EntityList::new();\n if op.symmetric() && lhs >= rhs {\n reads.extend([rhs, lhs].iter().cloned(), &mut self.fun.pool.value);\n } else {\n reads.extend([lhs, rhs].iter().cloned(), &mut self.fun.pool.value);\n }\n\n let primop = self.fun.primops.push(\n PrimOpData {\n op: PrimOpKind::BinOp(op),\n reads,\n },\n &self.fun.pool,\n );\n self.fun\n .values\n .push_with_location(ValueKind::PrimOp(primop), Some(loc))\n }\n\n /// This will construct a tuple.\n /// If all values are constants, a constant tuple is created.\n /// Otherwise, a tuple PrimOp is created.\n pub fn prim_tuple(&mut self, span: SourceSpan, values: &[Value]) -> Value {\n if values.iter().all(|v| self.fun.value_const(*v).is_some()) {\n let mut entries = EntityList::new();\n for val in values {\n let cons = self.fun.value_const(*val).unwrap();\n entries.push(cons, &mut self.fun.constant_container.const_pool);\n }\n\n let cons = self.cons_mut().from(ConstKind::Tuple { entries });\n self.value(cons)\n } else {\n let loc = self.fun.locations.location(None, None, None, None, span);\n let mut reads = EntityList::new();\n for val in values {\n reads.push(*val, &mut self.fun.pool.value);\n }\n\n let primop = self.fun.primops.push(\n PrimOpData {\n op: PrimOpKind::Tuple,\n reads,\n },\n &self.fun.pool,\n );\n self.fun\n .values\n .push_with_location(ValueKind::PrimOp(primop), Some(loc))\n }\n }\n\n /// This will construct a new map.\n /// If all values are constants, a constant map is created.\n /// Otherwise, a map PrimOp is created.\n pub fn prim_map(&mut self, span: SourceSpan, keys: &[Value], values: &[Value]) -> Value {\n if keys.iter().all(|v| self.fun.value_const(*v).is_some())\n && values.iter().all(|v| self.fun.value_const(*v).is_some())\n {\n let mut const_pair = self.const_pair_buf.take().unwrap();\n assert!(const_pair.is_empty());\n\n const_pair.extend(\n keys.iter()\n .map(|v| self.fun.value_const(*v).unwrap())\n .zip(values.iter().map(|v| self.fun.value_const(*v).unwrap()))\n .map(|(k, v)| [k, v]),\n );\n const_pair.sort_by(|[k1, _], [k2, _]| k1.cmp(k2));\n\n let mut key_list = EntityList::new();\n key_list.extend(\n const_pair.iter().map(|[k, _]| *k),\n &mut self.cons_mut().const_pool,\n );\n\n let mut val_list = EntityList::new();\n val_list.extend(\n const_pair.iter().map(|[_, v]| *v),\n &mut self.cons_mut().const_pool,\n );\n\n const_pair.clear();\n self.const_pair_buf = Some(const_pair);\n\n let cons = self.cons_mut().from(ConstKind::Map {\n keys: key_list,\n values: val_list,\n });\n self.value(cons)\n } else {\n let loc = self.fun.locations.location(None, None, None, None, span);\n let mut value_pair = self.value_pair_buf.take().unwrap();\n assert!(value_pair.is_empty());\n\n value_pair.extend(\n keys.iter()\n .cloned()\n .zip(values.iter().cloned())\n .map(|(k, v)| [k, v]),\n );\n value_pair.sort_by(|[k1, _], [k2, _]| k1.cmp(k2));\n\n let mut entries_list = EntityList::new();\n entries_list.extend(\n value_pair.iter().flatten().cloned(),\n &mut self.fun.pool.value,\n );\n\n value_pair.clear();\n self.value_pair_buf = Some(value_pair);\n\n let primop = self.fun.primops.push(\n PrimOpData {\n op: PrimOpKind::Map,\n reads: entries_list,\n },\n &self.fun.pool,\n );\n self.fun\n .values\n .push_with_location(ValueKind::PrimOp(primop), Some(loc))\n }\n }\n\n pub fn prim_list_cell(&mut self, span: SourceSpan, head: Value, tail: Value) -> Value {\n if let (Some(head_v), Some(tail_v)) =\n (self.fun.value_const(head), self.fun.value_const(tail))\n {\n let cons = self.cons_mut().from(ConstKind::ListCell {\n head: head_v,\n tail: tail_v,\n });\n self.value(cons)\n } else {\n let loc = self.fun.locations.location(None, None, None, None, span);\n let mut entries_list = EntityList::new();\n entries_list.push(head, &mut self.fun.pool.value);\n entries_list.push(tail, &mut self.fun.pool.value);\n\n let primop = self.fun.primops.push(\n PrimOpData {\n op: PrimOpKind::ListCell,\n reads: entries_list,\n },\n &self.fun.pool,\n );\n self.fun\n .values\n .push_with_location(ValueKind::PrimOp(primop), Some(loc))\n }\n }\n\n pub fn prim_value_list(&mut self, values: &[Value]) -> Value {\n assert!(values.iter().all(|v| {\n self.fun.value_primop(*v).map(|p| self.fun.primop_kind(p))\n != Some(&PrimOpKind::ValueList)\n }));\n\n if values.len() == 1 {\n return values[0];\n }\n\n let mut entries_list = EntityList::new();\n entries_list.extend(values.iter().cloned(), &mut self.fun.pool.value);\n\n let primop = self.fun.primops.push(\n PrimOpData {\n op: PrimOpKind::ValueList,\n reads: entries_list,\n },\n &self.fun.pool,\n );\n self.fun.values.push(ValueKind::PrimOp(primop))\n }\n\n pub(crate) fn prim_value_list_from_entity_list(&mut self, values: EntityList) -> Value {\n let num = values.len(&self.fun.pool.value);\n\n if num == 1 {\n return values.get(0, &self.fun.pool.value).unwrap();\n }\n\n for n in 0..num {\n let val = values.get(n, &self.fun.pool.value).unwrap();\n if let Some(prim) = self.fun.value_primop(val) {\n assert!(self.fun.primop_kind(prim) != &PrimOpKind::ValueList);\n }\n }\n\n let primop = self.fun.primops.push(\n PrimOpData {\n op: PrimOpKind::ValueList,\n reads: values,\n },\n &self.fun.pool,\n );\n self.fun.values.push(ValueKind::PrimOp(primop))\n }\n\n pub fn prim_logic_op(&mut self, span: SourceSpan, op: LogicOp, values: &[Value]) -> Value {\n match (op, values.len()) {\n (LogicOp::And, 0) => return self.value(true),\n (LogicOp::And, 1) => return values[0],\n (LogicOp::Or, 0) => return self.value(false),\n (LogicOp::Or, 1) => return values[0],\n (LogicOp::Eq, 0) => return self.value(true),\n (LogicOp::Eq, 1) => return self.value(true),\n _ => (),\n }\n\n if values.iter().all(|v| self.fun.value_const(*v).is_some()) {\n let true_const = self.value(true);\n let false_const = self.value(false);\n match op {\n LogicOp::And => {\n let mut acc = true;\n for val in values {\n if *val == false_const {\n acc = false;\n } else {\n assert!(*val == true_const);\n }\n }\n self.value(acc)\n }\n LogicOp::Or => {\n let mut acc = false;\n for val in values {\n if *val == true_const {\n acc = true;\n } else {\n assert!(*val == false_const);\n }\n }\n self.value(acc)\n }\n LogicOp::Eq => unimplemented!(),\n }\n } else {\n let loc = self.fun.locations.location(None, None, None, None, span);\n let mut entries_list = EntityList::new();\n entries_list.extend(values.iter().cloned(), &mut self.fun.pool.value);\n\n let primop = self.fun.primops.push(\n PrimOpData {\n op: PrimOpKind::LogicOp(op),\n reads: entries_list,\n },\n &self.fun.pool,\n );\n self.fun\n .values\n .push_with_location(ValueKind::PrimOp(primop), Some(loc))\n }\n }\n\n pub fn prim_capture_function(&mut self, span: SourceSpan, m: M, f: F, a: A) -> Value\n where\n M: IntoValue,\n F: IntoValue,\n A: IntoValue,\n {\n let m_val = self.value(m);\n let f_val = self.value(f);\n let a_val = self.value(a);\n\n let mut entries_list = EntityList::new();\n entries_list.push(m_val, &mut self.fun.pool.value);\n entries_list.push(f_val, &mut self.fun.pool.value);\n entries_list.push(a_val, &mut self.fun.pool.value);\n\n let loc = self.fun.locations.location(None, None, None, None, span);\n let primop = self.fun.primops.push(\n PrimOpData {\n op: PrimOpKind::CaptureFunction,\n reads: entries_list,\n },\n &self.fun.pool,\n );\n self.fun\n .values\n .push_with_location(ValueKind::PrimOp(primop), Some(loc))\n }\n\n pub fn prim_from_kind(&mut self, span: SourceSpan, op: PrimOpKind, vals: &[Value]) -> Value {\n match op {\n PrimOpKind::ValueList => self.prim_value_list(vals),\n PrimOpKind::Tuple => self.prim_tuple(span, vals),\n PrimOpKind::CaptureFunction => {\n assert!(vals.len() == 3);\n self.prim_capture_function(span, vals[0], vals[1], vals[2])\n }\n PrimOpKind::LogicOp(op) => self.prim_logic_op(span, op, vals),\n PrimOpKind::BinOp(op) => {\n assert!(vals.len() == 2);\n self.prim_binop(span, op, vals[0], vals[1])\n }\n PrimOpKind::ListCell => {\n assert!(vals.len() == 2);\n self.prim_list_cell(span, vals[0], vals[1])\n }\n p => unimplemented!(\"{:?}\", p),\n }\n }\n}\n" }, { "path": "libeir_ir/src/function/format.rs", "content": "#[macro_export]\nmacro_rules! function_format {\n ($fun:expr, $str:expr, $($arg:expr),*) => {\n format!($str, $($crate::ContainerDebugAdapter { container: $fun, value: $arg }),*)\n };\n}\n\nuse std::fmt::{Debug, Formatter, Result};\nuse std::hash::Hash;\n\nuse std::collections::{BTreeMap, HashMap};\nuse std::collections::{BTreeSet, HashSet};\n\nuse super::{Function, Value, ValueKind};\n\npub trait ContainerDebug: Debug {\n fn fmt(&self, container: &C, f: &mut Formatter) -> Result;\n}\n\npub struct ContainerDebugAdapter<'a, C, V> {\n pub container: &'a C,\n pub value: &'a V,\n}\nimpl Debug for ContainerDebugAdapter<'_, C, V>\nwhere\n V: ContainerDebug,\n{\n fn fmt(&self, f: &mut Formatter) -> Result {\n ContainerDebug::fmt(self.value, self.container, f)\n }\n}\n\ndefault impl ContainerDebug for V {\n fn fmt(&self, _con: &C, f: &mut Formatter) -> Result {\n std::fmt::Debug::fmt(self, f)\n }\n}\n\nimpl ContainerDebug for Value {\n fn fmt(&self, fun: &Function, f: &mut Formatter) -> Result {\n match fun.value_kind(*self) {\n ValueKind::PrimOp(prim) => write!(f, \"{}#{}\", self, prim),\n ValueKind::Block(block) => write!(f, \"{}#{}\", self, block),\n ValueKind::Argument(block, num) => write!(f, \"{}#{}[{}]\", self, block, num),\n ValueKind::Const(cons) => write!(f, \"{}#{}\", self, cons),\n }\n }\n}\n\nimpl ContainerDebug for &[Value] {\n fn fmt(&self, fun: &Function, f: &mut Formatter) -> Result {\n let values = self.as_ref();\n let mut builder = f.debug_list();\n\n builder\n .entries(values.iter().map(|v| ContainerDebugAdapter {\n container: fun,\n value: v,\n }))\n .finish()\n }\n}\n\nimpl ContainerDebug for HashMap\nwhere\n K: ContainerDebug + Hash + Eq,\n V: ContainerDebug,\n{\n fn fmt(&self, con: &C, f: &mut Formatter) -> Result {\n let mut builder = f.debug_map();\n builder\n .entries(self.iter().map(|(k, v)| {\n (\n ContainerDebugAdapter {\n container: con,\n value: k,\n },\n ContainerDebugAdapter {\n container: con,\n value: v,\n },\n )\n }))\n .finish()\n }\n}\nimpl ContainerDebug for BTreeMap\nwhere\n K: ContainerDebug + Hash,\n V: ContainerDebug,\n{\n fn fmt(&self, con: &C, f: &mut Formatter) -> Result {\n let mut builder = f.debug_map();\n builder\n .entries(self.iter().map(|(k, v)| {\n (\n ContainerDebugAdapter {\n container: con,\n value: k,\n },\n ContainerDebugAdapter {\n container: con,\n value: v,\n },\n )\n }))\n .finish()\n }\n}\n\nimpl ContainerDebug for HashSet\nwhere\n V: ContainerDebug + Hash + Eq,\n{\n fn fmt(&self, con: &C, f: &mut Formatter) -> Result {\n let mut builder = f.debug_set();\n builder\n .entries(self.iter().map(|v| ContainerDebugAdapter {\n container: con,\n value: v,\n }))\n .finish()\n }\n}\nimpl ContainerDebug for BTreeSet\nwhere\n V: ContainerDebug + Hash + Eq,\n{\n fn fmt(&self, con: &C, f: &mut Formatter) -> Result {\n let mut builder = f.debug_set();\n builder\n .entries(self.iter().map(|v| ContainerDebugAdapter {\n container: con,\n value: v,\n }))\n .finish()\n }\n}\n\nimpl ContainerDebug for bool {\n fn fmt(&self, _con: &C, f: &mut Formatter) -> Result {\n write!(f, \"{}\", self)\n }\n}\n\nmacro_rules! impl_tuple {\n ($(($typ:ident, $n:tt)),*) => {\n #[allow(unused_variables)]\n impl ContainerDebug for ($($typ,)*)\n where $($typ: ContainerDebug,)*\n {\n fn fmt(&self, con: &Container, f: &mut Formatter) -> Result {\n let mut builder = f.debug_tuple(\"\");\n $(\n builder.field(&ContainerDebugAdapter { container: con, value: &self.$n });\n )*\n builder.finish()\n }\n }\n\n }\n}\n\nimpl_tuple!();\nimpl_tuple!((A, 0));\nimpl_tuple!((A, 0), (B, 1));\nimpl_tuple!((A, 0), (B, 1), (C, 2));\nimpl_tuple!((A, 0), (B, 1), (C, 2), (D, 3));\nimpl_tuple!((A, 0), (B, 1), (C, 2), (D, 3), (E, 4));\nimpl_tuple!((A, 0), (B, 1), (C, 2), (D, 3), (E, 4), (F, 5));\nimpl_tuple!((A, 0), (B, 1), (C, 2), (D, 3), (E, 4), (F, 5), (G, 6));\nimpl_tuple!(\n (A, 0),\n (B, 1),\n (C, 2),\n (D, 3),\n (E, 4),\n (F, 5),\n (G, 6),\n (H, 7)\n);\n" }, { "path": "libeir_ir/src/function/location.rs", "content": "use std::hash::{Hash, Hasher};\n\nuse libeir_util_datastructures::dedup_aux_primary_map::DedupPrimaryMap;\nuse libeir_util_datastructures::{\n aux_traits::{AuxEq, AuxHash},\n dedup_aux_primary_map::DedupAuxPrimaryMap,\n};\n\nuse cranelift_entity::{entity_impl, EntityList, ListPool};\nuse libeir_diagnostics::{CodeMap, SourceSpan};\n\n#[derive(Copy, Clone, Hash, PartialEq, Eq, PartialOrd, Ord)]\npub struct Location(u32);\nentity_impl!(Location, \"loc\");\n\n#[derive(Copy, Clone, Hash, PartialEq, Eq, PartialOrd, Ord)]\npub struct LocationTerminal(u32);\nentity_impl!(LocationTerminal, \"loc_terminal\");\n\n#[derive(Debug, Clone, PartialEq, Eq, Hash)]\nstruct LocationTerminalData {\n /// Path to display for the origin file\n file: Option,\n /// Line number in origin file\n line: Option,\n\n /// Name of module\n module: Option,\n /// Name of function/stack entity\n entity: Option,\n\n /// Span in the file this was read from.\n /// While the `file`, `line` and `name` files are\n /// meant to be preserved when reading/writing\n /// to textual Eir, this span is meant to be the\n /// direct file it was read from.\n span: SourceSpan,\n}\n\nimpl AuxHash<()> for LocationTerminalData {\n fn aux_hash(&self, state: &mut H, _container: &()) {\n self.hash(state)\n }\n}\nimpl AuxEq<()> for LocationTerminalData {\n fn aux_eq(&self, rhs: &Self, _self_aux: &(), _rhs_aux: &()) -> bool {\n self.eq(rhs)\n }\n}\n\n#[derive(Debug, Clone)]\nstruct LocationData {\n terminals: EntityList,\n}\nimpl AuxHash> for LocationData {\n fn aux_hash(&self, state: &mut H, container: &ListPool) {\n self.terminals.as_slice(container).hash(state)\n }\n}\nimpl AuxEq> for LocationData {\n fn aux_eq(\n &self,\n other: &Self,\n self_aux: &ListPool,\n other_aux: &ListPool,\n ) -> bool {\n self.terminals.as_slice(self_aux) == other.terminals.as_slice(other_aux)\n }\n}\n\n#[derive(Debug, Clone)]\npub struct LocationContainer {\n terminals: DedupPrimaryMap,\n locations: DedupAuxPrimaryMap>,\n\n terminal_pool: ListPool,\n}\n\nimpl LocationContainer {\n pub fn new() -> Self {\n let locations = DedupAuxPrimaryMap::new();\n let terminals = DedupPrimaryMap::new();\n let terminal_pool = ListPool::new();\n\n LocationContainer {\n locations,\n terminals,\n terminal_pool,\n }\n }\n\n pub fn lookup(&self, location: &Location) -> Vec {\n let terminals = self.locations[*location]\n .terminals\n .as_slice(&self.terminal_pool);\n let mut locs = Vec::with_capacity(terminals.len());\n for terminal in terminals.iter().cloned() {\n let terminal_data = &self.terminals[terminal];\n locs.push(terminal_data.span.clone());\n }\n locs\n }\n\n pub fn location_empty(&mut self) -> Location {\n self.locations.push(\n LocationData {\n terminals: EntityList::new(),\n },\n &mut self.terminal_pool,\n )\n }\n\n pub fn location_unknown(&mut self) -> Location {\n let terminal = self.terminals.push(\n LocationTerminalData {\n file: None,\n line: None,\n module: None,\n entity: None,\n span: SourceSpan::UNKNOWN,\n },\n &mut (),\n );\n\n let mut terminals = EntityList::new();\n terminals.push(terminal, &mut self.terminal_pool);\n\n self.locations.push(\n LocationData {\n terminals: EntityList::new(),\n },\n &mut self.terminal_pool,\n )\n }\n\n pub fn terminal(\n &mut self,\n file: Option,\n line: Option,\n module: Option,\n entity: Option,\n span: SourceSpan,\n ) -> LocationTerminal {\n self.terminals.push(\n LocationTerminalData {\n file,\n line,\n module,\n entity,\n span,\n },\n &mut (),\n )\n }\n\n pub fn location(\n &mut self,\n file: Option,\n line: Option,\n module: Option,\n entity: Option,\n span: SourceSpan,\n ) -> Location {\n let terminal = self.terminal(file, line, module, entity, span);\n\n let mut terminals = EntityList::new();\n terminals.push(terminal, &mut self.terminal_pool);\n\n self.locations\n .push(LocationData { terminals }, &mut self.terminal_pool)\n }\n\n pub fn terminal_from_bytespan(\n &mut self,\n codemap: &CodeMap,\n span: SourceSpan,\n module: Option,\n entity: Option,\n ) -> LocationTerminal {\n let mut file = None;\n let mut line = None;\n\n let start_idx = span.start_index();\n if let Some(filemap) = codemap.get(span.source_id()) {\n file = Some(filemap.name().to_string());\n let line_idx = filemap.line_index(start_idx);\n line = Some(line_idx.0);\n }\n\n self.terminal(file, line, module, entity, span)\n }\n\n pub fn from_bytespan(\n &mut self,\n codemap: &CodeMap,\n span: SourceSpan,\n module: Option,\n entity: Option,\n ) -> Location {\n let terminal = self.terminal_from_bytespan(codemap, span, module, entity);\n\n let mut terminals = EntityList::new();\n terminals.push(terminal, &mut self.terminal_pool);\n\n self.locations\n .push(LocationData { terminals }, &mut self.terminal_pool)\n }\n\n pub fn from_terminals(&mut self, terminals: &[LocationTerminal]) -> Location {\n let mut n_terminals = EntityList::new();\n n_terminals.extend(terminals.iter().cloned(), &mut self.terminal_pool);\n\n self.locations.push(\n LocationData {\n terminals: n_terminals,\n },\n &mut self.terminal_pool,\n )\n }\n\n pub fn concat_locations(&mut self, bottom: Location, top: Location) -> Location {\n let mut terminals = Vec::new();\n terminals.extend(\n self.locations[bottom]\n .terminals\n .as_slice(&self.terminal_pool)\n .iter()\n .cloned(),\n );\n terminals.extend(\n self.locations[top]\n .terminals\n .as_slice(&self.terminal_pool)\n .iter()\n .cloned(),\n );\n\n let mut new_terminals = EntityList::new();\n new_terminals.extend(terminals.iter().cloned(), &mut self.terminal_pool);\n\n self.locations.push(\n LocationData {\n terminals: new_terminals,\n },\n &mut self.terminal_pool,\n )\n }\n\n pub fn location_eq(&self, l_loc: Location, r: &Self, r_loc: Location) -> bool {\n let l_n = &self.locations[l_loc];\n let r_n = &r.locations[r_loc];\n\n let l_ts = l_n.terminals.as_slice(&self.terminal_pool);\n let r_ts = r_n.terminals.as_slice(&r.terminal_pool);\n\n if l_ts.len() != r_ts.len() {\n return false;\n }\n\n for (l_t, r_t) in l_ts.iter().zip(r_ts.iter()) {\n let l_i = &self.terminals[*l_t];\n let r_i = &r.terminals[*r_t];\n\n if l_i.file != r_i.file\n || l_i.module != r_i.module\n || l_i.entity != r_i.entity\n || l_i.line != r_i.line\n {\n return false;\n }\n }\n\n return true;\n }\n\n pub fn format_loc(&self, loc: Location) -> String {\n use std::fmt::Write;\n\n let loc_inner = &self.locations[loc];\n let mut out = String::new();\n\n write!(&mut out, \"[\").unwrap();\n for term in loc_inner.terminals.as_slice(&self.terminal_pool) {\n let term_inner = &self.terminals[*term];\n\n if let Some(file) = &term_inner.file {\n write!(&mut out, \"{:?}:\", file).unwrap();\n } else {\n write!(&mut out, \"nil:\").unwrap();\n }\n if let Some(line) = &term_inner.line {\n write!(&mut out, \"{:?}@\", line).unwrap();\n } else {\n write!(&mut out, \"nil@\").unwrap();\n }\n if let Some(module) = &term_inner.module {\n write!(&mut out, \"{:?}:\", module).unwrap();\n } else {\n write!(&mut out, \"nil:\").unwrap();\n }\n if let Some(entity) = &term_inner.entity {\n write!(&mut out, \"{:?}\", entity).unwrap();\n } else {\n write!(&mut out, \"nil\").unwrap();\n }\n\n write!(&mut out, \", \").unwrap();\n }\n write!(&mut out, \"]\").unwrap();\n\n out\n }\n}\n" }, { "path": "libeir_ir/src/function/mod.rs", "content": "use std::cmp::Eq;\nuse std::collections::HashSet;\nuse std::hash::{Hash, Hasher};\n\nuse cranelift_bforest::{BoundSet, Set, SetForest};\nuse cranelift_entity::packed_option::ReservedValue;\nuse cranelift_entity::{entity_impl, EntityList, ListPool, PrimaryMap};\n\nuse libeir_util_datastructures::aux_traits::{AuxDebug, AuxEq, AuxHash, HasAux};\nuse libeir_util_datastructures::dedup_aux_primary_map::DedupAuxPrimaryMap;\n\nuse libeir_diagnostics::SourceSpan;\n\nuse crate::constant::{Const, ConstKind, ConstantContainer};\nuse crate::{ArcDialect, FunctionIdent};\n\npub mod builder;\nuse builder::IntoValue;\n\nmod pool_container;\nuse pool_container::PoolContainer;\n\nmod op;\npub use op::{BasicType, CallKind, MapPutUpdate, MatchKind, OpKind};\n\nmod primop;\npub use primop::{BinOp, LogicOp, PrimOpKind};\n\nmod value;\nuse value::ValueMap;\npub use value::{Value, ValueKind};\n\nmod location;\npub use location::{Location, LocationContainer};\n\nmod format;\npub use format::{ContainerDebug, ContainerDebugAdapter};\n\n//mod serialize;\n\n/// Block/continuation\n#[derive(Copy, Clone, Hash, PartialEq, Eq, PartialOrd, Ord)]\npub struct Block(u32);\nentity_impl!(Block, \"block\");\nimpl Default for Block {\n fn default() -> Self {\n Block::reserved_value()\n }\n}\nimpl AuxDebug for Block {\n fn aux_fmt(&self, f: &mut std::fmt::Formatter<'_>, _aux: &C) -> std::fmt::Result {\n std::fmt::Debug::fmt(self, f)\n }\n}\n\n#[derive(Copy, Clone, Hash, PartialEq, Eq)]\npub struct Argument(u32);\nentity_impl!(Argument, \"argument\");\n\n/// Reference to other function\n#[derive(Copy, Clone, Hash, PartialEq, Eq, PartialOrd, Ord)]\npub struct FunRef(u32);\nentity_impl!(FunRef, \"fun_ref\");\n\n#[derive(Copy, Clone, Hash, PartialEq, Eq, PartialOrd, Ord)]\npub struct PrimOp(u32);\nentity_impl!(PrimOp, \"prim_op\");\n\n#[derive(Clone)]\npub struct BlockData {\n pub(crate) arguments: EntityList,\n\n pub(crate) op: Option,\n pub(crate) reads: EntityList,\n\n pub(crate) location: Location,\n\n // Auxilary data for graph implementation\n\n // These will contain all the connected blocks, regardless\n // of whether they are actually alive or not.\n pub(crate) predecessors: Set,\n pub(crate) successors: Set,\n}\n\n#[derive(Debug, Clone)]\npub struct PrimOpData {\n op: PrimOpKind,\n reads: EntityList,\n}\nimpl AuxHash for PrimOpData {\n fn aux_hash(&self, state: &mut H, container: &PoolContainer) {\n self.op.hash(state);\n self.reads.as_slice(&container.value).hash(state);\n }\n}\nimpl AuxEq for PrimOpData {\n fn aux_eq(\n &self,\n rhs: &PrimOpData,\n self_aux: &PoolContainer,\n other_aux: &PoolContainer,\n ) -> bool {\n if self.op != rhs.op {\n return false;\n }\n self.reads.as_slice(&self_aux.value) == rhs.reads.as_slice(&other_aux.value)\n }\n}\n\n#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]\npub enum AttributeKey {\n Continuation,\n}\n#[derive(Debug, Clone, PartialEq, Eq)]\npub enum AttributeValue {\n None,\n}\n\n#[derive(Clone)]\npub struct Function {\n // Meta\n ident: FunctionIdent,\n entry_block: Option,\n span: SourceSpan,\n\n dialect: ArcDialect,\n\n pub(crate) blocks: PrimaryMap,\n pub(crate) values: ValueMap,\n pub(crate) primops: DedupAuxPrimaryMap,\n\n pub pool: PoolContainer,\n\n constant_container: ConstantContainer,\n\n // Auxiliary information\n pub constant_values: HashSet,\n pub locations: LocationContainer,\n}\n\nimpl Function {\n pub fn dialect(&self) -> &ArcDialect {\n &self.dialect\n }\n\n pub fn span(&self) -> SourceSpan {\n self.span\n }\n\n pub fn cons(&self) -> &ConstantContainer {\n &self.constant_container\n }\n}\n\nimpl HasAux> for Function {\n fn get_aux(&self) -> &ListPool {\n &self.pool.value\n }\n}\nimpl HasAux> for Function {\n fn get_aux(&self) -> &SetForest {\n &self.pool.block_set\n }\n}\n\nimpl> AuxDebug for Function {\n fn aux_fmt(&self, _f: &mut std::fmt::Formatter<'_>, _container: &C) -> std::fmt::Result {\n unimplemented!()\n }\n}\n\nimpl std::fmt::Debug for Function {\n fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {\n self.aux_fmt(fmt, self)\n }\n}\n\n/// Values\nimpl Function {\n pub fn value_get(&self, v: T) -> Option\n where\n T: IntoValue,\n {\n v.get_value(self)\n }\n\n pub fn iter_constants(&self) -> std::collections::hash_set::Iter<'_, Value> {\n self.constant_values.iter()\n }\n\n pub fn const_kind(&self, constant: Const) -> &ConstKind {\n self.constant_container.const_kind(constant)\n }\n\n pub fn const_entries<'f>(&'f self, entries: &'f EntityList) -> &'f [Const] {\n entries.as_slice(&self.constant_container.const_pool)\n }\n\n pub fn value_kind(&self, value: Value) -> ValueKind {\n self.values[value].kind\n }\n\n pub fn value_locations(&self, value: Value) -> Option> {\n self.values[value]\n .location\n .as_ref()\n .map(|loc| self.locations.lookup(loc))\n }\n\n pub fn value_is_constant(&self, value: Value) -> bool {\n self.constant_values.contains(&value)\n }\n\n pub fn value_list_length(&self, value: Value) -> usize {\n match self.value_kind(value) {\n ValueKind::PrimOp(prim) => {\n if let PrimOpKind::ValueList = self.primop_kind(prim) {\n return self.primop_reads(prim).len();\n }\n }\n _ => (),\n }\n 1\n }\n\n pub fn value_list_get_n(&self, value: Value, n: usize) -> Option {\n match self.value_kind(value) {\n ValueKind::PrimOp(prim) => {\n if let PrimOpKind::ValueList = self.primop_kind(prim) {\n let reads = self.primop_reads(prim);\n return reads.get(n).cloned();\n }\n }\n _ => (),\n }\n\n if n == 0 {\n Some(value)\n } else {\n None\n }\n }\n\n /// If the value is a variable, get its definition block and argument position\n pub fn value_argument(&self, value: Value) -> Option<(Block, usize)> {\n if let ValueKind::Argument(block, arg) = self.values[value].kind {\n Some((block, arg))\n } else {\n None\n }\n }\n\n pub fn value_block(&self, value: Value) -> Option {\n if let ValueKind::Block(block) = self.values[value].kind {\n Some(block)\n } else {\n None\n }\n }\n\n pub fn value_const(&self, value: Value) -> Option {\n if let ValueKind::Const(con) = &self.values[value].kind {\n Some(*con)\n } else {\n None\n }\n }\n\n pub fn value_primop(&self, value: Value) -> Option {\n if let ValueKind::PrimOp(prim) = &self.values[value].kind {\n Some(*prim)\n } else {\n None\n }\n }\n\n pub fn value_usages(&self, value: Value) -> BoundSet {\n self.values[value].usages.bind(&self.pool.block_set, &())\n }\n\n /// Walks all nested values contained within\n /// the tree of potential PrimOps.\n pub fn value_walk_nested_values(&self, value: Value, visit: &mut F) -> Result<(), R>\n where\n F: FnMut(Value) -> Result<(), R>,\n {\n visit(value)?;\n if let ValueKind::PrimOp(primop) = self.values[value].kind {\n self.primop_walk_nested_values(primop, visit)?;\n }\n Ok(())\n }\n pub fn value_walk_nested_values_mut(\n &mut self,\n value: Value,\n visit: &mut F,\n ) -> Result<(), R>\n where\n F: FnMut(&mut Function, Value) -> Result<(), R>,\n {\n visit(self, value)?;\n if let ValueKind::PrimOp(primop) = self.values[value].kind {\n self.primop_walk_nested_values_mut(primop, visit)?;\n }\n Ok(())\n }\n}\n\n/// PrimOps\nimpl Function {\n pub fn primop_kind(&self, primop: PrimOp) -> &PrimOpKind {\n &self.primops[primop].op\n }\n pub fn primop_reads(&self, primop: PrimOp) -> &[Value] {\n &self.primops[primop].reads.as_slice(&self.pool.value)\n }\n\n pub fn primop_walk_nested_values(&self, primop: PrimOp, visit: &mut F) -> Result<(), R>\n where\n F: FnMut(Value) -> Result<(), R>,\n {\n let data = &self.primops[primop];\n for read in data.reads.as_slice(&self.pool.value) {\n self.value_walk_nested_values(*read, visit)?;\n }\n Ok(())\n }\n\n pub fn primop_walk_nested_values_mut(\n &mut self,\n primop: PrimOp,\n visit: &mut F,\n ) -> Result<(), R>\n where\n F: FnMut(&mut Function, Value) -> Result<(), R>,\n {\n let len = self.primops[primop].reads.as_slice(&self.pool.value).len();\n for n in 0..len {\n let read = self.primops[primop].reads.as_slice(&self.pool.value)[n];\n self.value_walk_nested_values_mut(read, visit)?;\n }\n Ok(())\n }\n}\n\n/// Blocks\nimpl Function {\n #[inline(always)]\n fn block_insert(&mut self) -> Block {\n self.block_insert_with_span(None)\n }\n\n fn block_insert_with_span(&mut self, span: Option) -> Block {\n let location = span\n .map(|s| self.locations.location(None, None, None, None, s))\n .unwrap_or_else(|| self.locations.location_empty());\n let block = self.blocks.push(BlockData {\n arguments: EntityList::new(),\n\n op: None,\n reads: EntityList::new(),\n\n predecessors: Set::new(),\n successors: Set::new(),\n\n location,\n });\n self.values.push(ValueKind::Block(block));\n block\n }\n\n fn block_arg_insert(&mut self, block: Block) -> Value {\n let arg_num = self.blocks[block].arguments.len(&self.pool.value);\n let val = self.values.push(ValueKind::Argument(block, arg_num));\n self.blocks[block].arguments.push(val, &mut self.pool.value);\n val\n }\n\n pub fn block_arg_n(&self, block: Block, num: usize) -> Option {\n self.blocks[block].arguments.get(num, &self.pool.value)\n }\n\n pub fn block_kind(&self, block: Block) -> Option<&OpKind> {\n self.blocks[block].op.as_ref()\n }\n\n pub fn block_location(&self, block: Block) -> Location {\n self.blocks[block].location\n }\n\n pub fn block_locations(&self, block: Block) -> Vec {\n let loc = self.blocks[block].location;\n self.locations.lookup(&loc)\n }\n\n pub fn block_entry(&self) -> Block {\n self.entry_block.expect(\"Entry block not set on function\")\n }\n pub fn block_args(&self, block: B) -> &[Value]\n where\n B: Into,\n {\n let block: Block = block.into();\n self.blocks[block].arguments.as_slice(&self.pool.value)\n }\n\n pub fn block_reads(&self, block: Block) -> &[Value] {\n self.blocks[block].reads.as_slice(&self.pool.value)\n }\n\n pub fn block_value(&self, block: Block) -> Value {\n self.values.get(ValueKind::Block(block)).unwrap()\n }\n\n pub fn block_walk_nested_values(&self, block: Block, visit: &mut F) -> Result<(), R>\n where\n F: FnMut(Value) -> Result<(), R>,\n {\n let reads_len = self.blocks[block].reads.as_slice(&self.pool.value).len();\n for n in 0..reads_len {\n let read = self.blocks[block].reads.get(n, &self.pool.value).unwrap();\n self.value_walk_nested_values(read, visit)?;\n }\n Ok(())\n }\n pub fn block_walk_nested_values_mut(\n &mut self,\n block: Block,\n visit: &mut F,\n ) -> Result<(), R>\n where\n F: FnMut(&mut Function, Value) -> Result<(), R>,\n {\n let reads_len = self.blocks[block].reads.as_slice(&self.pool.value).len();\n for n in 0..reads_len {\n let read = self.blocks[block].reads.get(n, &self.pool.value).unwrap();\n self.value_walk_nested_values_mut(read, visit)?;\n }\n Ok(())\n }\n\n pub fn block_op_eq(&self, lb: Block, r_fun: &Function, rb: Block) -> bool {\n match (self.block_kind(lb).unwrap(), r_fun.block_kind(rb).unwrap()) {\n (OpKind::Call(l), OpKind::Call(r)) => l == r,\n (OpKind::IfBool, OpKind::IfBool) => true,\n (OpKind::Dyn(l), OpKind::Dyn(r)) => l.op_eq(&**r),\n (OpKind::TraceCaptureRaw, OpKind::TraceCaptureRaw) => true,\n (OpKind::TraceConstruct, OpKind::TraceConstruct) => true,\n (OpKind::MapPut { action: a1 }, OpKind::MapPut { action: a2 }) if a1 == a2 => true,\n (OpKind::UnpackValueList(n1), OpKind::UnpackValueList(n2)) if n1 == n2 => true,\n (OpKind::Match { branches: b1 }, OpKind::Match { branches: b2 }) if b1 == b2 => true,\n (OpKind::Unreachable, OpKind::Unreachable) => true,\n _ => false,\n }\n }\n\n // Iterates through ALL blocks in the function container\n pub fn block_iter(&self) -> impl Iterator {\n self.blocks.keys()\n }\n}\n\n/// Graph\nimpl Function {\n /// Validates graph invariants for the block.\n /// Relatively inexpensive, for debug assertions.\n pub(crate) fn graph_validate_block(&self, block: Block) {\n let block_data = &self.blocks[block];\n\n let mut successors_set = HashSet::new();\n self.block_walk_nested_values::<_, ()>(block, &mut |val| {\n if let ValueKind::Block(succ_block) = self.value_kind(val) {\n assert!(block_data\n .successors\n .contains(succ_block, &self.pool.block_set, &()));\n assert!(self.blocks[succ_block].predecessors.contains(\n block,\n &self.pool.block_set,\n &()\n ));\n successors_set.insert(succ_block);\n }\n Ok(())\n })\n .unwrap();\n\n assert!(block_data.successors.iter(&self.pool.block_set).count() == successors_set.len());\n }\n\n /// Validates graph invariants globally, for the whole\n /// function.\n /// Relatively expensive. Should only be used in tests.\n pub fn graph_validate_global(&self) {\n for block in self.blocks.keys() {\n self.graph_validate_block(block);\n }\n }\n}\n\npub trait GeneralSet {\n fn contains(&self, key: &V, fun: &Function) -> bool;\n fn insert(&mut self, key: V, fun: &mut Function) -> bool;\n}\nimpl GeneralSet for HashSet\nwhere\n V: Hash + Eq,\n{\n fn contains(&self, key: &V, _fun: &Function) -> bool {\n HashSet::contains(self, key)\n }\n fn insert(&mut self, key: V, _fun: &mut Function) -> bool {\n HashSet::insert(self, key)\n }\n}\nimpl GeneralSet for Set\nwhere\n V: Copy + Ord + SetPoolProvider,\n{\n fn contains(&self, key: &V, fun: &Function) -> bool {\n Set::contains(self, *key, V::pool(fun), &())\n }\n fn insert(&mut self, key: V, fun: &mut Function) -> bool {\n Set::insert(self, key, V::pool_mut(fun), &())\n }\n}\n\npub trait SetPoolProvider: Sized + Copy {\n fn pool(fun: &Function) -> &SetForest;\n fn pool_mut(fun: &mut Function) -> &mut SetForest;\n}\nimpl SetPoolProvider for Block {\n fn pool(fun: &Function) -> &SetForest {\n &fun.pool.block_set\n }\n fn pool_mut(fun: &mut Function) -> &mut SetForest {\n &mut fun.pool.block_set\n }\n}\n\nimpl Function {\n pub fn new(span: SourceSpan, ident: FunctionIdent) -> Self {\n Function {\n ident,\n span,\n\n dialect: crate::dialect::NORMAL.clone(),\n\n blocks: PrimaryMap::new(),\n values: ValueMap::new(),\n primops: DedupAuxPrimaryMap::new(),\n\n entry_block: None,\n\n pool: PoolContainer {\n value: ListPool::new(),\n block_set: SetForest::new(),\n },\n\n constant_container: ConstantContainer::new(),\n\n constant_values: HashSet::new(),\n\n locations: LocationContainer::new(),\n }\n }\n\n pub fn ident(&self) -> &FunctionIdent {\n &self.ident\n }\n\n pub fn entry_arg_num(&self) -> usize {\n self.block_args(self.block_entry()).len()\n }\n}\n" }, { "path": "libeir_ir/src/function/op.rs", "content": "use crate::binary::BinaryEntrySpecifier;\nuse crate::operation::{DynOp, Op};\n\nuse serde::{Deserialize, Serialize};\n\n#[derive(Debug, Copy, Clone, PartialEq, Eq, Serialize, Deserialize)]\npub enum CallKind {\n /// Control flow includes flow within a function and calls to\n /// escape values.\n ControlFlow,\n /// Call to a function, should generate a stack frame.\n /// The first two arguments MUST be the return and throw\n /// continuations respectively.\n Function,\n}\n\n#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]\npub enum BasicType {\n // Contains both ListCell and Nil\n List,\n ListCell,\n Nil,\n\n /// Arity is part of the type\n Tuple(usize),\n\n Map,\n\n /// Contains both Float and Integer\n Number,\n Float,\n /// Contains both SmallInt and BigInt\n Integer,\n SmallInteger,\n BigInteger,\n}\n\n#[derive(Debug, Copy, Clone, PartialEq, Eq, Serialize, Deserialize)]\npub enum MatchKind {\n /// One read, the value to test it against\n /// No arguments.\n Value,\n /// No reads.\n /// No writes.\n Type(BasicType),\n /// One optional read, the size.\n /// Two arguments, the decoded value, and the tail.\n Binary(BinaryEntrySpecifier),\n /// No reads.\n /// N arguments, the unpacked values.\n Tuple(usize),\n /// No reads.\n /// Two arguments, the head and the tail.\n ListCell,\n /// One read, the key.\n /// One argument, the value.\n MapItem,\n /// No reads.\n /// No arguments.\n Wildcard,\n}\n\n#[derive(Debug, Copy, Clone, PartialEq, Eq, Serialize, Deserialize)]\npub enum MapPutUpdate {\n /// Value is put into map, regardless of already existing\n Put,\n /// Value is updated, fails if not in map\n Update,\n}\n\n#[derive(Debug, Clone)]\npub enum OpKind {\n // Control flow/functions\n /// (call: fn(..), ..)\n /// This is the calling primitive,\n /// doing everything from returns to local calls,\n /// to external calls.\n Call(CallKind),\n\n /// (true: fn(), false: fn(), else: fn(), value)\n /// (true: fn(), false: fn(), value) implies else is unreachable\n /// Strict truth check, only 'true' is true, 'false' is false\n IfBool,\n\n // Stack traces\n /// This captures the current stack trace.\n /// Returns an implementation specific value that can only be\n /// used with `TraceConstruct`. Can not be exposed to the user\n /// or used with any other operation.\n TraceCaptureRaw,\n /// This gets the stack trace from a raw trace.\n TraceConstruct,\n\n /// (ok: fn(new_map), err: fn(), map: map, keys: (keys..), values: (value..))\n /// Puts a new value in the map, replacing the old key\n /// if it exists.\n MapPut {\n // TODO: don't do allocation\n action: Vec,\n },\n\n /// (cont: fn(terms..), l: valuelist)\n /// Value lists are not an actual type in the program.\n /// A value list of length 1 is semantically identical\n /// to the value itself.\n /// A value list may only exist as a SSA value directly,\n /// no other types may contain a value list. Value lists\n /// may not contain value lists.\n ///\n /// A value list of length 0 may be used as a empty set\n /// value. It may not be used in any reads, except a\n /// UnpackValueList with no writes.\n ///\n /// Only high level Eur may contain value lists. Codegen\n /// should not be concerned with these operations.\n UnpackValueList(usize),\n\n /// Match on a single value.\n /// Branches are tested in order, first matched is branched to.\n /// ```ignore\n /// (\n /// branches: (fn(..), ..),\n /// value: term,\n /// branch1_args: (..),\n /// ..\n /// )\n /// ```\n Match {\n branches: Vec,\n },\n\n /// ()\n /// Something that should not happen. The VM could be left in an\n /// invalid state, should raise an unrecoverable runtime error.\n Unreachable,\n\n Dyn(DynOp),\n}\n\nimpl OpKind {\n pub fn is_call(&self) -> bool {\n match self {\n OpKind::Call(_) => true,\n _ => false,\n }\n }\n\n pub fn get_dyn(&self) -> Option<&O> {\n match self {\n OpKind::Dyn(d) => d.downcast_ref(),\n _ => None,\n }\n }\n}\n" }, { "path": "libeir_ir/src/function/pool_container.rs", "content": "use cranelift_bforest::SetForest;\nuse cranelift_entity::ListPool;\n\nuse super::{Block, Value};\n\n#[derive(Clone)]\npub struct PoolContainer {\n pub value: ListPool,\n pub block_set: SetForest,\n}\n" }, { "path": "libeir_ir/src/function/primop.rs", "content": "use serde::{Deserialize, Serialize};\n\n#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]\npub enum BinOp {\n /// ==\n Equal,\n /// /=\n NotEqual,\n /// =<\n LessEqual,\n /// <\n Less,\n /// >=\n GreaterEqual,\n /// >\n Greater,\n /// =:=\n ExactEqual,\n /// =/=\n ExactNotEqual,\n}\nimpl BinOp {\n pub fn symmetric(self) -> bool {\n match self {\n BinOp::Equal => true,\n BinOp::NotEqual => true,\n BinOp::ExactEqual => true,\n BinOp::ExactNotEqual => true,\n _ => false,\n }\n }\n}\n\n#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]\npub enum LogicOp {\n /// All arguments are equal\n Eq,\n And,\n Or,\n}\n\n#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]\npub enum PrimOpKind {\n /// Corresponds the eir_intrinsics:type_tag.\n /// Required to be eliminated before lowering.\n /// TODO: Document returns\n /// (value)\n TypeTag,\n\n /// (value)\n IsType(super::op::BasicType),\n\n /// (lhs, rhs)\n BinOp(BinOp),\n\n /// (terms..)\n LogicOp(LogicOp),\n\n /// (terms..)\n Tuple,\n\n /// (head, tail)\n ListCell,\n\n /// (k1, v1, ... kn, vn)\n Map,\n\n /// (terms..)\n ValueList,\n\n /// Returns a function of arity `a`.\n /// If the function does not exists, this must return a function that\n /// throws badarg when called.\n /// For function capture semantics, the `CaptureFunction` op should be\n /// used instead. This will throw badarg at capture time.\n /// `(m, f, a)`\n CaptureFunction,\n}\n" }, { "path": "libeir_ir/src/function/serialize.rs", "content": "use super::Function;\n\nuse serde::{ Serialize, Serializer, Deserialize };\n\nimpl Serialize for Function {\n fn serialize(&self, serializer: S) -> Result\n where\n S: Serializer,\n {\n let mut value_n = 0;\n let mut block_n = 0;\n }\n}\n" }, { "path": "libeir_ir/src/function/value.rs", "content": "use std::collections::HashMap;\nuse std::ops::{Index, IndexMut};\n\nuse super::{Block, Const, Location, PrimOp};\nuse cranelift_bforest::Set;\nuse cranelift_entity::packed_option::ReservedValue;\nuse cranelift_entity::{entity_impl, PrimaryMap};\nuse libeir_util_datastructures::aux_traits::AuxDebug;\n\n#[derive(Copy, Clone, Hash, PartialEq, Eq, PartialOrd, Ord)]\npub struct Value(u32);\nentity_impl!(Value, \"value\");\nimpl Default for Value {\n fn default() -> Self {\n Value::reserved_value()\n }\n}\nimpl AuxDebug for Value {\n fn aux_fmt(&self, f: &mut std::fmt::Formatter<'_>, _aux: &C) -> std::fmt::Result {\n std::fmt::Debug::fmt(self, f)\n }\n}\n\nuse libeir_util_dot_graph::NodeId;\nimpl NodeId for Value {\n fn make_id(&self, out: &mut String) {\n use std::fmt::Write;\n write!(out, \"{}\", self).unwrap();\n }\n}\n\n#[derive(Clone)]\npub struct ValueData {\n pub(crate) kind: ValueKind,\n pub(crate) location: Option,\n pub(crate) usages: Set,\n}\n\n#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]\npub enum ValueKind {\n Argument(Block, usize),\n Block(Block),\n Const(Const),\n PrimOp(PrimOp),\n}\n\nimpl ValueKind {\n pub fn is_arg(&self) -> bool {\n match self {\n ValueKind::Argument(_, _) => true,\n _ => false,\n }\n }\n}\n\n#[derive(Clone)]\npub struct ValueMap {\n primary: PrimaryMap,\n back: HashMap,\n}\n\nimpl ValueMap {\n pub fn new() -> Self {\n ValueMap {\n primary: PrimaryMap::new(),\n back: HashMap::new(),\n }\n }\n\n pub fn push(&mut self, kind: ValueKind) -> Value {\n self.push_with_location(kind, None)\n }\n\n pub fn push_with_location(&mut self, kind: ValueKind, location: Option) -> Value {\n if let Some(key) = self.back.get(&kind) {\n *key\n } else {\n let val = self.primary.push(ValueData {\n kind,\n location,\n usages: Set::new(),\n });\n self.back.insert(kind, val);\n val\n }\n }\n\n pub fn get(&self, kind: ValueKind) -> Option {\n self.back.get(&kind).cloned()\n }\n}\n\nimpl Index for ValueMap {\n type Output = ValueData;\n fn index(&self, key: Value) -> &ValueData {\n &self.primary[key]\n }\n}\nimpl IndexMut for ValueMap {\n fn index_mut(&mut self, key: Value) -> &mut ValueData {\n &mut self.primary[key]\n }\n}\n" }, { "path": "libeir_ir/src/graph/block_graph.rs", "content": "use petgraph::visit::{Dfs, DfsPostOrder};\nuse petgraph::visit::{\n GraphBase, IntoNeighbors, IntoNeighborsDirected, VisitMap, Visitable, Walker,\n};\nuse petgraph::Direction;\n\nuse cranelift_entity::{EntityRef, EntitySet};\n\nuse itertools::Either;\n\nuse cranelift_bforest::SetIter;\n\nuse crate::Block;\nuse crate::Function;\n\nimpl Function {\n pub fn block_graph(&self) -> BlockGraph<'_> {\n BlockGraph::new(self)\n }\n}\n\n/// This is a newtype that contains implementations of petgraphs graph traits.\n///\n/// The semantics of the below graph are as follows:\n/// - Nodes are blocks\n/// - Block capture values in blocks are edges\n/// - Back edges exist to non-live blocks\n///\n/// The last point may cause some graph algorithms to produce undesirable results.\n/// `LiveBlockGraph` does not have this feature, but is slightly more expensive to\n/// construct.\npub struct BlockGraph<'a> {\n pub(crate) fun: &'a Function,\n}\n\nimpl<'a> BlockGraph<'a> {\n pub fn new(fun: &'a Function) -> Self {\n BlockGraph { fun }\n }\n\n pub fn dfs(&self) -> Dfs> {\n Dfs::new(self, self.fun.block_entry())\n }\n\n pub fn dfs_iter(&'a self) -> impl Iterator + 'a {\n self.dfs().iter(self)\n }\n\n pub fn dfs_post_order(&self) -> DfsPostOrder> {\n DfsPostOrder::new(self, self.fun.block_entry())\n }\n\n pub fn dfs_post_order_iter(&'a self) -> impl Iterator + 'a {\n self.dfs_post_order().iter(self)\n }\n\n pub fn outgoing(&'a self, block: Block) -> impl Iterator + 'a {\n self.fun.blocks[block]\n .successors\n .iter(&self.fun.pool.block_set)\n }\n}\n\n#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]\npub struct BlockEdge(Block, usize);\n\npub struct BlockSuccessors<'a> {\n iter: SetIter<'a, Block>,\n}\nimpl<'a> Iterator for BlockSuccessors<'a> {\n type Item = Block;\n #[inline]\n fn next(&mut self) -> Option {\n self.iter.next()\n }\n}\n\npub struct BlockPredecessors<'a> {\n iter: SetIter<'a, Block>,\n}\nimpl<'a> BlockPredecessors<'a> {\n fn new(graph: &'a BlockGraph, block: Block) -> Self {\n BlockPredecessors {\n iter: graph.fun.blocks[block]\n .predecessors\n .iter(&graph.fun.pool.block_set),\n }\n }\n}\nimpl<'a> Iterator for BlockPredecessors<'a> {\n type Item = Block;\n #[inline]\n fn next(&mut self) -> Option {\n self.iter.next()\n }\n}\n\nimpl<'a> GraphBase for BlockGraph<'a> {\n type NodeId = Block;\n type EdgeId = BlockEdge;\n}\n\nimpl<'a> IntoNeighbors for &'a BlockGraph<'a> {\n type Neighbors = BlockSuccessors<'a>;\n #[inline]\n fn neighbors(self, block: Block) -> Self::Neighbors {\n BlockSuccessors {\n iter: self.fun.blocks[block]\n .successors\n .iter(&self.fun.pool.block_set),\n }\n }\n}\nimpl<'a> IntoNeighborsDirected for &'a BlockGraph<'a> {\n type NeighborsDirected = Either, BlockPredecessors<'a>>;\n #[inline]\n fn neighbors_directed(self, block: Block, dir: Direction) -> Self::NeighborsDirected {\n match dir {\n Direction::Outgoing => Either::Left(self.neighbors(block)),\n Direction::Incoming => Either::Right(BlockPredecessors::new(self, block)),\n }\n }\n}\n\npub struct EntityVisitMap\nwhere\n E: EntityRef,\n{\n set: EntitySet,\n}\nimpl EntityVisitMap\nwhere\n E: EntityRef,\n{\n pub fn new(size: usize) -> Self {\n let mut set = EntitySet::new();\n set.resize(size);\n EntityVisitMap { set }\n }\n pub fn reset(&mut self, size: usize) {\n self.set.clear();\n self.set.resize(size);\n }\n}\nimpl VisitMap for EntityVisitMap\nwhere\n E: EntityRef,\n{\n #[inline]\n fn visit(&mut self, a: E) -> bool {\n self.set.insert(a)\n }\n #[inline]\n fn is_visited(&self, a: &E) -> bool {\n self.set.contains(*a)\n }\n}\n\nimpl<'a> Visitable for BlockGraph<'a> {\n type Map = EntityVisitMap;\n #[inline]\n fn visit_map(&self) -> EntityVisitMap {\n EntityVisitMap::new(self.fun.blocks.len())\n }\n #[inline]\n fn reset_map(&self, map: &mut EntityVisitMap) {\n map.reset(self.fun.blocks.len());\n }\n}\n\n#[cfg(test)]\nmod tests {\n\n use crate::{Function, FunctionBuilder, FunctionIdent};\n use libeir_diagnostics::SourceSpan;\n use libeir_intern::Ident;\n\n use petgraph::visit::IntoNeighborsDirected;\n use petgraph::Direction;\n\n #[test]\n fn test_edge() {\n let ident = FunctionIdent {\n module: Ident::from_str(\"woo\"),\n name: Ident::from_str(\"woo\"),\n arity: 1,\n };\n let mut fun = Function::new(SourceSpan::UNKNOWN, ident);\n let mut b = FunctionBuilder::new(&mut fun);\n\n let b1 = b.block_insert();\n b.block_set_entry(b1);\n let b1_ret = b.block_arg_insert(b1);\n\n let b2 = b.block_insert();\n\n let b3 = b.block_insert();\n\n b.op_call_flow(b1, b2, &[]);\n b.op_call_flow(b2, b1_ret, &[]);\n b.op_call_flow(b3, b2, &[]);\n\n let graph = b.fun().block_graph();\n\n assert!(\n &graph\n .neighbors_directed(b1, Direction::Outgoing)\n .collect::>()\n == &[b2]\n );\n assert!(\n &graph\n .neighbors_directed(b2, Direction::Outgoing)\n .collect::>()\n == &[]\n );\n assert!(\n &graph\n .neighbors_directed(b3, Direction::Outgoing)\n .collect::>()\n == &[b2]\n );\n assert!(\n &graph\n .neighbors_directed(b1, Direction::Incoming)\n .collect::>()\n == &[]\n );\n assert!(\n &graph\n .neighbors_directed(b2, Direction::Incoming)\n .collect::>()\n == &[b1, b3]\n );\n assert!(\n &graph\n .neighbors_directed(b3, Direction::Incoming)\n .collect::>()\n == &[]\n );\n }\n}\n" }, { "path": "libeir_ir/src/graph/control_flow_graph.rs", "content": "use std::collections::BTreeSet;\n\nuse petgraph::visit::{Dfs, DfsPostOrder};\nuse petgraph::visit::{GraphBase, IntoNeighbors, IntoNeighborsDirected, Visitable, Walker};\nuse petgraph::Direction;\n\nuse cranelift_entity::{EntityList, ListPool, SecondaryMap};\n\nuse itertools::Either;\n\nuse super::block_graph::EntityVisitMap;\nuse crate::Function;\nuse crate::Value;\n\nimpl Function {\n pub fn control_flow_graph(&self) -> ControlFlowGraph {\n ControlFlowGraph::new()\n }\n}\n\n#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]\npub struct CfgBranch(pub usize);\n\n/// This is a newtype that contains implementations of petgraphs graph traits.\n///\n/// The semantics of the below graph are as follows:\n/// - Nodes are values\n/// - Only explicit control flow are graph edges\n#[derive(Debug)]\npub struct ControlFlowGraph {\n entry: Option,\n forward: SecondaryMap>,\n back: SecondaryMap>,\n pool: ListPool,\n}\n\nimpl ControlFlowGraph {\n pub fn new() -> Self {\n ControlFlowGraph {\n entry: None,\n forward: SecondaryMap::new(),\n back: SecondaryMap::new(),\n pool: ListPool::new(),\n }\n }\n\n pub fn calculate(&mut self, fun: &Function, entry: Value) {\n self.entry = Some(entry);\n self.forward.clear();\n self.back.clear();\n self.pool.clear();\n\n let mut to_walk = Vec::new();\n to_walk.push(entry);\n let mut walked = BTreeSet::new();\n\n while let Some(val) = to_walk.pop() {\n if walked.contains(&val) {\n continue;\n }\n walked.insert(val);\n\n if let Some(block) = fun.value_block(val) {\n let forward = &mut self.forward[val];\n for out in fun.op_branch_iter(block) {\n forward.push(out, &mut self.pool);\n self.back[out].push(val, &mut self.pool);\n if !walked.contains(&out) {\n to_walk.push(out);\n }\n }\n }\n }\n }\n\n pub fn dfs(&self) -> Dfs> {\n Dfs::new(self, self.entry.unwrap())\n }\n\n pub fn dfs_iter<'a>(&'a self) -> impl Iterator + 'a {\n self.dfs().iter(self)\n }\n\n pub fn dfs_post_order(&self) -> DfsPostOrder> {\n DfsPostOrder::new(self, self.entry.unwrap())\n }\n\n pub fn dfs_post_order_iter<'a>(&'a self) -> impl Iterator + 'a {\n self.dfs_post_order().iter(self)\n }\n}\n\nimpl GraphBase for ControlFlowGraph {\n type NodeId = Value;\n type EdgeId = CfgBranch;\n}\n\npub struct ControlFlowSuccessors<'a> {\n graph: &'a ControlFlowGraph,\n value: Value,\n curr: usize,\n}\nimpl<'a> Iterator for ControlFlowSuccessors<'a> {\n type Item = Value;\n fn next(&mut self) -> Option {\n if let Some(val) = self.graph.forward[self.value].get(self.curr, &self.graph.pool) {\n self.curr += 1;\n Some(val)\n } else {\n None\n }\n }\n}\n\npub struct ControlFlowPredecessors<'a> {\n graph: &'a ControlFlowGraph,\n value: Value,\n curr: usize,\n}\nimpl<'a> ControlFlowPredecessors<'a> {\n pub fn new(graph: &'a ControlFlowGraph, value: Value) -> Self {\n ControlFlowPredecessors {\n graph,\n value,\n curr: 0,\n }\n }\n}\nimpl<'a> Iterator for ControlFlowPredecessors<'a> {\n type Item = Value;\n fn next(&mut self) -> Option {\n if let Some(val) = self.graph.back[self.value].get(self.curr, &self.graph.pool) {\n self.curr += 1;\n Some(val)\n } else {\n None\n }\n }\n}\n\nimpl<'a> IntoNeighbors for &'a ControlFlowGraph {\n type Neighbors = ControlFlowSuccessors<'a>;\n fn neighbors(self, value: Value) -> Self::Neighbors {\n ControlFlowSuccessors {\n graph: self,\n value,\n curr: 0,\n }\n }\n}\nimpl<'a> IntoNeighborsDirected for &'a ControlFlowGraph {\n type NeighborsDirected = Either, ControlFlowPredecessors<'a>>;\n fn neighbors_directed(self, value: Value, dir: Direction) -> Self::NeighborsDirected {\n match dir {\n Direction::Outgoing => Either::Left(self.neighbors(value)),\n Direction::Incoming => Either::Right(ControlFlowPredecessors::new(self, value)),\n }\n }\n}\n\nimpl<'a> Visitable for ControlFlowGraph {\n type Map = EntityVisitMap;\n #[inline]\n fn visit_map(&self) -> EntityVisitMap {\n EntityVisitMap::new(self.forward.capacity())\n }\n #[inline]\n fn reset_map(&self, map: &mut EntityVisitMap) {\n map.reset(self.forward.capacity());\n }\n}\n" }, { "path": "libeir_ir/src/graph/live_block_graph.rs", "content": "use std::collections::HashSet;\n\nuse petgraph::visit::{Dfs, DfsPostOrder};\nuse petgraph::visit::{\n GraphBase, IntoNeighbors, IntoNeighborsDirected, IntoNodeIdentifiers, Visitable,\n};\nuse petgraph::Direction;\n\nuse itertools::Either;\n\nuse cranelift_bforest::SetIter;\n\nuse crate::Block;\nuse crate::Function;\n\nuse super::block_graph::EntityVisitMap;\nuse super::block_graph::{BlockEdge, BlockSuccessors};\nuse super::BlockGraph;\n\nimpl Function {\n pub fn live_block_graph(&self) -> LiveBlockGraph<'_> {\n LiveBlockGraph::new(self)\n }\n}\n\n/// This is a newtype that contains implementations of petgraphs graph traits.\n///\n/// This has identical semantics to `BlockGraph`, with the following difference:\n/// - Back edges do not exist to non-live blocks\n///\n/// If back edges to non-live blocks are acceptable, it is recommended to use\n/// `BlockGraph` instead.\npub struct LiveBlockGraph<'a> {\n pub graph: BlockGraph<'a>,\n pub live: HashSet,\n}\n\nimpl<'a> LiveBlockGraph<'a> {\n pub fn new(fun: &'a Function) -> Self {\n let graph = fun.block_graph();\n\n let mut live = HashSet::new();\n for block in graph.dfs_iter() {\n live.insert(block);\n }\n\n LiveBlockGraph { graph, live }\n }\n\n pub fn dfs(&self) -> Dfs> {\n self.graph.dfs()\n }\n pub fn dfs_iter(&'a self) -> impl Iterator + 'a {\n self.graph.dfs_iter()\n }\n\n pub fn dfs_post_order(&self) -> DfsPostOrder> {\n self.graph.dfs_post_order()\n }\n pub fn dfs_post_order_iter(&'a self) -> impl Iterator + 'a {\n self.graph.dfs_post_order_iter()\n }\n\n pub fn outgoing(&'a self, block: Block) -> impl Iterator + 'a {\n self.graph.outgoing(block)\n }\n\n pub fn incoming(&'a self, block: Block) -> impl Iterator + 'a {\n self.graph.fun.blocks[block]\n .predecessors\n .iter(&self.graph.fun.pool.block_set)\n .filter(move |b| self.live.contains(b))\n }\n}\n\npub struct LiveBlockPredecessors<'a> {\n graph: &'a LiveBlockGraph<'a>,\n iter: SetIter<'a, Block>,\n}\nimpl<'a> LiveBlockPredecessors<'a> {\n fn new(graph: &'a LiveBlockGraph, block: Block) -> Self {\n LiveBlockPredecessors {\n graph,\n iter: graph.graph.fun.blocks[block]\n .predecessors\n .iter(&graph.graph.fun.pool.block_set),\n }\n }\n}\nimpl<'a> Iterator for LiveBlockPredecessors<'a> {\n type Item = Block;\n #[inline]\n fn next(&mut self) -> Option {\n while let Some(block) = self.iter.next() {\n if self.graph.live.contains(&block) {\n return Some(block);\n }\n }\n None\n }\n}\n\nimpl<'a> GraphBase for LiveBlockGraph<'a> {\n type NodeId = Block;\n type EdgeId = BlockEdge;\n}\n\nimpl<'a> IntoNeighbors for &'a LiveBlockGraph<'a> {\n type Neighbors = BlockSuccessors<'a>;\n #[inline]\n fn neighbors(self, block: Block) -> Self::Neighbors {\n self.graph.neighbors(block)\n }\n}\n\nimpl<'a> IntoNeighborsDirected for &'a LiveBlockGraph<'a> {\n type NeighborsDirected = Either, LiveBlockPredecessors<'a>>;\n #[inline]\n fn neighbors_directed(self, block: Block, dir: Direction) -> Self::NeighborsDirected {\n match dir {\n Direction::Outgoing => Either::Left(self.graph.neighbors(block)),\n Direction::Incoming => Either::Right(LiveBlockPredecessors::new(self, block)),\n }\n }\n}\n\nimpl<'a> Visitable for &'a LiveBlockGraph<'a> {\n type Map = EntityVisitMap;\n #[inline]\n fn visit_map(&self) -> EntityVisitMap {\n Visitable::visit_map(&self.graph)\n }\n #[inline]\n fn reset_map(&self, map: &mut EntityVisitMap) {\n Visitable::reset_map(&self.graph, map)\n }\n}\n\npub struct NodeIterator(Vec, usize);\nimpl Iterator for NodeIterator {\n type Item = Block;\n fn next(&mut self) -> Option {\n let val = self.0.get(self.1).cloned();\n self.1 += 1;\n val\n }\n}\n\nimpl<'a> IntoNodeIdentifiers for &'a LiveBlockGraph<'a> {\n type NodeIdentifiers = NodeIterator;\n fn node_identifiers(self) -> Self::NodeIdentifiers {\n let live = self.live.iter().cloned().collect::>();\n NodeIterator(live, 0)\n }\n}\n\n#[cfg(test)]\nmod tests {\n\n use crate::{Function, FunctionBuilder, FunctionIdent};\n use libeir_diagnostics::SourceSpan;\n use libeir_intern::Ident;\n\n use petgraph::visit::IntoNeighborsDirected;\n use petgraph::Direction;\n\n #[test]\n fn test_back_edge() {\n let ident = FunctionIdent {\n module: Ident::from_str(\"woo\"),\n name: Ident::from_str(\"woo\"),\n arity: 1,\n };\n let mut fun = Function::new(SourceSpan::UNKNOWN, ident);\n let mut b = FunctionBuilder::new(&mut fun);\n\n let b1 = b.block_insert();\n b.block_set_entry(b1);\n let b1_ret = b.block_arg_insert(b1);\n\n let b2 = b.block_insert();\n\n let b3 = b.block_insert();\n\n b.op_call_flow(b1, b2, &[]);\n b.op_call_flow(b2, b1_ret, &[]);\n b.op_call_flow(b3, b2, &[]);\n\n let graph = b.fun().live_block_graph();\n\n assert!(\n &graph\n .neighbors_directed(b1, Direction::Outgoing)\n .collect::>()\n == &[b2]\n );\n assert!(\n &graph\n .neighbors_directed(b2, Direction::Outgoing)\n .collect::>()\n == &[]\n );\n assert!(\n &graph\n .neighbors_directed(b3, Direction::Outgoing)\n .collect::>()\n == &[b2]\n );\n assert!(\n &graph\n .neighbors_directed(b1, Direction::Incoming)\n .collect::>()\n == &[]\n );\n assert!(\n &graph\n .neighbors_directed(b2, Direction::Incoming)\n .collect::>()\n == &[b1]\n );\n assert!(\n &graph\n .neighbors_directed(b3, Direction::Incoming)\n .collect::>()\n == &[]\n );\n }\n}\n" }, { "path": "libeir_ir/src/graph/mod.rs", "content": "pub use petgraph::visit::IntoNeighborsDirected;\npub use petgraph::Direction;\n\nmod block_graph;\npub use block_graph::{BlockGraph, EntityVisitMap};\n\nmod live_block_graph;\npub use live_block_graph::LiveBlockGraph;\n\nmod control_flow_graph;\npub use control_flow_graph::ControlFlowGraph;\n" }, { "path": "libeir_ir/src/ir_construct_macro.rs", "content": "#![allow(unused_macros)]\n\nmacro_rules! build_ir {\n ($module:ident : $name:ident / $arity:expr => $body:tt) => {\n #[allow(unused_variables, unused_mut, unused_assignments, redundant_semicolon)]\n {\n use libeir_intern::Ident;\n\n let ident = $crate::FunctionIdent {\n module: Ident::from_str(std::stringify!($module).into()),\n name: Ident::from_str(std::stringify!($name).into()),\n arity: $arity,\n };\n\n let mut fun = $crate::Function::new(ident);\n\n {\n let mut b = fun.builder();\n build_ir!(INTERNAL_MACRO; BLOCKS; &mut b; $body);\n }\n\n fun\n }\n };\n\n (INTERNAL_MACRO; BLOCKS; $b:expr; { $(\n $block_name:ident ( $($block_arg:ident),* ) {\n $(\n $($body_item:tt)*;\n )*\n };\n )* }) => {\n {\n use std::stringify;\n use std::collections::HashMap;\n use $crate::{Block, Value};\n\n let mut b = $b;\n let mut entry = None;\n\n let mut block_map: HashMap<&'static str, Block> =\n HashMap::new();\n let mut value_map: HashMap<&'static str, Value> =\n HashMap::new();\n\n // First pass, create blocks and arguments\n $(\n let block_name = stringify!($block_name);\n\n let block = b.block_insert();\n if entry.is_none() {\n entry = Some(block);\n }\n\n assert!(!value_map.contains_key(&block_name));\n block_map.insert(block_name, block);\n value_map.insert(block_name, b.value(block));\n\n $(\n let arg_name = stringify!($block_arg);\n let arg_value = b.block_arg_insert(block);\n assert!(!value_map.contains_key(&arg_name));\n value_map.insert(arg_name, arg_value);\n )*;\n\n )*;\n\n // Second pass, create primops, constants and bodies\n $(\n let block_name = stringify!($block_name);\n let block = block_map[block_name];\n\n $(\n build_ir!(INTERNAL_MACRO; BLOCK_ITEM; $b; value_map; block;\n $($body_item_part)*);\n )*;\n )*;\n\n }\n };\n\n (INTERNAL_MACRO; BLOCK_ITEM; $b:expr; $value_map:expr; $block:expr;\n $var_name:ident = $($var_tts:tt)*) => {\n };\n\n (INTERNAL_MACRO; BLOCK_ITEM; $b:expr; $value_map:expr; $block:expr;\n call $call_name:ident ( $($call_arg:ident),* )) => {\n {\n let call_dest = build_ir!(\n INTERNAL_MACRO; VALUE; $value_map; $call_name);\n let call_args = &[$(build_ir!(\n INTERNAL_MACRO; VALUE; $value_map; $call_arg)),*];\n\n $b.op_call($block, call_dest, call_args);\n }\n };\n\n (INTERNAL_MACRO; VALUE; $value_map:expr; $value_name:ident) => {\n {\n let value_name = stringify!($value_name);\n *$value_map.get(value_name).unwrap()\n }\n };\n}\n\n#[cfg(test)]\nmod tests {\n\n #[test]\n fn basic_ir_build() {\n\n build_ir!(\n test:test/0 => {\n b_entry(ret, exc) {\n call b_1(c_true);\n };\n b_1() {\n call ret(b_1);\n };\n }\n );\n\n }\n\n\n}\n" }, { "path": "libeir_ir/src/lib.rs", "content": "#![feature(specialization, raw, allocator_api)]\n//#![deny(warnings)]\n\nuse std::cmp::Ordering;\nuse std::fmt::{Display, Formatter};\n\nuse libeir_intern::Ident;\n\nmod function;\n\nmod dialect;\npub use dialect::{ArcDialect, Dialect};\n\npub mod operation;\n\npub mod traits;\n\n// Auxiliary utilities\nmod algo;\npub use algo::equality::GraphEqOptions;\npub use algo::func_tree::{FunctionEntry, FunctionTree};\npub use algo::live::LiveValues;\npub use algo::mangle::{MangleFrom, MangleTarget, MangleTo, Mangler};\npub use algo::validate::ValidationError;\n\npub mod text;\n\npub mod graph;\npub use graph::LiveBlockGraph;\n\n// Subcontainers\npub mod constant;\npub mod pattern;\n\npub use function::ValueKind;\npub use function::{AttributeKey, AttributeValue};\npub use function::{\n BasicType, BinOp, CallKind, LogicOp, MapPutUpdate, MatchKind, OpKind, PrimOpKind,\n};\npub use function::{Block, Function, Location, PrimOp, Value};\npub use function::{ContainerDebug, ContainerDebugAdapter};\n\npub use function::builder::{DynValue, FunctionBuilder, IntoValue};\n\npub use constant::EmptyMap;\npub use constant::{AtomTerm, BigIntTerm, BinaryTerm, FloatTerm, IntTerm, NilTerm};\npub use constant::{AtomicTerm, Const, ConstKind, ConstantContainer};\npub use constant::{FromPrimitive, Integer, ToPrimitive};\n\npub use pattern::{PatternClause, PatternContainer, PatternNode, PatternValue};\n\npub use text::printer::{FormatConfig, StandardFormatConfig};\npub use text::{\n parse_function, parse_function_map, parse_function_map_unwrap, parse_function_unwrap,\n parse_module, parse_module_unwrap,\n};\n\npub mod binary;\npub use binary::{BinaryEntrySpecifier, Endianness};\n\nmod module;\npub use module::{FunctionDefinition, FunctionIndex, Module};\n\n#[derive(Debug, Copy, Clone, Hash, Eq, PartialEq, PartialOrd)]\npub struct FunctionIdent {\n pub module: Ident,\n pub name: Ident,\n pub arity: usize,\n}\nimpl Ord for FunctionIdent {\n fn cmp(&self, other: &FunctionIdent) -> Ordering {\n self.partial_cmp(other).unwrap()\n }\n}\nimpl Display for FunctionIdent {\n fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {\n write!(f, \"{}:{}/{}\", self.module, self.name, self.arity)\n }\n}\n" }, { "path": "libeir_ir/src/module.rs", "content": "use std::collections::BTreeMap;\nuse std::ops::{Index, IndexMut};\n\nuse cranelift_entity::{entity_impl, PrimaryMap};\n\nuse crate::{Function, FunctionIdent};\nuse libeir_diagnostics::SourceSpan;\nuse libeir_intern::{Ident, Symbol};\n\npub struct FunctionDefinition {\n index: FunctionIndex,\n fun: Function,\n}\nimpl FunctionDefinition {\n pub fn index(&self) -> FunctionIndex {\n self.index\n }\n\n pub fn function(&self) -> &Function {\n &self.fun\n }\n\n pub fn function_mut(&mut self) -> &mut Function {\n &mut self.fun\n }\n}\n\n#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]\npub struct FunctionIndex(u32);\nentity_impl!(FunctionIndex, \"function_index\");\n\npub struct Module {\n name: Ident,\n span: SourceSpan,\n functions: PrimaryMap,\n name_map: BTreeMap<(Symbol, usize), FunctionIndex>,\n}\nimpl Module {\n pub fn new(name: Ident) -> Self {\n Self {\n name,\n span: SourceSpan::UNKNOWN,\n functions: PrimaryMap::new(),\n name_map: BTreeMap::new(),\n }\n }\n\n pub fn new_with_span(name: Ident, span: SourceSpan) -> Self {\n Self {\n name,\n span,\n functions: PrimaryMap::new(),\n name_map: BTreeMap::new(),\n }\n }\n\n pub fn name(&self) -> Ident {\n self.name\n }\n\n pub fn span(&self) -> SourceSpan {\n self.span\n }\n\n pub fn add_function(\n &mut self,\n span: SourceSpan,\n name: Ident,\n arity: usize,\n ) -> &mut FunctionDefinition {\n let ident = FunctionIdent {\n module: self.name,\n name,\n arity,\n };\n assert!(!self.name_map.contains_key(&(name.name, arity)));\n\n let fun = Function::new(span, ident);\n let def = FunctionDefinition {\n index: FunctionIndex(0),\n fun,\n };\n\n let index = self.functions.push(def);\n self.name_map.insert((name.name, arity), index);\n\n let def_mut = self.functions.get_mut(index).unwrap();\n def_mut.index = index;\n def_mut\n }\n\n pub fn ident_index(&self, ident: &FunctionIdent) -> Option {\n self.name_map.get(&(ident.name.name, ident.arity)).cloned()\n }\n pub fn name_arity_index(&self, name: Symbol, arity: usize) -> Option {\n self.name_map.get(&(name, arity)).cloned()\n }\n\n pub fn function_iter(&self) -> impl Iterator {\n self.functions.values()\n }\n pub fn function_iter_mut(&mut self) -> impl Iterator {\n self.functions.values_mut()\n }\n\n pub fn index_iter(&self) -> impl Iterator {\n self.functions.keys()\n }\n}\nimpl Clone for Module {\n fn clone(&self) -> Self {\n let mut functions: PrimaryMap = PrimaryMap::new();\n let mut name_map = BTreeMap::new();\n for def in self.function_iter() {\n let fun = def.function();\n let ident = fun.ident();\n let def = FunctionDefinition {\n index: FunctionIndex(0),\n fun: fun.clone(),\n };\n let index = functions.push(def);\n name_map.insert((ident.name.name, ident.arity), index);\n }\n Self {\n name: self.name.clone(),\n span: self.span,\n functions,\n name_map,\n }\n }\n}\n\nimpl Index for Module {\n type Output = FunctionDefinition;\n fn index(&self, idx: FunctionIndex) -> &FunctionDefinition {\n &self.functions[idx]\n }\n}\nimpl IndexMut for Module {\n fn index_mut(&mut self, idx: FunctionIndex) -> &mut FunctionDefinition {\n &mut self.functions[idx]\n }\n}\n\nimpl Index<&FunctionIdent> for Module {\n type Output = FunctionDefinition;\n fn index(&self, ident: &FunctionIdent) -> &FunctionDefinition {\n let idx = self\n .ident_index(ident)\n .expect(\"function ident not in module\");\n &self.functions[idx]\n }\n}\n" }, { "path": "libeir_ir/src/operation/binary_construct.rs", "content": "//! # Binary construction construct\n//! Binary construction is represented as several intrinsics that interact\n//! to represent binary construction.\n//!\n//! Binary construction always consists of a single\n//! `binary_construct_start`, any number of `binary_construct_push`,\n//! finishing off with a single `binary_construct_finish`.\n//!\n//! `binary_construct_start` returns a opaque handle that is used to refer\n//! to the binary construction in subsequent interactions.\n//!\n//! Once control flow enters through a `binary_construct_start`, it must\n//! ALWAYS exit through a `binary_construct_finish`.\n//!\n//! Several binary constructions may happen concurrently, as long as they\n//! are all eventually finished.\n//!\n//! A binary construction may contain arbitrary control flow, and as such\n//! the number of pushes may vary from run to run.\n//!\n//! ```ignore\n//! v\n//! binary_construct_start\n//! |\n//! v\n//! binary_construct_push\n//! |\n//! ...<-------------\n//! v |\n//! binary_construct_push |\n//! | |\n//! ...--------------\n//! |\n//! v\n//! binary_construct_push\n//! |\n//! v\n//! binary_construct_finish\n//!\n//! ````\n\nuse std::any::TypeId;\nuse std::default::Default;\n\nuse meta_table::{impl_meta_entry, MetaEntry};\n\nuse super::{DynOp, Op, OpBuild};\nuse crate::dialect::Dialect;\nuse crate::traits::OpBranches;\nuse crate::{BinaryEntrySpecifier, Block, Function, FunctionBuilder, Value};\n\npub struct BinaryConstructToken(());\n\n/// ## `binary_construct_start`\n/// (cont: fn(bin_ref))\n#[derive(Debug, Clone)]\npub struct BinaryConstructStart;\nimpl_meta_entry!(BinaryConstructStart);\nimpl_op!(BinaryConstructStart, \"binary_construct_start\");\n\nimpl OpBranches for BinaryConstructStart {\n fn branches_len(&self) -> usize {\n 1\n }\n fn branch_num(&self, fun: &Function, block: Block, branch_n: usize) -> Value {\n match branch_n {\n 0 => fun.block_reads(block)[0],\n _ => unreachable!(),\n }\n }\n}\n\nimpl BinaryConstructStart {\n pub fn build(builder: &mut FunctionBuilder, block: Block) -> Block {\n let target = builder.block_insert();\n let _arg = builder.block_arg_insert(target);\n Self::build_target(builder, block, target);\n target\n }\n\n pub fn build_target(builder: &mut FunctionBuilder, block: Block, target: Block) {\n let target_val = builder.value(target);\n builder.op_intrinsic(\n block,\n BinaryConstructStart,\n &[target_val],\n BinaryConstructToken(()),\n );\n }\n}\nimpl OpBuild for BinaryConstructStart {\n type Token = BinaryConstructToken;\n}\n\n/// ## `binary_construct_push`\n/// (ok: fn(bin_ref), fail: fn(), bin_ref, value)\n/// (ok: fn(bin_ref), fail: fn(), bin_ref, value, size)\n#[derive(Debug, Default, Clone, PartialEq)]\npub struct BinaryConstructPush {\n pub specifier: BinaryEntrySpecifier,\n}\nimpl_meta_entry!(BinaryConstructPush);\n\nimpl Op for BinaryConstructPush {\n fn name(&self) -> &str {\n \"binary_construct_push\"\n }\n fn dyn_clone(&self) -> DynOp {\n DynOp::new(self.clone())\n }\n fn type_id(&self) -> TypeId {\n TypeId::of::()\n }\n fn meta_entry(&self) -> &dyn MetaEntry {\n self\n }\n fn op_eq(&self, other: &dyn Op) -> bool {\n if let Some(other_i) = other.downcast_ref::() {\n self == other_i\n } else {\n false\n }\n }\n}\n\nimpl OpBranches for BinaryConstructPush {\n fn branches_len(&self) -> usize {\n 2\n }\n fn branch_num(&self, fun: &Function, block: Block, branch_n: usize) -> Value {\n match branch_n {\n 0 => fun.block_reads(block)[0],\n 1 => fun.block_reads(block)[1],\n _ => unreachable!(),\n }\n }\n}\n\nimpl BinaryConstructPush {\n pub fn build(\n builder: &mut FunctionBuilder,\n block: Block,\n bin_ref: Value,\n value: Value,\n spec: BinaryEntrySpecifier,\n size: Option,\n ) -> (Block, Block) {\n let ok = builder.block_insert();\n let _bin_ref = builder.block_arg_insert(ok);\n let fail = builder.block_insert();\n Self::build_target(builder, block, bin_ref, value, spec, size, ok, fail);\n (ok, fail)\n }\n\n pub fn build_target(\n builder: &mut FunctionBuilder,\n block: Block,\n bin_ref: Value,\n value: Value,\n spec: BinaryEntrySpecifier,\n size: Option,\n ok: Block,\n fail: Block,\n ) {\n let ok_val = builder.value(ok);\n let fail_val = builder.value(fail);\n\n if let Some(size) = size {\n builder.op_intrinsic(\n block,\n BinaryConstructPush { specifier: spec },\n &[ok_val, fail_val, bin_ref, value, size],\n BinaryConstructToken(()),\n );\n } else {\n builder.op_intrinsic(\n block,\n BinaryConstructPush { specifier: spec },\n &[ok_val, fail_val, bin_ref, value],\n BinaryConstructToken(()),\n );\n };\n }\n}\nimpl OpBuild for BinaryConstructPush {\n type Token = BinaryConstructToken;\n}\n\n/// ## `binary_construct_finish`\n/// (cont: fn(result), ref)\n#[derive(Debug, Clone)]\npub struct BinaryConstructFinish;\nimpl_meta_entry!(BinaryConstructFinish);\n\nimpl Op for BinaryConstructFinish {\n fn name(&self) -> &str {\n \"binary_construct_finish\"\n }\n fn dyn_clone(&self) -> DynOp {\n DynOp::new(self.clone())\n }\n fn type_id(&self) -> TypeId {\n TypeId::of::()\n }\n fn meta_entry(&self) -> &dyn MetaEntry {\n self\n }\n}\n\nimpl OpBranches for BinaryConstructFinish {\n fn branches_len(&self) -> usize {\n 1\n }\n fn branch_num(&self, fun: &Function, block: Block, branch_n: usize) -> Value {\n match branch_n {\n 0 => fun.block_reads(block)[0],\n _ => unreachable!(),\n }\n }\n}\n\nimpl BinaryConstructFinish {\n pub fn build(builder: &mut FunctionBuilder, block: Block, bin_ref: Value) -> Block {\n let target = builder.block_insert();\n let _arg = builder.block_arg_insert(target);\n Self::build_target(builder, block, bin_ref, target);\n target\n }\n\n pub fn build_target(\n builder: &mut FunctionBuilder,\n block: Block,\n bin_ref: Value,\n target: Block,\n ) {\n let target_val = builder.value(target);\n builder.op_intrinsic(\n block,\n BinaryConstructFinish,\n &[target_val, bin_ref],\n BinaryConstructToken(()),\n );\n }\n}\nimpl OpBuild for BinaryConstructFinish {\n type Token = BinaryConstructToken;\n}\n\npub fn register(dialect: &mut Dialect) {\n dialect.register_op::();\n dialect.register_op_branches_impl::();\n\n dialect.register_op::();\n dialect.register_op_branches_impl::();\n\n dialect.register_op::();\n dialect.register_op_branches_impl::();\n}\n" }, { "path": "libeir_ir/src/operation/case.rs", "content": "use std::any::TypeId;\n\nuse libeir_diagnostics::SourceSpan;\nuse libeir_intern::Symbol;\nuse meta_table::{impl_meta_entry, MetaEntry};\nuse pretty::{DocAllocator, RefDoc};\n\nuse super::{DynOp, Op, OpBuild};\nuse crate::pattern::{PatternClause, PatternContainer};\nuse crate::text::ast::DynToken;\nuse crate::text::parse_dyn::{DynParserError, ParseCtx};\nuse crate::text::LowerContext;\nuse crate::traits::{FormatOpCtx, OpBranches, OpParser, OpPrinter};\nuse crate::{Block, Dialect, Function, FunctionBuilder, Value};\n\npub struct CaseToken(());\n\n/// Case structure\n/// ```ignore\n/// (\n/// no_match: fn(),\n/// (\n/// guard: fn(ok: fn(), fail: fn(), pat_refs..),\n/// body: fn(pat_refs..),\n/// )..,\n/// match_val: ,\n/// match_values: term..,\n/// )\n/// ```\n///\n/// High level matching construct, lowered to explicit control flow\n/// in a Eir compiler pass. Only allowed in high level Eir dialect.\n/// This OP indicates the start of a case structure.\n/// A guard is strictly required to return through either the ok\n/// or fail continuation.\n#[derive(Debug, Clone)]\npub struct Case {\n inner: Box,\n}\nimpl_meta_entry!(Case);\n\nimpl Case {\n pub fn pat<'a>(&'a self) -> &'a PatternContainer {\n &self.inner.container\n }\n pub fn clauses<'a>(&'a self) -> &'a [PatternClause] {\n &self.inner.clauses\n }\n}\n\n#[derive(Debug, Clone)]\nstruct Inner {\n container: PatternContainer,\n clauses: Vec,\n}\n\nimpl Op for Case {\n fn name(&self) -> &str {\n \"case\"\n }\n fn dyn_clone(&self) -> DynOp {\n DynOp::new(self.clone())\n }\n fn type_id(&self) -> TypeId {\n TypeId::of::()\n }\n fn meta_entry(&self) -> &dyn MetaEntry {\n self\n }\n fn op_eq(&self, other: &dyn Op) -> bool {\n if let Some(_other_i) = other.downcast_ref::() {\n unimplemented!()\n } else {\n false\n }\n }\n}\n\nimpl OpBranches for Case {\n fn branches_len(&self) -> usize {\n 1 + self.inner.clauses.len()\n }\n fn branch_num(&self, fun: &Function, block: Block, branch_n: usize) -> Value {\n // [no_branch, guard_1, body_1, guard_2, body_2, ..]\n // guards are not control flow, they are lambda calls\n let reads = fun.block_reads(block);\n if branch_n == 0 {\n reads[0]\n } else {\n let n = branch_n - 1;\n reads[2 + n * 2]\n }\n }\n}\n\nimpl OpPrinter for Case {\n fn to_doc<'doc>(&self, ctx: &mut dyn FormatOpCtx<'doc>, _block: Block) -> RefDoc<'doc, ()> {\n let arena = ctx.arena();\n let inner = &*self.inner;\n\n //let block = arena.concat(inner.clauses.iter().map(|clause| {\n // let root_nodes = inner.container.clause_root_nodes(clause);\n //}));\n\n arena\n .nil()\n .append(arena.text(\"case\"))\n .append(arena.space())\n //.append(block.nest(1).braces())\n .into_doc()\n }\n}\n\nimpl Case {\n pub fn builder() -> CaseBuilder {\n CaseBuilder::default()\n }\n}\n\npub struct CaseBuilder {\n span: SourceSpan,\n\n pub container: PatternContainer,\n\n pub match_on: Option,\n pub no_match: Option,\n\n clauses: Vec,\n clauses_b: Vec,\n values: Vec,\n}\n\nimpl Default for CaseBuilder {\n fn default() -> Self {\n CaseBuilder {\n span: SourceSpan::UNKNOWN,\n\n container: PatternContainer::new(),\n\n match_on: None,\n no_match: None,\n\n clauses: Vec::new(),\n clauses_b: Vec::new(),\n values: Vec::new(),\n }\n }\n}\n\nimpl CaseBuilder {\n pub fn new(span: SourceSpan) -> Self {\n let mut this = Self::default();\n this.span = span;\n this\n }\n\n pub fn set_span(&mut self, span: SourceSpan) {\n self.span = span;\n }\n\n pub fn push_clause<'a>(\n &mut self,\n clause: PatternClause,\n guard: Value,\n body: Value,\n _b: &mut FunctionBuilder<'a>,\n ) {\n self.clauses.push(clause);\n self.clauses_b.extend([guard, body].iter().cloned());\n }\n\n pub fn push_value<'a>(&mut self, value: Value, _b: &mut FunctionBuilder<'a>) {\n self.values.push(value);\n }\n\n pub fn finish<'a>(self, block: Block, b: &mut FunctionBuilder<'a>) {\n // Validate that the number of values matches between the\n // clauses and reads\n let mut num_values = 0;\n for clause in &self.clauses {\n num_values += self.container.clause_values(*clause).len();\n }\n let num_value_reads = self.values.len();\n assert!(num_values == num_value_reads);\n\n let op = Case {\n inner: Box::new(Inner {\n container: self.container,\n clauses: self.clauses,\n }),\n };\n\n let mut args = vec![self.no_match.unwrap()];\n args.extend(self.clauses_b.iter().cloned());\n args.push(self.match_on.unwrap());\n args.extend(self.values.iter().cloned());\n\n b.op_intrinsic(block, op, &args, CaseToken(()));\n\n //let data = b.fun_mut().blocks.get_mut(block).unwrap();\n //assert!(data.op.is_none());\n //assert!(data.reads.is_empty());\n\n //b.op_intrinsic(block, op, args, _token)\n\n //data.op = Some(OpKind::Case {\n // clauses: self.clauses,\n //});\n //data.location = b.fun_mut().locations.location(None, None, None, self.span);\n\n //let mut buf = b.value_buf.take().unwrap();\n //buf.clear();\n\n //data.reads\n // .push(self.no_match.unwrap(), &mut b.fun.pool.value);\n\n //// Guard and body blocks for clauses\n //for c in self.clauses_b.as_slice(&b.fun.pool.value) {\n // buf.push(*c);\n //}\n //data.reads\n // .extend(buf.iter().cloned(), &mut b.fun.pool.value);\n\n //// Match value\n //data.reads\n // .push(self.match_on.unwrap(), &mut b.fun.pool.value);\n\n //// Values\n //buf.clear();\n //for c in self.values.as_slice(&b.fun.pool.value) {\n // buf.push(*c);\n //}\n //data.reads\n // .extend(buf.iter().cloned(), &mut b.fun.pool.value);\n\n //buf.clear();\n //b.value_buf = Some(buf);\n\n //self.clauses_b.clear(&mut b.fun.pool.value);\n //self.values.clear(&mut b.fun.pool.value);\n\n //b.graph_update_block(block);\n //b.fun.graph_validate_block(block);\n }\n}\n\nimpl OpBuild for Case {\n type Token = CaseToken;\n}\n\nmacro_rules! parser_fail {\n ($context:expr, $value:expr) => {\n match $value {\n Ok(value) => value,\n Err(error) => {\n $context.error(error);\n return Err(());\n }\n }\n };\n}\n\nstruct CaseParser;\nimpl OpParser for CaseParser {\n fn parse(\n &self,\n context: &mut LowerContext,\n block: Block,\n tokens: &[DynToken],\n ) -> Result<(), ()> {\n use crate::text::parse_dyn::val;\n\n let mut ctx = ParseCtx::new(tokens, SourceSpan::UNKNOWN);\n\n let value = parser_fail!(context, val(&mut ctx));\n parser_fail!(context, parse_case_body(&mut ctx));\n parser_fail!(context, ctx.eof());\n\n unimplemented!()\n }\n}\n\nfn parse_case_body(ctx: &mut ParseCtx) -> Result<(), DynParserError> {\n let (tokens, span) = ctx.tok_braces()?;\n let mut ictx = ParseCtx::new(tokens, span);\n Ok(())\n}\n\npub fn register(dialect: &mut Dialect) {\n dialect.register_op::();\n dialect.register_op_branches_impl::();\n dialect.register_op_printer_impl::();\n dialect.register_op_parser(Symbol::intern(\"casen\"), Box::new(CaseParser));\n}\n\n#[cfg(test)]\nmod tests {\n\n #[ignore]\n #[test]\n fn basic_parse() {\n let fun = crate::text::parse_function_unwrap(\n \"\na'foo':a'bar'/1 {\n entry(%ret, %thr, %a):\n @casen <%a> {};\n}\n\",\n );\n }\n}\n" }, { "path": "libeir_ir/src/operation/mod.rs", "content": "use std::ops::Deref;\n\nuse std::any::TypeId;\nuse std::fmt::{Debug, Formatter, Result as FmtResult};\nuse std::raw::TraitObject;\n\nuse meta_table::MetaEntry;\nuse stack_dst::Value;\n\nmacro_rules! impl_op {\n ($typ:ident, $name:expr) => {\n impl Op for $typ {\n fn name(&self) -> &str {\n $name\n }\n fn dyn_clone(&self) -> DynOp {\n DynOp::new(self.clone())\n }\n fn type_id(&self) -> TypeId {\n TypeId::of::()\n }\n fn meta_entry(&self) -> &dyn MetaEntry {\n self\n }\n }\n };\n}\n\npub mod binary_construct;\npub mod case;\npub mod receive;\n\npub trait Op: MetaEntry + Send {\n fn name(&self) -> &str;\n\n fn dyn_clone(&self) -> DynOp;\n\n fn type_id(&self) -> TypeId;\n\n fn meta_entry(&self) -> &dyn MetaEntry;\n\n /// Tests for semantic equality between the two operations.\n /// The default implementation assumes no inner state, and simply compares\n /// TypeIds.\n fn op_eq(&self, other: &dyn Op) -> bool {\n self.type_id() == other.type_id()\n }\n\n fn debug_fmt(&self, formatter: &mut Formatter) -> FmtResult {\n write!(formatter, \"Op[{}]\", self.name())\n }\n}\n\nimpl dyn Op {\n pub fn try_cast(&self) -> Option<&T> {\n unimplemented!()\n }\n\n /// Returns some reference to the boxed value if it is of type `T`, or\n /// `None` if it isn't.\n #[inline]\n pub fn downcast_ref(&self) -> Option<&T> {\n // TODO: `type_id` is implemented by the user, if the user returns the\n // wrong TypeId, this is unsafe.\n if self.type_id() == TypeId::of::() {\n unsafe { Some(self.downcast_ref_unchecked()) }\n } else {\n None\n }\n }\n\n /// Returns a reference to the boxed value, blindly assuming it to be of type `T`.\n /// If you are not *absolutely certain* of `T`, you *must not* call this.\n #[inline]\n pub unsafe fn downcast_ref_unchecked(&self) -> &T {\n let trait_object: TraitObject = ::std::mem::transmute(self);\n std::mem::transmute(trait_object.data)\n }\n}\n\npub trait OpBuild: Op {\n /// In order to allow the operation implementation to have control over\n /// invariants for the operaion in the IR, each buildable operation\n /// has a token that must be provided to the function builder when adding\n /// it to the IR.\n /// The operation implementation has control over how this token type is\n /// created, and may restrict it in order to ensure that only it is able\n /// to build itself.\n type Token;\n}\n\npub struct DynOp(Value);\n\nimpl DynOp {\n pub fn new(value: T) -> Self {\n DynOp(Value::new_stable(value, |v| v as _).ok().unwrap())\n }\n}\n\nimpl Deref for DynOp {\n type Target = dyn Op;\n fn deref(&self) -> &dyn Op {\n &*self.0\n }\n}\n\nimpl Clone for DynOp {\n fn clone(&self) -> Self {\n self.0.dyn_clone()\n }\n}\n\nimpl Debug for DynOp {\n fn fmt(&self, formatter: &mut Formatter) -> FmtResult {\n self.0.debug_fmt(formatter)\n }\n}\n" }, { "path": "libeir_ir/src/operation/receive.rs", "content": "//! # Receive construct\n//! A receive statement is represented as several intrinsics that\n//! interact to represent the receive operation semantics of erlang.\n//!\n//! It consists of 3 operations, `receive_start`, `receive_wait`\n//! and `receive_done`. They are always called in this pattern:\n//!\n//! ```ignore\n//! v\n//! receive_start\n//! |\n//! v\n//! receive_wait <------------\n//! | | |\n//! timeout check_msg no match on\n//! | | message\n//! v v |\n//! control flow to ----\n//! match on message\n//! |\n//! message matches\n//! |\n//! v\n//! receive_done\n//! |\n//! ```\n\nuse std::any::TypeId;\n\nuse meta_table::{impl_meta_entry, MetaEntry};\n\nuse super::{DynOp, Op, OpBuild};\nuse crate::dialect::Dialect;\nuse crate::traits::{FormatOpCtx, OpBranches, OpPrinter};\nuse crate::{Block, Function, FunctionBuilder, Value};\nuse pretty::{DocAllocator, RefDoc};\n\npub struct ReceiveToken(());\n\n/// ## `receive_start`\n/// (cont: fn(recv_ref), timeout)\n///\n/// `recv_ref` is an opaque value that represents the current\n/// receive operation. It is up to the runtime implementor\n/// to decide what this stores, if anything at all.\n/// Since receive constructs can never be nested, storing receive\n/// state globally is also a valid strategy.\n/// This value can only ever be passed to `receive_wait` or\n/// `receive_done`.\n///\n/// `timeout` is either an atom, `infinity`, or a number.\n#[derive(Debug, Clone)]\npub struct ReceiveStart;\nimpl_meta_entry!(ReceiveStart);\n\nimpl Op for ReceiveStart {\n fn name(&self) -> &str {\n \"receive_start\"\n }\n fn dyn_clone(&self) -> DynOp {\n DynOp::new(self.clone())\n }\n fn type_id(&self) -> TypeId {\n TypeId::of::()\n }\n fn meta_entry(&self) -> &dyn MetaEntry {\n self\n }\n fn op_eq(&self, other: &dyn Op) -> bool {\n self.type_id() == other.type_id()\n }\n}\n\nimpl OpBranches for ReceiveStart {\n fn branches_len(&self) -> usize {\n 1\n }\n fn branch_num(&self, fun: &Function, block: Block, branch_n: usize) -> Value {\n match branch_n {\n 0 => fun.block_reads(block)[0],\n _ => unreachable!(),\n }\n }\n}\n\nimpl OpPrinter for ReceiveStart {\n fn to_doc<'doc>(&self, ctx: &mut dyn FormatOpCtx<'doc>, block: Block) -> RefDoc<'doc, ()> {\n let arena = ctx.arena();\n arena\n .nil()\n .append(arena.text(\"@\"))\n .append(arena.text(\"receive_start\"))\n .append(arena.space())\n .into_doc()\n }\n}\n\nimpl ReceiveStart {\n pub fn build(builder: &mut FunctionBuilder, block: Block, timeout: Value) -> Block {\n let target = builder.block_insert();\n let _arg = builder.block_arg_insert(target);\n Self::build_target(builder, block, timeout, target);\n target\n }\n\n pub fn build_target(\n builder: &mut FunctionBuilder,\n block: Block,\n timeout: Value,\n target: Block,\n ) {\n let target_val = builder.value(target);\n builder.op_intrinsic(\n block,\n ReceiveStart,\n &[target_val, timeout],\n ReceiveToken(()),\n );\n }\n}\nimpl OpBuild for ReceiveStart {\n type Token = ReceiveToken;\n}\n\n/// ## `receive_wait`\n/// (timeout: fn(), check_message: fn(msg), recv_ref)\n///\n/// This increments the mailbox pointer, fetches it, and calls\n/// `check_message` with that message. The value passed to\n/// `check_message` can not escape the current receive construct\n/// without being mapped through `receive_done`, so it is safe for\n/// this to be an off-heap value as long as it's guaranteed to be\n/// alive until the receive construct is exited by `receive_done`.\n///\n/// If there are no more messages, this should yield until there is.\n///\n/// If there is a timeout, `timeout` should be called. When `timeout`\n/// is called, the receive construct should be considered finished,\n/// that is, `receive_done` should not be called.\n#[derive(Debug, Clone)]\npub struct ReceiveWait;\nimpl_meta_entry!(ReceiveWait);\n\nimpl Op for ReceiveWait {\n fn name(&self) -> &str {\n \"receive_wait\"\n }\n fn dyn_clone(&self) -> DynOp {\n DynOp::new(self.clone())\n }\n fn type_id(&self) -> TypeId {\n TypeId::of::()\n }\n fn meta_entry(&self) -> &dyn MetaEntry {\n self\n }\n fn op_eq(&self, other: &dyn Op) -> bool {\n self.type_id() == other.type_id()\n }\n}\n\nimpl OpBranches for ReceiveWait {\n fn branches_len(&self) -> usize {\n 2\n }\n fn branch_num(&self, fun: &Function, block: Block, branch_n: usize) -> Value {\n match branch_n {\n 0 => fun.block_reads(block)[0],\n 1 => fun.block_reads(block)[1],\n _ => unreachable!(),\n }\n }\n}\n\nimpl ReceiveWait {\n pub fn build(builder: &mut FunctionBuilder, block: Block, recv_ref: Value) -> (Block, Block) {\n let timeout = builder.block_insert();\n\n let check_message = builder.block_insert();\n let _message = builder.block_arg_insert(check_message);\n\n Self::build_target(builder, block, recv_ref, timeout, check_message);\n\n (timeout, check_message)\n }\n\n pub fn build_target(\n builder: &mut FunctionBuilder,\n block: Block,\n recv_ref: Value,\n timeout: Block,\n check_message: Block,\n ) {\n let timeout_val = builder.value(timeout);\n let check_message_val = builder.value(check_message);\n builder.op_intrinsic(\n block,\n ReceiveWait,\n &[timeout_val, check_message_val, recv_ref],\n ReceiveToken(()),\n );\n }\n}\nimpl OpBuild for ReceiveWait {\n type Token = ReceiveToken;\n}\n\n/// ## `receive_done`\n/// (next: fn(...), recv_ref, ...)\n///\n/// Called when the message under the mailbox pointer is successfully\n/// matched, and should be removed from the mailbox.\n///\n/// Called with an arbitrary amount of arguments, these are the values\n/// that have been extracted from that message. If these are off-heap\n/// references, this operation would presumably copy them to the current\n/// process heap, and ensure that they are under juristiction of the\n/// process GC. The potentially copied values are then passed on as\n/// arguments to `next`.\n///\n/// After this operation is completed, there will be no live references\n/// to the value originally passed to `check_message`, they will have\n/// all been mapped through `receive_done`.\n#[derive(Debug, Clone)]\npub struct ReceiveDone;\nimpl_meta_entry!(ReceiveDone);\n\nimpl Op for ReceiveDone {\n fn name(&self) -> &str {\n \"receive_done\"\n }\n fn dyn_clone(&self) -> DynOp {\n DynOp::new(self.clone())\n }\n fn type_id(&self) -> TypeId {\n TypeId::of::()\n }\n fn meta_entry(&self) -> &dyn MetaEntry {\n self\n }\n fn op_eq(&self, other: &dyn Op) -> bool {\n self.type_id() == other.type_id()\n }\n}\n\nimpl OpBranches for ReceiveDone {\n fn branches_len(&self) -> usize {\n 1\n }\n fn branch_num(&self, fun: &Function, block: Block, branch_n: usize) -> Value {\n match branch_n {\n 0 => fun.block_reads(block)[0],\n _ => unreachable!(),\n }\n }\n}\n\nimpl ReceiveDone {\n pub fn build(\n builder: &mut FunctionBuilder,\n block: Block,\n recv_ref: Value,\n values: &[Value],\n ) -> Block {\n let next = builder.block_insert();\n for _ in values.iter() {\n builder.block_arg_insert(next);\n }\n\n Self::build_target(builder, block, recv_ref, values, next);\n\n next\n }\n\n pub fn build_target(\n builder: &mut FunctionBuilder,\n block: Block,\n recv_ref: Value,\n values: &[Value],\n next: Block,\n ) {\n let next_val = builder.value(next);\n\n let mut tmp = Vec::with_capacity(values.len() + 1);\n tmp.push(next_val);\n tmp.push(recv_ref);\n tmp.extend(values.iter().cloned());\n\n builder.op_intrinsic(block, ReceiveDone, &tmp, ReceiveToken(()));\n }\n}\nimpl OpBuild for ReceiveDone {\n type Token = ReceiveToken;\n}\n\npub fn register(dialect: &mut Dialect) {\n dialect.register_op::();\n dialect.register_op_branches_impl::();\n //dialect.register_op_printer_impl(&ReceiveStart);\n\n dialect.register_op::();\n dialect.register_op_branches_impl::();\n //dialect.register_op_printer_impl(&ReceiveWait);\n\n dialect.register_op::();\n dialect.register_op_branches_impl::();\n //dialect.register_op_printer_impl(&ReceiveDone);\n}\n" }, { "path": "libeir_ir/src/pattern/fmt.rs", "content": "use std::fmt;\nuse super::PatternNode;\n\nimpl fmt::Display for PatternNode {\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n match self {\n PatternNode::Wildcard =>\n write!(f, \"_\")?,\n PatternNode::Assign(var, pat) =>\n write!(f, \"({:?} = {})\", var, pat)?,\n PatternNode::Atomic(lit) =>\n write!(f, \"{:?}\", lit)?,\n PatternNode::Tuple(nodes) => {\n write!(f, \"{{\")?;\n for node in nodes {\n write!(f, \"{}, \", node)?;\n }\n write!(f, \"}}\")?;\n },\n PatternNode::List(head_values, tail) => {\n write!(f, \"[\")?;\n for val in head_values {\n write!(f, \"{}, \", val)?;\n }\n write!(f, \" | {}\", tail)?;\n write!(f, \"]\")?;\n },\n PatternNode::Map(values) => {\n write!(f, \"~{{\")?;\n for (key_num, val) in values {\n write!(f, \"V{}; {}, \", key_num.0, val)?;\n }\n write!(f, \"}}~\")?;\n },\n PatternNode::Binary(elems) => {\n write!(f, \"#<\")?;\n for elem in elems.iter() {\n write!(f, \"{}:{:?}, \", elem.node, elem.args)?;\n }\n write!(f, \">#\")?;\n },\n //PatternNode::Binary(elems) => {\n // write!(f, \"#<\")?;\n\n // for elem in elems {\n // write!(f, \"#<{}>(\", elem.0)?;\n // for attr in &elem.1 {\n // write!(f, \"{}, \", attr)?;\n // }\n // write!(f, \")#\")?;\n // }\n\n // write!(f, \">#\")?;\n //},\n }\n Ok(())\n }\n}\n" }, { "path": "libeir_ir/src/pattern/mod.rs", "content": "use std::collections::HashMap;\n\nuse cranelift_entity::{entity_impl, EntityList, ListPool, PrimaryMap};\n\nuse libeir_diagnostics::SourceSpan;\n\nuse crate::binary::BinaryEntrySpecifier;\nuse crate::constant::ConstantContainer;\nuse crate::Const;\n\n#[derive(Copy, Clone, Hash, PartialEq, Eq, PartialOrd, Ord)]\npub struct PatternNode(u32);\nentity_impl!(PatternNode, \"pattern_node\");\n\n/// A input value for a pattern, used in map matching\n/// and binary matching\n#[derive(Copy, Clone, Hash, PartialEq, Eq, PartialOrd, Ord)]\npub struct PatternValue(u32);\nentity_impl!(PatternValue, \"pattern_value\");\n\n#[derive(Copy, Clone, Hash, PartialEq, Eq, PartialOrd, Ord)]\npub struct PatternClause(u32);\nentity_impl!(PatternClause, \"pattern_clause\");\n\n#[derive(Debug, Clone)]\npub struct PatternContainer {\n nodes: PrimaryMap,\n values: PrimaryMap,\n clauses: PrimaryMap,\n\n pub node_pool: ListPool,\n pub value_pool: ListPool,\n\n /// Temporary map used for copies\n tmp_val_map: Option>,\n tmp_node_map: Option>,\n}\n\nimpl Default for PatternContainer {\n fn default() -> PatternContainer {\n PatternContainer {\n nodes: PrimaryMap::new(),\n values: PrimaryMap::new(),\n clauses: PrimaryMap::new(),\n\n node_pool: ListPool::new(),\n value_pool: ListPool::new(),\n\n tmp_val_map: Some(HashMap::new()),\n tmp_node_map: Some(HashMap::new()),\n }\n }\n}\n\n#[derive(Debug, Clone)]\nstruct PatternClauseData {\n span: SourceSpan,\n root_nodes: EntityList,\n\n node_binds_keys: EntityList,\n node_binds_vals: EntityList,\n\n /// This is the set of nodes that are bound from the pattern.\n /// This will correspond to another list of the same length stored\n /// outside of the container, the two will together form a pair.\n /// This way of doing things enables this single representation\n /// of patterns to work through several IRs.\n binds: EntityList,\n\n /// This is the set of values that are accessible from the pattern.\n /// Same as `binds`, except for external values used within the clause.\n values: EntityList,\n\n finished: bool,\n}\n\n#[derive(Debug, Clone)]\nstruct PatternNodeData {\n kind: Option,\n finished: bool,\n span: SourceSpan,\n}\n\n#[derive(Debug, Clone)]\npub enum PatternNodeKind {\n Wildcard,\n Const(Const),\n Value(PatternValue),\n Binary {\n specifier: BinaryEntrySpecifier,\n value: PatternNode,\n size: Option,\n\n remaining: Option,\n },\n Tuple(EntityList),\n List {\n head: PatternNode,\n tail: PatternNode,\n },\n Map {\n keys: EntityList,\n values: EntityList,\n },\n}\n\n#[derive(Debug, Clone)]\npub struct PatternBinaryEntryData {}\n\npub enum PatternMergeFail {\n /// The two patterns are disjoint, they can never match at the\n /// same time.\n /// The two nodes are the reason for this.\n Disjoint {\n left: Option,\n right: PatternNode,\n },\n /// Merging is not supported. Only happens with binaries\n /// The two nodes are the reason for this.\n Failure {\n left: Option,\n right: PatternNode,\n },\n}\n\nimpl PatternContainer {\n pub fn new() -> Self {\n Self::default()\n }\n\n pub fn clause_value(&mut self, clause: PatternClause) -> PatternValue {\n let val = self.values.push(());\n self.clauses[clause].values.push(val, &mut self.value_pool);\n val\n }\n\n pub fn clause_node_value(&mut self, clause: PatternClause, node: PatternNode) -> PatternValue {\n let val = self.values.push(());\n\n let data = &mut self.clauses[clause];\n data.node_binds_keys.push(node, &mut self.node_pool);\n data.node_binds_vals.push(val, &mut self.value_pool);\n\n val\n }\n\n pub fn node_empty(&mut self, span: Option) -> PatternNode {\n self.nodes.push(PatternNodeData {\n kind: None,\n finished: false,\n span: span.unwrap_or(SourceSpan::UNKNOWN),\n })\n }\n\n pub fn binary(\n &mut self,\n node: PatternNode,\n specifier: BinaryEntrySpecifier,\n value: PatternNode,\n size: Option,\n remaining: Option,\n ) {\n let mut data = &mut self.nodes[node];\n assert!(data.kind.is_none());\n data.kind = Some(PatternNodeKind::Binary {\n specifier,\n value,\n size,\n\n remaining,\n });\n data.finished = true;\n }\n\n pub fn wildcard(&mut self, node: PatternNode) {\n let mut data = &mut self.nodes[node];\n assert!(data.kind.is_none());\n data.kind = Some(PatternNodeKind::Wildcard);\n data.finished = true;\n }\n\n pub fn constant(&mut self, node: PatternNode, val: Const) {\n let mut data = &mut self.nodes[node];\n assert!(data.kind.is_none());\n data.kind = Some(PatternNodeKind::Const(val));\n data.finished = true;\n }\n\n pub fn value(&mut self, node: PatternNode, val: PatternValue) {\n let mut data = &mut self.nodes[node];\n assert!(data.kind.is_none());\n data.kind = Some(PatternNodeKind::Value(val));\n data.finished = true;\n }\n\n pub fn tuple(&mut self, node: PatternNode) {\n let mut data = &mut self.nodes[node];\n assert!(data.kind.is_none());\n data.kind = Some(PatternNodeKind::Tuple(EntityList::new()));\n }\n\n pub fn tuple_elem_push(&mut self, tup: PatternNode, node: PatternNode) {\n let data = &mut self.nodes[tup];\n assert!(!data.finished);\n assert!(data.kind.is_some());\n if let PatternNodeKind::Tuple(ref mut list) = data.kind.as_mut().unwrap() {\n list.push(node, &mut self.node_pool);\n } else {\n panic!();\n }\n }\n\n pub fn list(&mut self, node: PatternNode, head: PatternNode, tail: PatternNode) {\n let mut data = &mut self.nodes[node];\n assert!(data.kind.is_none());\n data.kind = Some(PatternNodeKind::List { head, tail });\n data.finished = true;\n }\n\n pub fn map(&mut self, node: PatternNode) {\n let mut data = &mut self.nodes[node];\n assert!(data.kind.is_none());\n data.kind = Some(PatternNodeKind::Map {\n keys: EntityList::new(),\n values: EntityList::new(),\n });\n }\n\n pub fn map_push(&mut self, map: PatternNode, key: PatternValue, value: PatternNode) {\n let data = &mut self.nodes[map];\n assert!(!data.finished);\n assert!(data.kind.is_some());\n if let PatternNodeKind::Map {\n ref mut keys,\n ref mut values,\n } = data.kind.as_mut().unwrap()\n {\n keys.push(key, &mut self.value_pool);\n values.push(value, &mut self.node_pool);\n } else {\n panic!();\n }\n }\n\n pub fn node_finish(&mut self, node: PatternNode) {\n let data = &mut self.nodes[node];\n assert!(data.kind.is_some());\n data.finished = true;\n }\n\n pub fn node_set_span(&mut self, node: PatternNode, span: SourceSpan) {\n self.nodes[node].span = span;\n }\n\n pub fn clause_start(&mut self, span: SourceSpan) -> PatternClause {\n self.clauses.push(PatternClauseData {\n span,\n\n root_nodes: EntityList::new(),\n\n node_binds_keys: EntityList::new(),\n node_binds_vals: EntityList::new(),\n\n binds: EntityList::new(),\n values: EntityList::new(),\n\n finished: false,\n })\n }\n pub fn clause_node_push(&mut self, clause: PatternClause, node: PatternNode) {\n let data = &mut self.clauses[clause];\n assert!(!data.finished);\n\n data.root_nodes.push(node, &mut self.node_pool);\n }\n pub fn clause_bind_push(&mut self, clause: PatternClause, node: PatternNode) {\n let data = &mut self.clauses[clause];\n assert!(!data.finished);\n\n data.binds.push(node, &mut self.node_pool);\n }\n pub fn clause_value_push(&mut self, clause: PatternClause, val: PatternValue) {\n let data = &mut self.clauses[clause];\n assert!(!data.finished);\n\n data.values.push(val, &mut self.value_pool);\n }\n pub fn clause_finish(&mut self, clause: PatternClause) {\n let data = &mut self.clauses[clause];\n assert!(!data.finished);\n\n data.finished = true;\n }\n\n pub fn copy_from(&mut self, clause: PatternClause, from: &PatternContainer) -> PatternClause {\n let from_clause = &from.clauses[clause];\n\n let mut value_map = self.tmp_val_map.take().unwrap();\n let mut node_map = self.tmp_node_map.take().unwrap();\n\n let mut new_values = EntityList::new();\n for from_val in from_clause.values.as_slice(&from.value_pool) {\n let new_val = self.values.push(());\n new_values.push(new_val, &mut self.value_pool);\n value_map.insert(*from_val, new_val);\n }\n\n let mut new_roots = EntityList::new();\n for node in from_clause.root_nodes.as_slice(&from.node_pool) {\n let new = copy_pattern_node(&value_map, &mut node_map, *node, from, self);\n new_roots.push(new, &mut self.node_pool);\n }\n\n let mut new_binds = EntityList::new();\n for bind in from_clause.binds.as_slice(&from.node_pool) {\n new_binds.push(node_map[bind], &mut self.node_pool);\n }\n\n value_map.clear();\n self.tmp_val_map = Some(value_map);\n node_map.clear();\n self.tmp_node_map = Some(node_map);\n\n unimplemented!()\n //self.clauses.push(PatternClauseData {\n // root_nodes: new_roots,\n\n // node_binds_keys: unimplemented!(),\n // node_binds_vals: unimplemented!(),\n\n // binds: new_binds,\n // values: new_values,\n\n // finished: true,\n //})\n }\n\n /// Given a HashMap containing the mapping, this will go through all the\n /// binds of a clause and update them. Useful when merging nodes while\n /// constructing patterns.\n pub fn update_binds(&mut self, clause: PatternClause, map: &HashMap) {\n let clause_d = &mut self.clauses[clause];\n\n let len = clause_d.binds.len(&self.node_pool);\n for n in 0..len {\n let entry = clause_d.binds.get_mut(n, &mut self.node_pool).unwrap();\n if let Some(new) = map.get(&*entry) {\n *entry = *new;\n }\n }\n }\n}\n\nimpl PatternContainer {\n pub fn clause_root_nodes(&self, clause: PatternClause) -> &[PatternNode] {\n let data = &self.clauses[clause];\n data.root_nodes.as_slice(&self.node_pool)\n }\n\n pub fn clause_binds(&self, clause: PatternClause) -> &[PatternNode] {\n let data = &self.clauses[clause];\n data.binds.as_slice(&self.node_pool)\n }\n\n pub fn clause_values(&self, clause: PatternClause) -> &[PatternValue] {\n let data = &self.clauses[clause];\n data.values.as_slice(&self.value_pool)\n }\n\n pub fn clause_node_binds_iter<'a>(\n &'a self,\n clause: PatternClause,\n ) -> impl Iterator + 'a {\n let data = &self.clauses[clause];\n data.node_binds_vals\n .as_slice(&self.value_pool)\n .iter()\n .cloned()\n .zip(\n data.node_binds_keys\n .as_slice(&self.node_pool)\n .iter()\n .cloned(),\n )\n }\n\n pub fn node_span(&self, node: PatternNode) -> SourceSpan {\n self.nodes[node].span\n }\n\n pub fn node_kind(&self, node: PatternNode) -> &PatternNodeKind {\n self.nodes[node].kind.as_ref().unwrap()\n }\n}\n\nfn copy_pattern_node(\n value_map: &HashMap,\n node_map: &mut HashMap,\n node: PatternNode,\n from: &PatternContainer,\n to: &mut PatternContainer,\n) -> PatternNode {\n let data = &from.nodes[node];\n match data.kind.as_ref().unwrap() {\n PatternNodeKind::Wildcard => {\n let new = to.node_empty(Some(data.span));\n to.wildcard(new);\n node_map.insert(node, new);\n new\n }\n PatternNodeKind::Value(val) => {\n let new = to.node_empty(Some(data.span));\n to.value(new, *val);\n node_map.insert(node, new);\n new\n }\n PatternNodeKind::Tuple(elems) => {\n let new = to.node_empty(Some(data.span));\n to.tuple(new);\n\n for elem in elems.as_slice(&from.node_pool) {\n let copied = copy_pattern_node(value_map, node_map, *elem, from, to);\n to.tuple_elem_push(new, copied);\n }\n\n to.node_finish(new);\n node_map.insert(node, new);\n new\n }\n PatternNodeKind::List { head, tail } => {\n let head_copied = copy_pattern_node(value_map, node_map, *head, from, to);\n let tail_copied = copy_pattern_node(value_map, node_map, *tail, from, to);\n\n let new = to.node_empty(Some(data.span));\n to.list(new, head_copied, tail_copied);\n\n node_map.insert(node, new);\n new\n }\n PatternNodeKind::Map { keys, values } => {\n let new = to.node_empty(Some(data.span));\n to.map(new);\n\n for (key, val) in keys\n .as_slice(&from.value_pool)\n .iter()\n .zip(values.as_slice(&from.node_pool))\n {\n let copied = copy_pattern_node(value_map, node_map, *val, from, to);\n to.map_push(new, value_map[key], copied);\n }\n\n to.node_finish(new);\n node_map.insert(node, new);\n new\n }\n _ => unimplemented!(\"{:?}\", data.kind),\n }\n}\n\nimpl PatternContainer {\n pub fn merge_patterns(\n &mut self,\n cons: &ConstantContainer,\n map: &mut HashMap,\n lhs: PatternNode,\n rhs: PatternNode,\n ) -> Result {\n // This clone is really cheap since entitylists are basically just an usize\n let lhs_kind = self.nodes[lhs].kind.clone().unwrap();\n let rhs_kind = self.nodes[rhs].kind.clone().unwrap();\n\n // TODO: Fuse locations\n let fused_span = self.nodes[lhs].span;\n match (lhs_kind, rhs_kind) {\n (PatternNodeKind::Value(l_val), PatternNodeKind::Value(r_val)) if l_val == r_val => {\n map.insert(rhs, lhs);\n Ok(lhs)\n }\n (PatternNodeKind::Const(l), _) => {\n self.merge_pattern_constant(cons, map, fused_span, rhs, l)\n }\n (_, PatternNodeKind::Const(r)) => {\n self.merge_pattern_constant(cons, map, fused_span, lhs, r)\n }\n (PatternNodeKind::Wildcard, _) => {\n map.insert(lhs, rhs);\n Ok(rhs)\n }\n (_, PatternNodeKind::Wildcard) => {\n map.insert(rhs, lhs);\n Ok(lhs)\n }\n (PatternNodeKind::Tuple(l1), PatternNodeKind::Tuple(l2)) => {\n let l1_len = l1.len(&self.node_pool);\n let l2_len = l2.len(&self.node_pool);\n if l1_len == l2_len {\n let new_tup = self.node_empty(Some(fused_span));\n self.tuple(new_tup);\n for idx in 0..l1_len {\n let ln = l1.get(idx, &self.node_pool).unwrap();\n let rn = l2.get(idx, &self.node_pool).unwrap();\n\n let merged = self.merge_patterns(cons, map, ln, rn)?;\n\n self.tuple_elem_push(new_tup, merged);\n }\n self.node_finish(new_tup);\n\n map.insert(lhs, new_tup);\n map.insert(rhs, new_tup);\n\n Ok(new_tup)\n } else {\n Err(PatternMergeFail::Disjoint {\n left: Some(lhs),\n right: rhs,\n })\n }\n }\n (\n PatternNodeKind::Map {\n keys: k1,\n values: v1,\n },\n PatternNodeKind::Map {\n keys: k2,\n values: v2,\n },\n ) => {\n let new_map = self.node_empty(Some(fused_span));\n self.map(new_map);\n\n for idx in 0..(k1.len(&self.value_pool)) {\n let k = k1.get(idx, &self.value_pool).unwrap();\n let v = v1.get(idx, &self.node_pool).unwrap();\n self.map_push(new_map, k, v);\n }\n for idx in 0..(k2.len(&self.value_pool)) {\n let k = k2.get(idx, &self.value_pool).unwrap();\n let v = v2.get(idx, &self.node_pool).unwrap();\n self.map_push(new_map, k, v);\n }\n\n self.node_finish(new_map);\n\n map.insert(lhs, new_map);\n map.insert(rhs, new_map);\n\n Ok(new_map)\n }\n (\n PatternNodeKind::List { head: h1, tail: t1 },\n PatternNodeKind::List { head: h2, tail: t2 },\n ) => {\n let new_head = self.merge_patterns(cons, map, h1, h2)?;\n let new_tail = self.merge_patterns(cons, map, t1, t2)?;\n\n let list = self.node_empty(Some(fused_span));\n self.list(list, new_head, new_tail);\n\n map.insert(lhs, list);\n map.insert(rhs, list);\n\n Ok(list)\n }\n // Patterns are incompatible\n _ => Err(PatternMergeFail::Disjoint {\n left: Some(lhs),\n right: rhs,\n }),\n }\n }\n\n pub fn merge_pattern_constant(\n &mut self,\n cons: &ConstantContainer,\n map: &mut HashMap,\n fused_span: SourceSpan,\n lhs: PatternNode,\n rhs: Const,\n ) -> Result {\n let lhs_kind = self.nodes[lhs].kind.clone().unwrap();\n let rhs_kind = cons.const_kind(rhs).clone();\n\n use crate::{AtomicTerm, ConstKind};\n\n match (lhs_kind, rhs_kind) {\n (PatternNodeKind::Const(l_const), _) if l_const == rhs => Ok(lhs),\n (PatternNodeKind::Const(_), _) => Err(PatternMergeFail::Disjoint {\n left: None,\n right: lhs,\n }),\n (PatternNodeKind::Wildcard, _) => {\n let node = self.node_empty(Some(fused_span));\n self.constant(node, rhs);\n map.insert(lhs, node);\n Ok(node)\n }\n (\n PatternNodeKind::Tuple(pat_entries),\n ConstKind::Tuple {\n entries: const_entries,\n },\n ) => {\n let pat_len = pat_entries.len(&self.node_pool);\n let const_len = const_entries.len(&cons.const_pool);\n\n if pat_len != const_len {\n return Err(PatternMergeFail::Disjoint {\n left: None,\n right: lhs,\n });\n }\n\n let node = self.node_empty(Some(fused_span));\n self.tuple(node);\n\n for n in 0..pat_len {\n let pat_node = pat_entries.get(n, &self.node_pool).unwrap();\n let const_node = const_entries.get(n, &cons.const_pool).unwrap();\n\n // TODO: Fuse locations\n let fspan = self.nodes[pat_node].span;\n let new =\n self.merge_pattern_constant(cons, map, fspan, pat_node, const_node)?;\n self.tuple_elem_push(node, new);\n }\n\n self.node_finish(node);\n map.insert(lhs, node);\n\n Ok(node)\n }\n (PatternNodeKind::Tuple(_), _) => Err(PatternMergeFail::Disjoint {\n left: None,\n right: lhs,\n }),\n (\n PatternNodeKind::List {\n head: pat_head,\n tail: pat_tail,\n },\n ConstKind::ListCell {\n head: cons_head,\n tail: cons_tail,\n },\n ) => {\n let head =\n self.merge_pattern_constant(cons, map, fused_span, pat_head, cons_head)?;\n let tail =\n self.merge_pattern_constant(cons, map, fused_span, pat_tail, cons_tail)?;\n\n let node = self.node_empty(Some(fused_span));\n self.list(node, head, tail);\n map.insert(lhs, node);\n\n Ok(node)\n }\n (PatternNodeKind::List { .. }, _) => Err(PatternMergeFail::Disjoint {\n left: None,\n right: lhs,\n }),\n (PatternNodeKind::Binary { .. }, ConstKind::Atomic(AtomicTerm::Binary(_))) => {\n Err(PatternMergeFail::Failure {\n left: None,\n right: lhs,\n })\n }\n (PatternNodeKind::Binary { .. }, _) => Err(PatternMergeFail::Disjoint {\n left: None,\n right: lhs,\n }),\n (a, b) => unimplemented!(\"{:?} {:?}\", a, b),\n }\n }\n\n /// Makes a structural variant of the given pattern clause.\n ///\n /// A structural pattern is a pattern which matches on a term of the same\n /// structure, but with all atomic matches removed.\n ///\n /// This is currently only defined for binary nodes, and will panic if\n /// any other pattern is given.\n pub fn make_structural(&mut self, clause: PatternClause) -> PatternClause {\n use PatternNodeKind as PNK;\n \n let clause_data = &self.clauses[clause];\n\n let mut bind_mapping: HashMap = HashMap::new();\n for bind in clause_data.binds.as_slice(&self.node_pool).iter() {\n bind_mapping.insert(*bind, *bind);\n }\n for bind in clause_data.node_binds_keys.as_slice(&self.node_pool).iter() {\n bind_mapping.insert(*bind, *bind);\n }\n\n let mut value_mapping: HashMap = HashMap::new();\n let values = &mut self.values;\n let mut map_value = |val: PatternValue| -> PatternValue {\n *value_mapping.entry(val).or_insert_with(|| values.push(()))\n };\n\n let mut root_nodes: Vec<_> = clause_data\n .root_nodes\n .as_slice(&self.node_pool)\n .iter()\n .cloned()\n .collect();\n\n fn make_node_structural(\n nodes: &mut PrimaryMap,\n node_pool: &mut ListPool,\n value_pool: &mut ListPool,\n bind_mapping: &mut HashMap,\n mut map_value: &mut impl FnMut(PatternValue) -> PatternValue,\n node: PatternNode,\n ) -> PatternNode {\n let mut node_data = nodes[node].clone();\n assert!(node_data.finished);\n\n println!(\"{:?}\", node_data.kind);\n let new_kind = match node_data.kind.unwrap() {\n PNK::Wildcard => PNK::Wildcard,\n PNK::Const(_) => PNK::Wildcard,\n PNK::Value(_) => PNK::Wildcard,\n PNK::Binary{\n specifier,\n value,\n size,\n remaining,\n } => {\n let remaining = remaining.map(|n| make_node_structural(nodes, node_pool, value_pool, bind_mapping, map_value, n));\n PNK::Binary {\n specifier,\n value: make_node_structural(nodes, node_pool, value_pool, bind_mapping, map_value, value),\n size: size.map(&mut map_value),\n remaining,\n }\n },\n PNK::Tuple(nodes_list) => {\n let mut nodes_buf: Vec<_> = nodes_list.as_slice(node_pool).iter().cloned().collect();\n for node in nodes_buf.iter_mut() {\n *node = make_node_structural(nodes, node_pool, value_pool, bind_mapping, map_value, *node);\n }\n\n let mut nodes_new = EntityList::new();\n for node in nodes_buf.iter() {\n nodes_new.push(*node, node_pool);\n }\n\n PNK::Tuple(nodes_new)\n },\n PNK::List { head, tail } => {\n PNK::List {\n head: make_node_structural(nodes, node_pool, value_pool, bind_mapping, map_value, head),\n tail: make_node_structural(nodes, node_pool, value_pool, bind_mapping, map_value, tail),\n }\n },\n PNK::Map { keys, values } => {\n let keys_buf: Vec<_> = keys.as_slice(value_pool).iter().cloned().collect();\n let mut keys_new = EntityList::new();\n for value in keys_buf.iter() {\n keys_new.push(map_value(*value), value_pool);\n }\n\n let mut values_buf: Vec<_> = values.as_slice(node_pool).iter().cloned().collect();\n for node in values_buf.iter_mut() {\n *node = make_node_structural(nodes, node_pool, value_pool, bind_mapping, map_value, *node);\n }\n\n let mut values_new = EntityList::new();\n for node in values_buf.iter() {\n values_new.push(*node, node_pool);\n }\n\n PNK::Map {\n keys,\n values: values_new,\n }\n }\n };\n node_data.kind = Some(new_kind);\n\n let new_node = nodes.push(node_data);\n if let Some(entry) = bind_mapping.get_mut(&node) {\n *entry = new_node;\n }\n\n new_node\n }\n\n for node in root_nodes.iter_mut() {\n *node = make_node_structural(&mut self.nodes, &mut self.node_pool, &mut self.value_pool,\n &mut bind_mapping, &mut map_value, *node);\n }\n let mut root_nodes_new = EntityList::new();\n for node in root_nodes.iter() {\n root_nodes_new.push(*node, &mut self.node_pool);\n }\n\n let new_data = PatternClauseData {\n span: clause_data.span,\n root_nodes: root_nodes_new,\n\n node_binds_keys: {\n let mut new = EntityList::new();\n\n let len = clause_data.node_binds_keys.as_slice(&self.node_pool).len();\n for idx in 0..len {\n let node = clause_data.node_binds_keys.as_slice(&self.node_pool)[idx];\n new.push(bind_mapping[&node], &mut self.node_pool);\n }\n\n new\n },\n node_binds_vals: {\n let mut new = EntityList::new();\n\n let len = clause_data.node_binds_vals.as_slice(&self.value_pool).len();\n for idx in 0..len {\n let value = clause_data.node_binds_vals.as_slice(&self.value_pool)[idx];\n new.push(map_value(value), &mut self.value_pool);\n }\n\n new\n },\n\n binds: {\n let mut new = EntityList::new();\n\n let len = clause_data.binds.as_slice(&self.node_pool).len();\n for idx in 0..len {\n let node = clause_data.binds.as_slice(&self.node_pool)[idx];\n new.push(bind_mapping[&node], &mut self.node_pool);\n }\n\n new\n },\n\n values: {\n let mut new = EntityList::new();\n\n let len = clause_data.values.as_slice(&self.value_pool).len();\n for idx in 0..len {\n let value = clause_data.values.as_slice(&self.value_pool)[idx];\n new.push(map_value(value), &mut self.value_pool);\n }\n\n new\n },\n\n finished: true,\n };\n\n self.clauses.push(new_data)\n }\n}\n" }, { "path": "libeir_ir/src/text/ast/mod.rs", "content": "use libeir_diagnostics::SourceSpan;\nuse libeir_intern::Ident;\n\nuse crate::constant::Integer;\nuse crate::{BasicType, BinOp, BinaryEntrySpecifier};\n\n#[derive(Debug, PartialEq, Eq)]\npub enum DynToken {\n Parens(Vec, SourceSpan),\n Braces(Vec, SourceSpan),\n MapBraces(Vec, SourceSpan),\n SquareBrackets(Vec, SourceSpan),\n AngleBrackets(Vec, SourceSpan),\n\n Ident(Ident),\n Variable(Ident),\n\n Atom(Ident),\n Integer(Integer, SourceSpan),\n Float(Ident),\n String(Ident),\n\n Percent(SourceSpan),\n Colon(SourceSpan),\n SemiColon(SourceSpan),\n Comma(SourceSpan),\n Question(SourceSpan),\n ForwardSlash(SourceSpan),\n Equals(SourceSpan),\n EqualsEquals(SourceSpan),\n FatArrow(SourceSpan),\n Underscore(SourceSpan),\n Pipe(SourceSpan),\n At(SourceSpan),\n Bang(SourceSpan),\n\n Unpack(SourceSpan),\n Unreachable(SourceSpan),\n Arity(SourceSpan),\n IfBool(SourceSpan),\n TraceCaptureRaw(SourceSpan),\n Value(SourceSpan),\n Match(SourceSpan),\n Type(SourceSpan),\n Case(SourceSpan),\n Guard(SourceSpan),\n Except(SourceSpan),\n}\n\nimpl DynToken {\n pub fn span(&self) -> SourceSpan {\n use DynToken::*;\n match self {\n Parens(_, span) => *span,\n Braces(_, span) => *span,\n MapBraces(_, span) => *span,\n SquareBrackets(_, span) => *span,\n AngleBrackets(_, span) => *span,\n\n Ident(ident) => ident.span,\n Variable(ident) => ident.span,\n\n Atom(ident) => ident.span,\n Integer(_, span) => *span,\n Float(ident) => ident.span,\n String(ident) => ident.span,\n\n Percent(span) => *span,\n Colon(span) => *span,\n SemiColon(span) => *span,\n Comma(span) => *span,\n Question(span) => *span,\n ForwardSlash(span) => *span,\n Equals(span) => *span,\n EqualsEquals(span) => *span,\n FatArrow(span) => *span,\n Underscore(span) => *span,\n Pipe(span) => *span,\n At(span) => *span,\n Bang(span) => *span,\n\n Unpack(span) => *span,\n Unreachable(span) => *span,\n Arity(span) => *span,\n IfBool(span) => *span,\n TraceCaptureRaw(span) => *span,\n Value(span) => *span,\n Match(span) => *span,\n Type(span) => *span,\n Case(span) => *span,\n Guard(span) => *span,\n Except(span) => *span,\n }\n }\n}\n\n#[derive(Debug, PartialEq, Eq)]\npub struct Module {\n pub span: SourceSpan,\n pub name: Ident,\n pub items: Vec,\n}\n\n#[derive(Debug, PartialEq, Eq)]\npub enum ModuleItem {\n Function(Function),\n}\n\n#[derive(Debug, PartialEq, Eq)]\npub struct Function {\n pub span: SourceSpan,\n pub name: Ident,\n pub arity: Integer,\n pub items: Vec,\n}\n\n#[derive(Debug, PartialEq, Eq)]\npub enum FunctionItem {\n Label(Label),\n Meta(Meta),\n Assignment(Assignment),\n Op(Op),\n}\n\n#[derive(Debug, PartialEq, Eq)]\npub struct Meta {\n pub span: SourceSpan,\n pub name: Ident,\n pub tokens: Vec,\n}\n\n#[derive(Debug, PartialEq, Eq)]\npub struct Label {\n pub span: SourceSpan,\n pub name: Value,\n // Only Value::Value is supported here\n pub args: Vec,\n}\n\n#[derive(Debug, PartialEq, Eq)]\npub struct Assignment {\n pub span: SourceSpan,\n pub lhs: Value,\n pub rhs: Value,\n}\n\n#[derive(Debug, PartialEq, Eq)]\npub enum Op {\n Dyn(Ident, Vec),\n UnpackValueList(UnpackValueListOp),\n CallControlFlow(CallControlFlowOp),\n CallFunction(CallFunctionOp),\n IfBool(IfBoolOp),\n TraceCaptureRaw(TraceCaptureRawOp),\n Match(MatchOp),\n Case(CaseOp),\n Unreachable,\n}\n\n#[derive(Debug, PartialEq, Eq)]\npub struct CaseOp {\n pub span: SourceSpan,\n pub value: Value,\n pub entries: Vec,\n pub no_match: Option,\n}\n\n#[derive(Debug, PartialEq, Eq)]\npub struct CaseEntry {\n pub span: SourceSpan,\n pub patterns: Vec,\n pub args: Vec,\n pub guard: Value,\n pub target: Value,\n}\n\n#[derive(Debug, PartialEq, Eq)]\npub enum CasePattern {\n Value(Value),\n Binding {\n name: Ident,\n pattern: Box,\n },\n ListCell {\n head: Box,\n tail: Box,\n },\n Tuple {\n elements: Vec,\n },\n Wildcard,\n}\n\n#[derive(Debug, PartialEq, Eq)]\npub struct MatchOp {\n pub span: SourceSpan,\n pub value: Value,\n pub entries: Vec,\n}\n#[derive(Debug, PartialEq, Eq)]\npub struct MatchEntry {\n pub span: SourceSpan,\n pub target: Value,\n pub kind: MatchKind,\n}\n#[derive(Debug, PartialEq, Eq)]\npub enum MatchKind {\n Value(Value),\n Type(BasicType),\n Binary(BinaryEntrySpecifier, Option),\n Tuple(usize),\n ListCell,\n MapItem(Value),\n Wildcard,\n}\n\n#[derive(Debug, PartialEq, Eq)]\npub struct UnpackValueListOp {\n pub span: SourceSpan,\n pub arity: usize,\n pub value: Value,\n pub block: Value,\n}\n\n#[derive(Debug, PartialEq, Eq)]\npub struct CallControlFlowOp {\n pub span: SourceSpan,\n pub target: Value,\n pub args: Vec,\n}\n#[derive(Debug, PartialEq, Eq)]\npub struct CallFunctionOp {\n pub span: SourceSpan,\n pub target: Value,\n pub ret: Value,\n pub thr: Value,\n pub args: Vec,\n}\n\n#[derive(Debug, PartialEq, Eq)]\npub struct IfBoolOp {\n pub span: SourceSpan,\n pub value: Value,\n pub tru: Value,\n pub fal: Value,\n pub or: Option,\n}\n\n#[derive(Debug, PartialEq, Eq)]\npub struct TraceCaptureRawOp {\n pub span: SourceSpan,\n pub then: Value,\n}\n\n#[derive(Debug, PartialEq, Eq)]\npub enum Value {\n // Atomics\n Value(Ident),\n Block(Ident),\n Atom(Ident),\n Integer(Integer),\n Nil,\n\n // Composites\n ValueList(Vec),\n Tuple(Vec),\n List(Vec, Option>),\n CaptureFunction(Box, Box, Box),\n BinOp(Box, BinOp, Box),\n}\nimpl Value {\n pub fn value(&self) -> Option {\n match self {\n Value::Value(sym) => Some(*sym),\n _ => None,\n }\n }\n pub fn block(&self) -> Option {\n match self {\n Value::Block(sym) => Some(*sym),\n _ => None,\n }\n }\n}\n" }, { "path": "libeir_ir/src/text/ast/raise.rs", "content": "use std::collections::BTreeMap;\n\nuse libeir_intern::Ident;\n\nuse crate::Function;\nuse crate::{Block, Value};\n//use crate::OpKind;\nuse crate::text::ast;\n\n#[allow(dead_code)]\nstruct RaiseCtx {\n block_names: BTreeMap,\n value_names: BTreeMap,\n}\nimpl RaiseCtx {\n pub fn block_name(&mut self, _block: Block) -> Ident {\n unimplemented!()\n }\n\n pub fn value_name(&mut self, _value: Value) -> Ident {\n unimplemented!()\n }\n}\n\nimpl Function {\n pub fn raise(&self) -> ast::Function {\n let graph = self.block_graph();\n\n let mut ctx = RaiseCtx {\n block_names: BTreeMap::new(),\n value_names: BTreeMap::new(),\n };\n let mut items = Vec::new();\n\n for block in graph.dfs_iter() {\n // Block label\n items.push(ast::FunctionItem::Label(ast::Label {\n name: ast::Value::Block(ctx.block_name(block)),\n args: self\n .block_args(block)\n .iter()\n .map(|v| ast::Value::Value(ctx.value_name(*v)))\n .collect(),\n }));\n\n //if let Some(kind) = self.block_kind(block) {\n // match kind {\n // OpKind::Call => {\n // //items.push(ast::FunctionItem::Op(ast::Op::Call(ast::CallOp {\n // //\n // //})));\n // }\n // _ => unimplemented!(),\n // }\n //}\n }\n\n ast::Function {\n name: self.ident().name,\n arity: self.ident().arity.into(),\n items,\n }\n }\n}\n" }, { "path": "libeir_ir/src/text/dot_printer.rs", "content": "use std::marker::PhantomData;\n\nuse super::printer as pr;\nuse super::printer::{FormatState, FunctionFormatData};\nuse crate::Function;\nuse pretty::Arena;\n\nuse libeir_util_dot_graph::GraphPrinter;\n\nuse petgraph::visit::{Dfs, IntoNeighbors};\n\npub fn function_into_graph_printer(fun: &Function, g: &mut GraphPrinter)\nwhere\n O: std::fmt::Write,\n{\n let mut buf = String::new();\n\n let mut config = pr::FormatConfig {\n width: 80,\n print_locations: true,\n block_iterator_config: pr::DfsBlockIteratorConfig,\n value_formatter: pr::StandardValueFormatter,\n block_value_layout: pr::ReferencePrimopBlockValueLayout::default(),\n };\n let mut state = FormatState {\n function: fun,\n nesting: 0,\n };\n\n let arena = Arena::new();\n let mut ctx = FunctionFormatData {\n arena: &arena,\n buf: String::new(),\n value_buf: Vec::new(),\n config: PhantomData,\n };\n\n let block_graph = fun.block_graph();\n let mut block_dfs = Dfs::new(&block_graph, fun.block_entry());\n\n while let Some(block) = block_dfs.next(&block_graph) {\n let block_val = fun.block_value(block);\n\n let doc = ctx.block_to_doc(&mut config, &mut state, block);\n buf.clear();\n doc.render_fmt(80, &mut buf).unwrap();\n g.node(block_val, &buf);\n\n for out in block_graph.neighbors(block) {\n let out_val = fun.block_value(out);\n g.edge(block_val, out_val, \"\");\n }\n }\n}\n\npub fn function_to_dot(fun: &Function) -> String {\n let mut g = GraphPrinter::new();\n function_into_graph_printer(fun, &mut g);\n g.finish().unwrap()\n}\n" }, { "path": "libeir_ir/src/text/lower/location.rs", "content": "use crate::text::parse_dyn::{DynParserError, ParseCtx};\nuse libeir_intern::Symbol;\nuse libeir_util_number::ToPrimitive;\nuse std::convert::TryInto;\n\npub struct ParsedTerminalLocation {\n pub file: Option,\n pub line: Option,\n pub module: Option,\n pub function: Option,\n}\n\npub struct ParsedLocation {\n pub terminals: Vec,\n}\n\npub fn parse_terminal_location(\n ctx: &mut ParseCtx,\n) -> Result {\n let mut module = None;\n let mut function = None;\n let mut file = None;\n let mut line = None;\n\n if let Ok(module_i) = ctx.try_parse(|ctx| ctx.tok_string()) {\n module = Some(module_i.name);\n if ctx.try_parse(|ctx| ctx.tok_colon()).is_ok() {\n function = Some(ctx.tok_string()?.name);\n }\n }\n\n if ctx.try_parse(|ctx| ctx.tok_at()).is_ok() {\n file = Some(ctx.tok_string()?.name);\n if ctx.try_parse(|ctx| ctx.tok_colon()).is_ok() {\n line = Some(ctx.tok_integer()?.0);\n }\n }\n\n Ok(ParsedTerminalLocation {\n file,\n line: line.map(|i| i.to_u32().unwrap()),\n module,\n function,\n })\n}\n\npub fn parse_location(ctx: &mut ParseCtx) -> Result {\n let (toks, span) = ctx.tok_square_brackets()?;\n let mut ictx = ParseCtx::new(toks, span);\n\n let locs = ictx.comma(parse_terminal_location)?;\n ictx.eof()?;\n\n ctx.eof()?;\n\n Ok(ParsedLocation { terminals: locs })\n}\n" }, { "path": "libeir_ir/src/text/lower/mod.rs", "content": "use std::collections::HashMap;\n\nuse libeir_diagnostics::{Diagnostic, Label, SourceSpan, ToDiagnostic};\nuse libeir_intern::Ident;\nuse libeir_util_datastructures::hashmap_stack::HashMapStack;\nuse libeir_util_parse::ErrorReceiver;\n\nuse snafu::Snafu;\n\nuse crate::text::ast;\nuse crate::{Block, Value};\nuse crate::{Function, FunctionBuilder, FunctionIdent, Module};\nuse crate::{PatternContainer, PatternNode};\n\nmod location;\n\ntype ErrCollector<'a> = &'a mut dyn ErrorReceiver;\n\npub struct LowerContext<'a, 'b> {\n builder: &'a mut FunctionBuilder<'b>,\n errors: ErrCollector<'a>,\n scope: &'a mut HashMapStack,\n}\n\nimpl<'a, 'b> LowerContext<'a, 'b> {\n pub fn error(&mut self, diag: T) {\n self.errors.error(LowerError::DynError {\n diagnostic: diag.to_diagnostic(),\n })\n }\n}\n\n#[derive(Debug, Snafu)]\npub enum LowerError {\n DuplicateDefinititon {\n previous: SourceSpan,\n current: SourceSpan,\n },\n\n LabelNotFinalized {\n span: SourceSpan,\n },\n\n OpOutsideOfLabel {},\n\n UndefinedVariable {\n span: SourceSpan,\n },\n\n UndefinedBlock {\n span: SourceSpan,\n },\n\n UndefinedBind {\n span: SourceSpan,\n },\n\n UnknownMeta {\n span: SourceSpan,\n name: Ident,\n },\n\n UnknownDyn {\n span: SourceSpan,\n },\n DynError {\n diagnostic: Diagnostic,\n },\n}\n\nimpl ToDiagnostic for LowerError {\n fn to_diagnostic(&self) -> Diagnostic {\n let msg = self.to_string();\n match self {\n LowerError::DuplicateDefinititon { previous, current } => Diagnostic::error()\n .with_message(\"duplicate identifier definition\")\n .with_labels(vec![\n Label::primary(current.source_id(), *current)\n .with_message(\"attempted redefinition\"),\n Label::secondary(previous.source_id(), *previous)\n .with_message(\"previously defined here\"),\n ]),\n LowerError::LabelNotFinalized { span } => Diagnostic::error()\n .with_message(\"label not finalized\")\n .with_labels(vec![Label::primary(span.source_id(), *span)\n .with_message(\"block does not end with an operation\")]),\n LowerError::UndefinedVariable { span } => Diagnostic::error()\n .with_message(\"undefined variable name\")\n .with_labels(vec![Label::primary(span.source_id(), *span)\n .with_message(\"variable name was not defined in the IR\")]),\n LowerError::UndefinedBlock { span } => Diagnostic::error()\n .with_message(\"undefined block name\")\n .with_labels(vec![Label::primary(span.source_id(), *span)\n .with_message(\"block name was not defined in the IR\")]),\n LowerError::UnknownMeta { name, .. } => Diagnostic::error()\n .with_message(\"unknown meta entry\")\n .with_labels(vec![Label::primary(name.span.source_id(), name.span)\n .with_message(\"meta entry is unknown to the compiler\")]),\n LowerError::UnknownDyn { span } => Diagnostic::error()\n .with_message(\"unknown dynop identifier\")\n .with_labels(vec![Label::primary(span.source_id(), *span)\n .with_message(\"no parser exists for dynop in current dialect\")]),\n LowerError::DynError { diagnostic } => diagnostic.clone(),\n _ => Diagnostic::error().with_message(msg),\n }\n }\n}\n\npub struct LowerMap {\n map: HashMap,\n block_map: HashMap,\n}\nimpl LowerMap {\n pub fn get_value(&self, ident: &str) -> Value {\n self.map[&Name::Value(Ident::from_str(ident))]\n }\n\n pub fn get_block(&self, ident: &str) -> Block {\n self.block_map[&Ident::from_str(ident)]\n }\n}\n\nimpl ast::Module {\n pub fn lower(&self, errors: ErrCollector) -> Result {\n let mut module = Module::new(self.name);\n\n for item in self.items.iter() {\n match item {\n ast::ModuleItem::Function(fun) => {\n let fun_ir = module.add_function(\n SourceSpan::UNKNOWN,\n fun.name,\n fun.arity.to_usize().unwrap(),\n );\n let mut b = fun_ir.function_mut().builder();\n fun.lower_into(errors, &mut b)?;\n }\n }\n }\n\n Ok(module)\n }\n}\n\n#[derive(Debug, Eq, PartialEq, Hash, Copy, Clone)]\npub enum Name {\n Value(Ident),\n Block(Ident),\n}\nimpl Name {\n pub fn span(&self) -> SourceSpan {\n match self {\n Name::Value(ident) => ident.span,\n Name::Block(ident) => ident.span,\n }\n }\n}\n\nfn insert_check_duplicate(\n errors: ErrCollector,\n scope: &mut HashMapStack,\n name: Name,\n value: Value,\n) -> Result<(), ()> {\n if let Some((span, _)) = scope.get(&name) {\n errors.error(LowerError::DuplicateDefinititon {\n previous: *span,\n current: name.span(),\n });\n Err(())\n } else {\n scope.insert(name, (name.span(), value));\n Ok(())\n }\n}\n\nimpl ast::Function {\n pub fn lower(&self, errors: ErrCollector, module: Ident) -> Result<(Function, LowerMap), ()> {\n let ident = FunctionIdent {\n module,\n name: self.name,\n arity: self.arity.to_usize().unwrap(),\n };\n let mut fun = Function::new(SourceSpan::UNKNOWN, ident);\n\n let mut b = fun.builder();\n let map = self.lower_into(errors, &mut b)?;\n\n Ok((fun, map))\n }\n\n pub fn lower_into(\n &self,\n errors: ErrCollector,\n b: &mut FunctionBuilder,\n ) -> Result {\n let mut blocks: HashMap = HashMap::new();\n let mut scope: HashMapStack = HashMapStack::new();\n scope.push();\n\n let mut location = None;\n\n // 1. Create blocks and their args\n let mut first_block = None;\n for item in self.items.iter() {\n match item {\n ast::FunctionItem::Label(label) => {\n let block_name = label.name.block().unwrap();\n let block = b.block_insert();\n\n if let Some(loc) = location {\n b.block_set_location(block, loc);\n location = None;\n }\n\n insert_check_duplicate(\n errors,\n &mut scope,\n Name::Block(block_name),\n b.value(block),\n )?;\n scope.insert(Name::Block(block_name), (block_name.span, b.value(block)));\n blocks.insert(block_name, (block_name.span, block));\n\n for arg in label.args.iter() {\n let arg_name = arg.value().unwrap();\n let arg = b.block_arg_insert(block);\n insert_check_duplicate(errors, &mut scope, Name::Value(arg_name), arg)?;\n scope.insert(Name::Value(arg_name), (block_name.span, arg));\n }\n\n if first_block.is_none() {\n first_block = Some(block);\n }\n }\n ast::FunctionItem::Meta(meta) => match &*meta.name.as_str() {\n \"location\" => {\n let mut ctx = super::parse_dyn::ParseCtx::new(&meta.tokens, meta.span);\n match self::location::parse_location(&mut ctx) {\n Ok(loc_desc) => {\n let mut terminals = vec![];\n for term_desc in loc_desc.terminals.iter() {\n let term = b.fun_mut().locations.terminal(\n term_desc.file.map(|v| v.to_string()),\n term_desc.line,\n term_desc.module.map(|v| v.to_string()),\n term_desc.function.map(|v| v.to_string()),\n meta.span,\n );\n terminals.push(term);\n }\n let loc = b.fun_mut().locations.from_terminals(&terminals);\n location = Some(loc);\n }\n Err(err) => errors.error(LowerError::DynError {\n diagnostic: err.to_diagnostic(),\n }),\n }\n }\n _ => errors.error(LowerError::UnknownMeta {\n span: meta.span,\n name: meta.name,\n }),\n },\n _ => (),\n }\n }\n\n b.block_set_entry(first_block.unwrap());\n\n // 2. Create assignments and bodies\n let mut current_block: Option<(SourceSpan, Block)> = None;\n for item in self.items.iter() {\n match item {\n ast::FunctionItem::Label(label) => {\n let block_name = label.name.block().unwrap();\n\n if let Some((span, _)) = current_block {\n errors.error(LowerError::LabelNotFinalized { span });\n return Err(());\n }\n\n current_block = Some((block_name.span, blocks[&block_name].1));\n scope.push();\n }\n ast::FunctionItem::Meta(meta) => match &*meta.name.as_str() {\n \"location\" => {}\n _ => errors.error(LowerError::UnknownMeta {\n span: meta.span,\n name: meta.name,\n }),\n },\n ast::FunctionItem::Assignment(assign) => {\n let lhs = assign.lhs.value().unwrap();\n let value = lower_value(errors, b, &mut scope, &assign.rhs)?;\n scope.insert(Name::Value(lhs), (lhs.span, value));\n }\n ast::FunctionItem::Op(op) => {\n if let Some((_, block)) = current_block {\n lower_operation(b, errors, &mut scope, block, op)?;\n } else {\n errors.error(LowerError::OpOutsideOfLabel {});\n return Err(());\n }\n\n scope.pop();\n\n current_block = None;\n }\n }\n }\n\n if let Some((span, _)) = current_block {\n errors.error(LowerError::LabelNotFinalized { span });\n return Err(());\n }\n\n assert!(scope.height() == 1);\n let top = scope.layer(0);\n\n Ok(LowerMap {\n map: top.iter().map(|(k, (_, v))| (*k, *v)).collect(),\n block_map: blocks.iter().map(|(k, (_, v))| (*k, *v)).collect(),\n })\n }\n}\n\nfn lower_operation(\n b: &mut FunctionBuilder,\n errors: ErrCollector,\n scope: &mut HashMapStack,\n block: Block,\n op: &ast::Op,\n) -> Result<(), ()> {\n match op {\n ast::Op::Dyn(ident, opts) => {\n let mut ctx = LowerContext {\n builder: b,\n errors,\n scope,\n };\n\n if let Some(parser) = crate::dialect::NORMAL.get_op_parser(ident.name) {\n parser.parse(&mut ctx, block, opts)?;\n } else {\n errors.error(LowerError::UnknownDyn { span: ident.span });\n }\n }\n ast::Op::CallControlFlow(call) => {\n let target = lower_value(errors, b, scope, &call.target)?;\n let args: Result, _> = call\n .args\n .iter()\n .map(|v| lower_value(errors, b, scope, v))\n .collect();\n b.op_call_flow(block, target, &args?);\n }\n ast::Op::CallFunction(call) => {\n let target = lower_value(errors, b, scope, &call.target)?;\n\n let ret = lower_value(errors, b, scope, &call.ret)?;\n let thr = lower_value(errors, b, scope, &call.thr)?;\n\n let args: Result, _> = call\n .args\n .iter()\n .map(|v| lower_value(errors, b, scope, v))\n .collect();\n b.op_call_function_next(SourceSpan::UNKNOWN, block, target, ret, thr, &args?);\n }\n ast::Op::UnpackValueList(list) => {\n let target = lower_value(errors, b, scope, &list.block)?;\n let value = lower_value(errors, b, scope, &list.value)?;\n b.op_unpack_value_list_next(block, target, value, list.arity);\n }\n ast::Op::IfBool(if_bool) => {\n let value = lower_value(errors, b, scope, &if_bool.value)?;\n let tru = lower_value(errors, b, scope, &if_bool.tru)?;\n let fal = lower_value(errors, b, scope, &if_bool.fal)?;\n if let Some(or) = &if_bool.or {\n let or = lower_value(errors, b, scope, or)?;\n b.op_if_bool_next(SourceSpan::UNKNOWN, block, tru, fal, or, value);\n } else {\n b.op_if_bool_strict_next(SourceSpan::UNKNOWN, block, tru, fal, value);\n }\n }\n ast::Op::TraceCaptureRaw(trace_op) => {\n let then = lower_value(errors, b, scope, &trace_op.then)?;\n b.op_trace_capture_raw_next(SourceSpan::UNKNOWN, block, then);\n }\n ast::Op::Match(match_op) => {\n let mut builder = b.op_match_build(SourceSpan::UNKNOWN);\n for entry in match_op.entries.iter() {\n let next = lower_value(errors, b, scope, &entry.target)?;\n match &entry.kind {\n ast::MatchKind::Value(v) => {\n let v_v = lower_value(errors, b, scope, v)?;\n builder.push_value_next(next, v_v, b);\n }\n ast::MatchKind::ListCell => {\n builder.push_list_cell_next(next, b);\n }\n ast::MatchKind::Wildcard => {\n builder.push_wildcard_next(next, b);\n }\n ast::MatchKind::Type(typ) => {\n builder.push_type_next(next, *typ, b);\n }\n ast::MatchKind::MapItem(k) => {\n let k_v = lower_value(errors, b, scope, k)?;\n builder.push_map_item_next(next, k_v, b);\n }\n ast::MatchKind::Tuple(n) => {\n builder.push_tuple_next(next, *n, b);\n }\n s => unimplemented!(\"{:?}\", s),\n }\n }\n\n let match_val = lower_value(errors, b, scope, &match_op.value)?;\n builder.finish(block, match_val, b);\n }\n ast::Op::Unreachable => {\n b.op_unreachable(SourceSpan::UNKNOWN, block);\n }\n ast::Op::Case(case_op) => {\n use crate::operation::case::Case;\n let value = lower_value(errors, b, scope, &case_op.value)?;\n\n let mut binds = HashMap::new();\n\n let mut case_b = Case::builder();\n\n for entry in case_op.entries.iter() {\n binds.clear();\n let clause = case_b.container.clause_start(SourceSpan::UNKNOWN);\n\n for pattern in entry.patterns.iter() {\n let pat = lower_case_pattern(\n errors,\n &mut case_b.container,\n b,\n scope,\n &mut binds,\n pattern,\n )?;\n case_b.container.clause_node_push(clause, pat);\n }\n\n for bind in entry.args.iter() {\n if let Some(node) = binds.get(bind) {\n case_b.container.clause_bind_push(clause, node.1);\n } else {\n errors.error(LowerError::UndefinedBind { span: bind.span });\n return Err(());\n }\n }\n\n case_b.container.clause_finish(clause);\n\n let guard = lower_value(errors, b, scope, &entry.guard)?;\n let target = lower_value(errors, b, scope, &entry.target)?;\n\n case_b.push_clause(clause, guard, target, b);\n }\n\n if let Some(no_match) = case_op.no_match.as_ref() {\n let val = lower_value(errors, b, scope, no_match)?;\n case_b.no_match = Some(val);\n }\n\n case_b.match_on = Some(value);\n case_b.finish(block, b);\n }\n }\n\n Ok(())\n}\n\nfn lower_case_pattern(\n errors: ErrCollector,\n pat: &mut PatternContainer,\n b: &mut FunctionBuilder,\n scope: &mut HashMapStack,\n binds: &mut HashMap,\n pattern: &ast::CasePattern,\n) -> Result {\n match pattern {\n ast::CasePattern::Binding { name, pattern } => {\n let child = lower_case_pattern(errors, pat, b, scope, binds, pattern)?;\n if binds.contains_key(name) {\n errors.error(LowerError::DuplicateDefinititon {\n current: name.span,\n previous: binds[name].0,\n });\n return Err(());\n }\n binds.insert(*name, (name.span, child));\n Ok(child)\n }\n ast::CasePattern::Wildcard => {\n let node = pat.node_empty(Some(SourceSpan::UNKNOWN));\n pat.wildcard(node);\n Ok(node)\n }\n _ => unimplemented!(),\n }\n}\n\nfn lower_value(\n errors: ErrCollector,\n b: &mut FunctionBuilder,\n scope: &mut HashMapStack,\n val: &ast::Value,\n) -> Result {\n match val {\n ast::Value::Value(i) => {\n if let Some((_, val)) = scope.get(&Name::Value(*i)) {\n Ok(*val)\n } else {\n errors.error(LowerError::UndefinedVariable { span: i.span });\n return Err(());\n }\n }\n ast::Value::Block(b) => {\n if let Some((_, val)) = scope.get(&Name::Block(*b)) {\n Ok(*val)\n } else {\n errors.error(LowerError::UndefinedBlock { span: b.span });\n return Err(());\n }\n }\n ast::Value::Atom(atom) => {\n // TODO escapes\n Ok(b.value(crate::constant::AtomTerm(atom.name)))\n }\n ast::Value::Integer(int) => match int {\n crate::constant::Integer::Small(int) => Ok(b.value(*int)),\n crate::constant::Integer::Big(int) => Ok(b.value(int.clone())),\n },\n ast::Value::Nil => Ok(b.value(crate::constant::NilTerm)),\n ast::Value::ValueList(list) => {\n let v_buf: Result, _> = list\n .iter()\n .map(|v| lower_value(errors, b, scope, v))\n .collect();\n Ok(b.prim_value_list(&v_buf?))\n }\n ast::Value::Tuple(tup) => {\n let v_buf: Result, _> = tup\n .iter()\n .map(|v| lower_value(errors, b, scope, v))\n .collect();\n Ok(b.prim_tuple(SourceSpan::UNKNOWN, &v_buf?))\n }\n ast::Value::CaptureFunction(m, f, a) => {\n let m_v = lower_value(errors, b, scope, &*m)?;\n let f_v = lower_value(errors, b, scope, &*f)?;\n let a_v = lower_value(errors, b, scope, &*a)?;\n\n Ok(b.prim_capture_function(SourceSpan::UNKNOWN, m_v, f_v, a_v))\n }\n ast::Value::BinOp(lhs, op, rhs) => {\n let lhs_v = lower_value(errors, b, scope, &*lhs)?;\n let rhs_v = lower_value(errors, b, scope, &*rhs)?;\n\n Ok(b.prim_binop(SourceSpan::UNKNOWN, *op, lhs_v, rhs_v))\n }\n ast::Value::List(head, tail) => {\n let mut acc = tail\n .as_ref()\n .map(|v| lower_value(errors, b, scope, &*v))\n .transpose()?\n .unwrap_or(b.value(crate::constant::NilTerm));\n for v in head.iter().rev() {\n let new_val = lower_value(errors, b, scope, &*v)?;\n acc = b.prim_list_cell(SourceSpan::UNKNOWN, new_val, acc);\n }\n Ok(acc)\n }\n }\n}\n" }, { "path": "libeir_ir/src/text/mod.rs", "content": "//pub mod printer;\n//pub use printer::{ ToEirText, ToEirTextFun, ToEirTextContext };\n\npub mod printer;\n\npub mod dot_printer;\npub use dot_printer::function_to_dot;\n\nmod lower;\npub use lower::{LowerContext, LowerError, LowerMap};\n\npub mod parse_dyn;\n\n//pub trait TextFormatter {\n// // TODO add result\n// fn write(&mut self, text: &str);\n// fn newline(&mut self);\n//\n// fn enter_indent(&mut self, dist: usize);\n// fn exit_indent(&mut self, dist: usize);\n//}\n//\n//pub struct BufferTextFormatter {\n// indent: usize,\n// buf: String,\n//}\n//\n//impl Default for BufferTextFormatter {\n// fn default() -> Self {\n// BufferTextFormatter {\n// indent: 0,\n// buf: String::new(),\n// }\n// }\n//}\n//\n//impl BufferTextFormatter {\n//\n// pub fn new() -> Self {\n// Self::default()\n// }\n//\n// pub fn clear(&mut self) {\n// self.indent = 0;\n// self.buf.clear();\n// }\n//\n//}\n//\n//impl TextFormatter for BufferTextFormatter {\n//\n// fn write(&mut self, text: &str) {\n// self.buf.push_str(text);\n// }\n// fn newline(&mut self) {\n// self.buf.push('\\n');\n// for _ in 0..self.indent {\n// self.buf.push(' ');\n// }\n// }\n//\n// fn enter_indent(&mut self, _dist: usize) {\n// self.indent += 1;\n// }\n// fn exit_indent(&mut self, _dist: usize) {\n// self.indent -= 1;\n// }\n//\n//}\n\npub mod parser;\npub use parser::{\n function as parse_function, function_map as parse_function_map,\n function_map_unwrap as parse_function_map_unwrap, function_unwrap as parse_function_unwrap,\n module as parse_module, module_unwrap as parse_module_unwrap,\n};\n\npub mod ast;\n" }, { "path": "libeir_ir/src/text/parse_dyn/mod.rs", "content": "use libeir_diagnostics::{Diagnostic, Label, SourceSpan, ToDiagnostic};\nuse libeir_intern::{Ident, Symbol};\nuse snafu::Snafu;\n\nuse crate::constant::Integer;\n\nuse super::ast::{DynToken, Value};\n\n#[derive(Copy, Clone)]\npub enum Nesting {\n Top,\n\n Parens(SourceSpan),\n Braces(SourceSpan),\n MapBraces(SourceSpan),\n SquareBrackets(SourceSpan),\n AngleBrackets(SourceSpan),\n}\n\npub enum Token {\n ParenOpen,\n ParenClose,\n BraceOpen,\n BraceClose,\n MapBraceOpen,\n SquareBracketOpen,\n SquareBracketClose,\n AngleBracketOpen,\n AngleBracketClose,\n\n Ident(Symbol),\n Variable(Symbol),\n\n Atom(Symbol),\n Integer(Integer),\n Float(Symbol),\n String(Symbol),\n\n Percent,\n Colon,\n SemiColon,\n Comma,\n Question,\n ForwardSlash,\n Equals,\n EqualsEquals,\n FatArrow,\n Underscore,\n Pipe,\n At,\n Bang,\n\n Unpack,\n Unreachable,\n Arity,\n IfBool,\n TraceCaptureRaw,\n Value,\n Match,\n Type,\n Case,\n Guard,\n Except,\n\n EOF,\n}\n\npub fn flatten_dyn_token(tok: &[DynToken]) -> Vec<(Token, SourceSpan)> {\n fn flatten(toks: &[DynToken], out: &mut Vec<(Token, SourceSpan)>) {\n for tok in toks {\n match tok {\n DynToken::Parens(inner, span) => {\n out.push((Token::ParenOpen, *span));\n flatten(inner, out);\n out.push((Token::ParenClose, *span));\n }\n DynToken::Braces(inner, span) => {\n out.push((Token::BraceOpen, *span));\n flatten(inner, out);\n out.push((Token::BraceClose, *span));\n }\n DynToken::MapBraces(inner, span) => {\n out.push((Token::MapBraceOpen, *span));\n flatten(inner, out);\n out.push((Token::BraceClose, *span));\n }\n DynToken::SquareBrackets(inner, span) => {\n out.push((Token::SquareBracketOpen, *span));\n flatten(inner, out);\n out.push((Token::SquareBracketClose, *span));\n }\n DynToken::AngleBrackets(inner, span) => {\n out.push((Token::AngleBracketOpen, *span));\n flatten(inner, out);\n out.push((Token::AngleBracketClose, *span));\n }\n\n DynToken::Ident(ident) => out.push((Token::Ident(ident.name), ident.span)),\n DynToken::Variable(ident) => out.push((Token::Variable(ident.name), ident.span)),\n DynToken::Atom(ident) => out.push((Token::Atom(ident.name), ident.span)),\n DynToken::Integer(int, span) => out.push((Token::Integer(int.clone()), *span)),\n DynToken::Float(ident) => out.push((Token::Float(ident.name), ident.span)),\n DynToken::String(ident) => out.push((Token::String(ident.name), ident.span)),\n\n DynToken::Percent(span) => out.push((Token::Percent, *span)),\n DynToken::Colon(span) => out.push((Token::Colon, *span)),\n DynToken::SemiColon(span) => out.push((Token::SemiColon, *span)),\n DynToken::Comma(span) => out.push((Token::Comma, *span)),\n DynToken::Question(span) => out.push((Token::Question, *span)),\n DynToken::ForwardSlash(span) => out.push((Token::ForwardSlash, *span)),\n DynToken::Equals(span) => out.push((Token::Equals, *span)),\n DynToken::EqualsEquals(span) => out.push((Token::EqualsEquals, *span)),\n DynToken::FatArrow(span) => out.push((Token::FatArrow, *span)),\n DynToken::Underscore(span) => out.push((Token::Underscore, *span)),\n DynToken::Pipe(span) => out.push((Token::Pipe, *span)),\n DynToken::At(span) => out.push((Token::At, *span)),\n DynToken::Bang(span) => out.push((Token::Bang, *span)),\n\n DynToken::Unpack(span) => out.push((Token::Unpack, *span)),\n DynToken::Unreachable(span) => out.push((Token::Unreachable, *span)),\n DynToken::Arity(span) => out.push((Token::Arity, *span)),\n DynToken::IfBool(span) => out.push((Token::IfBool, *span)),\n DynToken::TraceCaptureRaw(span) => out.push((Token::TraceCaptureRaw, *span)),\n DynToken::Value(span) => out.push((Token::Value, *span)),\n DynToken::Match(span) => out.push((Token::Match, *span)),\n DynToken::Type(span) => out.push((Token::Type, *span)),\n DynToken::Case(span) => out.push((Token::Case, *span)),\n DynToken::Guard(span) => out.push((Token::Guard, *span)),\n DynToken::Except(span) => out.push((Token::Except, *span)),\n }\n }\n }\n\n let mut out = vec![];\n flatten(tok, &mut out);\n out\n}\n\n//pub struct DynTokenLexer {\n// stack: Vec<(Nesting, &'a [DynToken], usize)>,\n// containing: SourceSpan,\n//}\n//\n//impl<'a> DynTokenLexer<'a> {\n// pub fn new(tokens: &'a [DynToken], containing: SourceSpan) -> Self {\n// DynTokenLexer {\n// stack: vec![Nesting::Top, tokens, 0],\n// containing,\n// }\n// }\n//}\n//\n//impl Iterator for DynTokenLexer {\n// type Item = (SourceIndex, Token, SourceIndex);\n// fn next(&mut self) -> Option {\n// enum Action<'b> {\n// PopLex(Nesting),\n// PushLex(Nesting, &'b [DynToken]),\n// }\n//\n// let action = match self.stack.last_mut() {\n// Some((nesting, tokens, cursor)) if cursor >= tokens.len() => Action::PopLex(*nesting),\n// Some((_, tokens, cursor)) => match &tokens[cursor] {\n// DynToken::Parens(children, span) => {\n// Action::PushLex(Nesting::Parens(*span), children)\n// }\n// DynToken::Braces(children, span) => {\n// Action::PushLex(Nesting::Braces(*span), children)\n// }\n// DynToken::MapBraces(children, span) => {\n// Action::PushLex(Nesting::MapBraces(*span), children)\n// }\n// DynToken::SquareBrackets(children, span) => {\n// Action::PushLex(Nesting::SquareBrackets(*span), children)\n// }\n// DynToken::AngleBrackets(children, span)\n// _ => unimplemented!(),\n// },\n// None => unreachable!(),\n// };\n//\n// match action {\n// Action::PopLex(Nesting::Top) => {\n// (self.containing.end(), Token::Eof, self.containing.end())\n// }\n// Action::PopLex(Nesting::Parens(span)) => {\n// self.stack.pop();\n// (span.start(), Token::ParenClose, span.end())\n// }\n// Action::PopLex(Nesting::Braces(span)) => {\n// self.stack.pop();\n// (span.start(), Token::BraceClose, span.end())\n// }\n// Action::PopLex(Nesting::MapBraces(span)) => {\n// self.stack.pop();\n// (span.start(), Token::BraceClose, span.end())\n// }\n// Action::PopLex(Nesting::SquareBrackets(span)) => {\n// self.stack.pop();\n// (span.start(), Token::SquareBracketClose, span.end())\n// }\n// Action::PopLex(Nesting::AngleBrackets(span)) => {\n// self.stack.pop();\n// (span.start(), Token::AngleBracketClose, span.end())\n// }\n// }\n// }\n//}\n\nmacro_rules! try_seq {\n ($ctx:expr) => {};\n}\n\nmacro_rules! container_token {\n ($name:ident, $ident:ident) => {\n pub fn $name(&mut self) -> Result<(&'a [DynToken], SourceSpan), DynParserError> {\n match self.pop()? {\n DynToken::$ident(inner, span) => Ok((inner, *span)),\n other => Err(DynParserError::UnexpectedToken { span: other.span() }),\n }\n }\n };\n}\n\npub struct ParseCtx<'a> {\n containing: SourceSpan,\n tokens: &'a [DynToken],\n pos: usize,\n}\n\n#[derive(Debug, Snafu)]\n#[snafu(visibility = \"pub\")]\npub enum DynParserError {\n UnexpectedToken { span: SourceSpan },\n UnexpectedEnd { span: SourceSpan },\n}\n\nimpl ToDiagnostic for DynParserError {\n fn to_diagnostic(&self) -> Diagnostic {\n match self {\n DynParserError::UnexpectedEnd { span } => Diagnostic::error()\n .with_message(\"unexpected end\")\n .with_labels(vec![Label::primary(span.source_id(), *span)]),\n DynParserError::UnexpectedToken { span } => Diagnostic::error()\n .with_message(\"unexpected token\")\n .with_labels(vec![Label::primary(span.source_id(), *span)]),\n }\n }\n}\n\nimpl<'a> ParseCtx<'a> {\n pub fn new(tokens: &'a [DynToken], span: SourceSpan) -> Self {\n ParseCtx {\n containing: span,\n tokens,\n pos: 0,\n }\n }\n\n pub fn pop(&mut self) -> Result<&'a DynToken, DynParserError> {\n if self.pos < self.tokens.len() {\n let tok = &self.tokens[self.pos];\n self.pos += 1;\n Ok(tok)\n } else {\n UnexpectedEnd {\n span: self\n .tokens\n .last()\n .map(|tok| tok.span())\n .unwrap_or(self.containing),\n }\n .fail()?\n }\n }\n\n pub fn peek(&self) -> Option<&'a DynToken> {\n self.tokens.get(self.pos)\n }\n\n pub fn try_parse(\n &mut self,\n fun: impl FnOnce(&mut ParseCtx) -> Result,\n ) -> Result {\n let pos = self.pos;\n match fun(self) {\n Ok(res) => Ok(res),\n Err(err) => {\n self.pos = pos;\n Err(err)\n }\n }\n }\n\n pub fn comma(\n &mut self,\n fun: impl Fn(&mut ParseCtx) -> Result,\n ) -> Result, E> {\n let mut res = vec![];\n loop {\n match fun(self) {\n Ok(val) => res.push(val),\n Err(err) => break,\n }\n match self.peek() {\n Some(&DynToken::Comma(_)) => (),\n _ => break,\n None => break,\n }\n }\n return Ok(res);\n }\n\n pub fn repeat_any(&mut self, fun: impl Fn(&mut ParseCtx) -> Result) -> Vec {\n let mut res = vec![];\n loop {\n match fun(self) {\n Ok(val) => res.push(val),\n Err(err) => break,\n }\n }\n return res;\n }\n\n pub fn eof(&mut self) -> Result<(), DynParserError> {\n match self.peek() {\n Some(tok) => Err(DynParserError::UnexpectedToken { span: tok.span() }),\n None => Ok(()),\n }\n }\n\n pub fn tok_string(&mut self) -> Result {\n match self.pop()? {\n DynToken::String(string) => Ok(*string),\n tok => Err(DynParserError::UnexpectedToken { span: tok.span() }),\n }\n }\n pub fn tok_integer(&mut self) -> Result<(&'a Integer, SourceSpan), DynParserError> {\n match self.pop()? {\n DynToken::Integer(int, span) => Ok((int, *span)),\n tok => Err(DynParserError::UnexpectedToken { span: tok.span() }),\n }\n }\n\n pub fn tok_colon(&mut self) -> Result {\n match self.pop()? {\n DynToken::Colon(span) => Ok(*span),\n tok => Err(DynParserError::UnexpectedToken { span: tok.span() }),\n }\n }\n pub fn tok_at(&mut self) -> Result {\n match self.pop()? {\n DynToken::At(span) => Ok(*span),\n tok => Err(DynParserError::UnexpectedToken { span: tok.span() }),\n }\n }\n\n container_token!(tok_parens, Parens);\n container_token!(tok_braces, Braces);\n container_token!(tok_map_braces, MapBraces);\n container_token!(tok_square_brackets, SquareBrackets);\n container_token!(tok_angle_brackets, AngleBrackets);\n}\n\npub struct ParsePos(usize);\n\npub fn val(ctx: &mut ParseCtx) -> Result {\n println!(\"val PEEK {:?}\", ctx.peek());\n match ctx.peek() {\n Some(DynToken::SquareBrackets(_, _)) => val_list(ctx),\n Some(DynToken::AngleBrackets(_, _)) => val_value_list(ctx),\n _ => val_atomic(ctx),\n }\n}\n\n//pub fn value_max(ctx: &mut ParseCtx) -> Result {\n// ctx.try_parse(|ctx| match ctx.pop() {\n// DynToken::SquareBrackets(inner, span) => unimplemented!(),\n// _ => panic!(),\n// })\n//}\n\npub fn val_value_list(ctx: &mut ParseCtx) -> Result {\n ctx.try_parse(|ctx| {\n let (inner, span) = ctx.tok_angle_brackets()?;\n\n let mut ictx = ParseCtx::new(inner, span);\n let vec = ictx.comma(val)?;\n\n println!(\"{:?}\", vec);\n\n println!(\"before value list eof\");\n ictx.eof()?;\n println!(\"after value list eof\");\n\n Ok(Value::ValueList(vec))\n })\n}\n\npub fn val_list(ctx: &mut ParseCtx) -> Result {\n ctx.try_parse(|ctx| {\n let (inner, span) = ctx.tok_square_brackets()?;\n\n let mut ictx = ParseCtx::new(inner, span);\n let vec = ictx.comma(val)?;\n\n match ictx.pop() {\n Err(_) => Ok(Value::List(vec, None)),\n Ok(DynToken::Pipe(_span)) => {\n let tail = val(&mut ictx)?;\n ictx.eof()?;\n Ok(Value::List(vec, Some(Box::new(tail))))\n }\n Ok(other) => Err(DynParserError::UnexpectedToken { span: other.span() }),\n }\n })\n}\n\npub fn val_atomic(ctx: &mut ParseCtx) -> Result {\n println!(\"val_atomic PEEK {:?}\", ctx.peek());\n ctx.try_parse(|ctx| match ctx.pop()? {\n DynToken::Atom(atom) => Ok(Value::Atom(*atom)),\n DynToken::Integer(int, span) => Ok(Value::Integer(int.clone())),\n DynToken::Ident(block) => Ok(Value::Block(*block)),\n DynToken::Variable(var) => Ok(Value::Value(*var)),\n tok => {\n println!(\"unexpected tok {:?}\", tok);\n UnexpectedToken { span: tok.span() }.fail()?\n }\n })\n}\n\n//pub fn value(ctx: &mut ParseCtx) -> Result {\n// if let Ok(head_val) = value(ctx) {\n// } else {\n// unimplemented!()\n// }\n//}\n" }, { "path": "libeir_ir/src/text/parser/errors.rs", "content": "use snafu::Snafu;\nuse std::path::PathBuf;\n\nuse libeir_diagnostics::{Diagnostic, Label, SourceIndex, SourceSpan, ToDiagnostic};\nuse libeir_util_parse::SourceError;\n\nuse super::lexer::Token;\nuse crate::text::LowerError;\n\npub type ParseError = lalrpop_util::ParseError;\n\npub type Errors = libeir_util_parse::Errors;\n\n#[derive(Debug, Snafu)]\n#[snafu(visibility = \"pub(super)\")]\npub enum ParserError {\n #[snafu(display(\"{} occurred while reading {:?}\", source, path))]\n RootFileError {\n source: std::io::Error,\n path: PathBuf,\n },\n\n #[snafu(display(\"{}\", source))]\n Source {\n source: SourceError,\n },\n\n Lower {\n source: LowerError,\n },\n\n InvalidToken {\n span: SourceSpan,\n },\n\n UnexpectedEOF {\n span: SourceSpan,\n expected: Vec,\n },\n\n UnexpectedToken {\n span: SourceSpan,\n expected: Vec,\n },\n\n UnrecognizedToken {\n span: SourceSpan,\n expected: Vec,\n },\n\n ExtraToken {\n span: SourceSpan,\n },\n\n ShowDiagnostic {\n diagnostic: Diagnostic,\n },\n}\n\nimpl ParserError {\n pub fn span(&self) -> Option {\n match self {\n ParserError::InvalidToken { span } => Some(*span),\n ParserError::UnrecognizedToken { span, .. } => Some(*span),\n ParserError::ExtraToken { span } => Some(*span),\n _ => None,\n }\n }\n}\n\nimpl ToDiagnostic for ParserError {\n fn to_diagnostic(&self) -> Diagnostic {\n let span = self.span();\n let msg = self.to_string();\n match self {\n ParserError::ShowDiagnostic { diagnostic } => diagnostic.clone(),\n ParserError::Source { source } => source.to_diagnostic(),\n ParserError::Lower { source } => source.to_diagnostic(),\n ParserError::UnrecognizedToken { expected, .. } => {\n let span = span.unwrap();\n Diagnostic::error()\n .with_message(format!(\"expected: {}\", expected.join(\", \")))\n .with_labels(vec![\n Label::primary(span.source_id(), span).with_message(msg)\n ])\n }\n _ if span.is_some() => {\n let span = span.unwrap();\n Diagnostic::error()\n .with_message(msg)\n .with_labels(vec![Label::primary(span.source_id(), span)])\n }\n _ => Diagnostic::error().with_message(msg),\n }\n }\n}\n\nimpl From for ParserError {\n fn from(err: LowerError) -> ParserError {\n ParserError::Lower { source: err }\n }\n}\nimpl From for ParserError {\n fn from(err: ParseError) -> ParserError {\n use lalrpop_util::ParseError as E;\n match err {\n E::InvalidToken { location } => ParserError::InvalidToken {\n span: SourceSpan::new(location, location),\n },\n E::UnrecognizedEOF { location, expected } => ParserError::UnexpectedEOF {\n span: SourceSpan::new(location, location),\n expected,\n },\n E::UnrecognizedToken {\n token: (start, _tok, end),\n expected,\n } => ParserError::UnrecognizedToken {\n span: SourceSpan::new(start, end),\n expected,\n },\n E::ExtraToken {\n token: (start, _, end),\n } => ParserError::ExtraToken {\n span: SourceSpan::new(start, end),\n },\n E::User { error } => error,\n }\n }\n}\nimpl From for ParserError {\n fn from(diagnostic: Diagnostic) -> ParserError {\n ParserError::ShowDiagnostic { diagnostic }\n }\n}\n" }, { "path": "libeir_ir/src/text/parser/grammar.lalrpop", "content": "//-*- mode: rust -*-\n\nuse libeir_diagnostics::{SourceIndex, SourceSpan, Diagnostic, Label as DiagLabel};\nuse libeir_intern::{Ident, Symbol};\nuse libeir_util_parse::ErrorReceiver;\nuse libeir_util_number::ToPrimitive;\n\nuse crate::{BasicType, BinOp};\nuse crate::constant::Integer;\nuse crate::text::parser::lexer::Token;\nuse crate::text::ast::{Module, ModuleItem, Function, FunctionItem, Label,\n Op, CallControlFlowOp, CallFunctionOp, Value,\n Assignment, UnpackValueListOp, IfBoolOp,\n TraceCaptureRawOp, MatchEntry, MatchKind,\n MatchOp, CaseOp, CaseEntry, CasePattern, Meta, DynToken};\nuse super::ParserErrorReceiver;\nuse super::errors::{ParserError, Errors};\n\ngrammar<'a>(errors: &'a mut ParserErrorReceiver<'a>);\n\n#[inline]\nComma: Vec = {\n \",\")*> => {\n let mut v = v;\n if let Some(n) = e {\n v.push(n);\n }\n v\n }\n};\n\npub Module: Module = {\n \"{\" \"}\" => {\n Module {\n span: span!(l, r),\n name: name,\n items,\n }\n }\n};\n\nModuleItem: ModuleItem = {\n => ModuleItem::Function(<>),\n};\n\npub StandaloneFunction: (Ident, Function) = {\n \":\" \"/\" \"{\" \"}\" => {\n (\n module,\n Function {\n span: span!(l, r),\n name: name,\n arity: arity,\n items,\n }\n )\n }\n};\n\nFunction: Function = {\n \"/\" \"{\" \"}\" => {\n Function {\n span: span!(l, r),\n name: name,\n arity: arity,\n items,\n }\n }\n};\n\nFunctionItem: FunctionItem = {\n\n // Assignments\n \";\" => <>,\n\n // Operations\n \";\" => FunctionItem::Op(<>),\n\n // Meta\n \"!\" \";\" => {\n FunctionItem::Meta(Meta {\n span: SourceSpan::new(l, r),\n name,\n tokens,\n })\n },\n\n // Label\n \"(\" > \")\" \":\" => {\n let span = SourceSpan::new(l, r);\n if name.block().is_none() {\n errors.error(\n Diagnostic::error()\n .with_message(\"label name must be block\")\n .with_labels(vec![DiagLabel::primary(span.source_id(), span)])\n .into()\n );\n }\n for arg in args.iter() {\n if arg.value().is_none() {\n errors.error(\n Diagnostic::error()\n .with_message(\"argument to label must be value\")\n .with_labels(vec![DiagLabel::primary(span.source_id(), span)])\n .into()\n );\n }\n }\n FunctionItem::Label(Label { span: span!(l, r), name: name, args })\n },\n\n};\n\n#[inline]\nFunctionAssignItem: FunctionItem = {\n \"=\" => {\n if lhs.value().is_none() {\n let span = SourceSpan::new(l, r);\n errors.error(\n Diagnostic::error()\n .with_message(\"assignment must be to a value\")\n .with_labels(vec![DiagLabel::primary(span.source_id(), span)])\n .into()\n );\n }\n\n FunctionItem::Assignment(Assignment {\n span: span!(l, r),\n lhs,\n rhs,\n })\n }\n};\n\nDynToken: DynToken = {\n => <>,\n};\n\nDynTokenInner: DynToken = {\n \";\" => DynToken::SemiColon(span!(l, r)),\n => <>,\n};\n\nDynToken100: DynToken = {\n \"(\" \")\" => DynToken::Parens(i, span!(l, r)),\n \"{\" \"}\" => DynToken::Braces(i, span!(l, r)),\n \"%{\" \"}\" => DynToken::MapBraces(i, span!(l, r)),\n \"[\" \"]\" => DynToken::SquareBrackets(i, span!(l, r)),\n \"<\" \">\" => DynToken::AngleBrackets(i, span!(l, r)),\n\n => DynToken::Ident(i),\n => DynToken::Variable(i),\n\n => DynToken::Atom(i),\n => DynToken::Integer(i, span!(l, r)),\n => DynToken::Float(i),\n => DynToken::String(s),\n\n \"%\" => DynToken::Percent(span!(l, r)),\n \":\" => DynToken::Colon(span!(l, r)),\n \",\" => DynToken::Comma(span!(l, r)),\n \"?\" => DynToken::Question(span!(l, r)),\n \"/\" => DynToken::ForwardSlash(span!(l, r)),\n \"=\" => DynToken::Equals(span!(l, r)),\n \"==\" => DynToken::EqualsEquals(span!(l, r)),\n \"=>\" => DynToken::FatArrow(span!(l, r)),\n \"_\" => DynToken::Underscore(span!(l, r)),\n \"|\" => DynToken::Pipe(span!(l, r)),\n \"@\" => DynToken::At(span!(l, r)),\n \"!\" => DynToken::Bang(span!(l, r)),\n\n \"unpack\" => DynToken::Unpack(span!(l, r)),\n \"unreachable\" => DynToken::Unreachable(span!(l, r)),\n \"arity\" => DynToken::Arity(span!(l, r)),\n \"if_bool\" => DynToken::IfBool(span!(l, r)),\n \"trace_capture_raw\" => DynToken::TraceCaptureRaw(span!(l, r)),\n \"value\" => DynToken::Value(span!(l, r)),\n \"match\" => DynToken::Match(span!(l, r)),\n \"type\" => DynToken::Type(span!(l, r)),\n \"case\" => DynToken::Case(span!(l, r)),\n \"guard\" => DynToken::Guard(span!(l, r)),\n \"except\" => DynToken::Except(span!(l, r)),\n};\n\n#[inline]\nFunctionOp: Op = {\n\n // Intrinsic/Dynop\n \"@\" => {\n Op::Dyn(name, tokens)\n },\n\n // Call\n \"(\" > \")\" \"=>\" \"except\" => {\n Op::CallFunction(CallFunctionOp {\n span: span!(l, r),\n target,\n ret,\n thr,\n args,\n })\n },\n \"(\" > \")\" => {\n Op::CallControlFlow(CallControlFlowOp {\n span: span!(l, r),\n target,\n args,\n })\n },\n\n // UnpackValueList\n \"unpack\" \"arity\" \"=>\" => {\n Op::UnpackValueList(UnpackValueListOp {\n span: span!(l, r),\n arity: arity.to_usize().unwrap(),\n value,\n block,\n })\n },\n\n \"if_bool\" => {\n Op::IfBool(IfBoolOp {\n span: span!(l, r),\n value,\n tru,\n fal,\n or,\n })\n },\n\n \"trace_capture_raw\" => {\n Op::TraceCaptureRaw(TraceCaptureRawOp {\n span: span!(l, r),\n then,\n })\n },\n\n \"match\" \"{\" \"}\" => {\n Op::Match(MatchOp {\n span: span!(l, r),\n value,\n entries,\n })\n },\n\n \"case\" \"{\" \"}\" => {\n Op::Case(CaseOp {\n span: span!(l, r),\n value,\n entries,\n no_match,\n })\n },\n\n // Unreachable\n \"unreachable\" => Op::Unreachable,\n\n};\n\nCaseEntry: CaseEntry = {\n \"<\" > \">\" \"guard\" \"=>\" \"(\" > \")\" \";\" => {\n CaseEntry {\n span: span!(l, r),\n patterns,\n args,\n guard,\n target,\n }\n },\n \"guard\" \"=>\" \"(\" > \")\" \";\" => {\n CaseEntry {\n span: span!(l, r),\n patterns: vec![pattern],\n args,\n guard,\n target,\n }\n },\n};\n\nCaseNoMatch: Value = {\n \"_\" \"=>\" \";\" => <>,\n};\n\nCasePattern: CasePattern = {\n \"(\" \")\" => <>,\n \"{\" > \"}\" => {\n CasePattern::Tuple {\n elements,\n }\n },\n \"[\" > )?> \"]\" => {\n let mut acc = tail.unwrap_or(CasePattern::Value(Value::Nil));\n for elem in heads.drain(..).rev() {\n acc = CasePattern::ListCell {\n head: Box::new(elem),\n tail: Box::new(acc),\n };\n }\n acc\n },\n \"@\" => {\n CasePattern::Binding {\n name,\n pattern: Box::new(pat),\n }\n },\n \"_\" => {\n CasePattern::Wildcard\n }\n};\n\nMatchEntry: MatchEntry = {\n \"=>\" \";\" => {\n MatchEntry {\n span: span!(l, r),\n target,\n kind,\n }\n }\n};\n\nMatchKind: MatchKind = {\n \"value\" =>\n MatchKind::Value(value),\n \"type\" \"%{\" \"}\" =>\n MatchKind::Type(BasicType::Map),\n \"{\" \"}\" \"arity\" =>\n MatchKind::Tuple(arity.to_usize().unwrap()),\n \"[\" \"]\" =>\n MatchKind::ListCell,\n \"%{\" \"}\" =>\n MatchKind::MapItem(key),\n \"_\" =>\n MatchKind::Wildcard,\n};\n\nValue: Value = {\n \":\" \"/\" =>\n Value::CaptureFunction(Box::new(m), Box::new(f), Box::new(a)),\n =>\n Value::BinOp(Box::new(left), op, Box::new(right)),\n Value100,\n};\n\nValue100: Value = {\n ValueMax\n};\n\nValueMax: Value = {\n \"[\" > )?> \"]\" => {\n if head.len() == 0 {\n if let Some(tail) = tail {\n tail\n } else {\n Value::Nil\n }\n } else {\n Value::List(head, tail.map(Box::new))\n }\n },\n \"{\" > \"}\" =>\n Value::Tuple(<>),\n \"<\" > \">\" =>\n Value::ValueList(<>),\n => <>,\n};\n\nAtomicValue: Value = {\n => Value::Atom(<>),\n => Value::Integer(<>),\n => Value::Block(<>),\n => Value::Value(<>),\n};\n\nBinOp: BinOp = {\n \"==\" => BinOp::Equal,\n};\n\nBlock: Ident = {\n => <>,\n \"type\" =>\n Ident::new(Symbol::intern(\"type\"), SourceSpan::new(l, r)),\n};\n\nextern {\n type Location = SourceIndex;\n type Error = ParserError;\n\n enum Token {\n \"EOF\" => Token::EOF,\n\n ident => Token::Ident(),\n variable => Token::Variable(),\n\n atom => Token::Atom(),\n integer => Token::Integer(),\n float => Token::Float(),\n string => Token::String(),\n\n \"(\" => Token::ParenOpen,\n \")\" => Token::ParenClose,\n \"{\" => Token::CurlyOpen,\n \"}\" => Token::CurlyClose,\n \"[\" => Token::SquareOpen,\n \"]\" => Token::SquareClose,\n \"<\" => Token::Less,\n \">\" => Token::Greater,\n \"%\" => Token::Percent,\n \"%{\" => Token::MapOpen,\n \":\" => Token::Colon,\n \";\" => Token::Semicolon,\n \",\" => Token::Comma,\n \"?\" => Token::Question,\n \"/\" => Token::ForwardSlash,\n \"=\" => Token::Equals,\n \"==\" => Token::EqualsEquals,\n \"=>\" => Token::FatArrow,\n \"_\" => Token::Underscore,\n \"|\" => Token::Pipe,\n \"@\" => Token::At,\n \"!\" => Token::Bang,\n\n \"unpack\" => Token::UnpackValueList,\n \"unreachable\" => Token::Unreachable,\n \"arity\" => Token::Arity,\n \"if_bool\" => Token::IfBool,\n \"trace_capture_raw\" => Token::TraceCaptureRaw,\n \"value\" => Token::Value,\n \"match\" => Token::Match,\n \"type\" => Token::Type,\n \"case\" => Token::Case,\n \"guard\" => Token::Guard,\n \"except\" => Token::Except,\n }\n\n}\n" }, { "path": "libeir_ir/src/text/parser/lexer.rs", "content": "#![allow(\n dead_code,\n unreachable_code,\n unused_mut,\n unused_variables,\n unused_macros\n)]\n\nuse std::collections::HashMap;\nuse std::ops::Range;\n\nuse lazy_static::lazy_static;\n\nuse libeir_diagnostics::{ByteOffset, SourceIndex, SourceSpan};\nuse libeir_intern::{Ident, Symbol};\nuse libeir_util_parse::{Scanner, Source};\n\nuse super::errors::ParserError;\nuse crate::constant::Integer;\n\nmacro_rules! pop {\n ($lex:ident) => {{\n $lex.skip();\n }};\n ($lex:ident, $code:expr) => {{\n $lex.skip();\n $code\n }};\n}\n\nmacro_rules! pop2 {\n ($lex:ident) => {{\n $lex.skip();\n $lex.skip();\n }};\n ($lex:ident, $code:expr) => {{\n $lex.skip();\n $lex.skip();\n $code\n }};\n}\n\nmacro_rules! pop3 {\n ($lex:ident) => {{\n $lex.skip();\n $lex.skip();\n $lex.skip()\n }};\n ($lex:ident, $code:expr) => {{\n $lex.skip();\n $lex.skip();\n $lex.skip();\n $code\n }};\n}\n\n#[derive(Clone, Debug, PartialEq)]\npub struct LexicalError;\n\n#[derive(Debug, Clone, PartialEq)]\npub struct LexicalToken(pub SourceIndex, pub Token, pub SourceIndex);\nimpl LexicalToken {\n pub fn token(&self) -> Token {\n self.1.clone()\n }\n\n pub fn span(&self) -> SourceSpan {\n SourceSpan::new(self.0, self.2)\n }\n}\n\n#[derive(Clone, PartialEq, Eq, Debug)]\npub enum Token {\n EOF,\n\n // Identifiers\n /// something\n Ident(Ident),\n Variable(Ident),\n\n // Atomics\n /// a'true'\n Atom(Ident),\n /// 12\n Integer(Integer),\n /// 12.2\n Float(Ident),\n String(Ident),\n\n // Symbols\n ParenOpen,\n ParenClose,\n CurlyOpen,\n CurlyClose,\n SquareOpen,\n SquareClose,\n Less,\n Greater,\n MapOpen,\n Colon,\n Semicolon,\n Comma,\n Question,\n ForwardSlash,\n Percent,\n Equals,\n EqualsEquals,\n FatArrow,\n Underscore,\n Pipe,\n At,\n Bang,\n\n // Keywords\n Unreachable,\n IfBool,\n UnpackValueList,\n ValueList,\n Tuple,\n Arity,\n TraceCaptureRaw,\n Value,\n Match,\n Type,\n Case,\n Guard,\n Except,\n}\n\nlazy_static! {\n static ref KEYWORDS: HashMap = {\n let mut map = HashMap::new();\n map.insert(Symbol::intern(\"unreachable\"), Token::Unreachable);\n map.insert(Symbol::intern(\"if_bool\"), Token::IfBool);\n map.insert(Symbol::intern(\"unpack_value_list\"), Token::UnpackValueList);\n map.insert(Symbol::intern(\"value_list\"), Token::ValueList);\n map.insert(Symbol::intern(\"tuple\"), Token::Tuple);\n map.insert(Symbol::intern(\"unpack\"), Token::UnpackValueList);\n map.insert(Symbol::intern(\"arity\"), Token::Arity);\n map.insert(Symbol::intern(\"trace_capture_raw\"), Token::TraceCaptureRaw);\n map.insert(Symbol::intern(\"value\"), Token::Value);\n map.insert(Symbol::intern(\"match\"), Token::Match);\n map.insert(Symbol::intern(\"type\"), Token::Type);\n map.insert(Symbol::intern(\"case\"), Token::Case);\n map.insert(Symbol::intern(\"except\"), Token::Except);\n map.insert(Symbol::intern(\"guard\"), Token::Guard);\n map\n };\n}\n\nfn is_escapechar(c: char) -> bool {\n c == 'b'\n || c == 'd'\n || c == 'e'\n || c == 'f'\n || c == 'n'\n || c == 'r'\n || c == 's'\n || c == 't'\n || c == 'v'\n || c == '\"'\n || c == '\\''\n || c == '\\\\'\n}\nfn is_control(c: char) -> bool {\n c >= '\\u{0000}' && c <= '\\u{001f}'\n}\nfn is_inputchar(c: char) -> bool {\n c != '\\n' && c != '\\r'\n}\nfn is_digit(c: char) -> bool {\n c >= '0' && c <= '9'\n}\nfn is_octal(c: char) -> bool {\n c >= '0' && c <= '7'\n}\nfn is_uppercase(c: char) -> bool {\n (c >= 'A' && c <= 'Z')\n || (c >= '\\u{00c0}' && c <= '\\u{00d6}')\n || (c >= '\\u{00d8}' && c <= '\\u{00de}')\n}\nfn is_lowercase(c: char) -> bool {\n (c >= 'a' && c <= 'z')\n || (c >= '\\u{00df}' && c <= '\\u{00f6}')\n || (c >= '\\u{00f8}' && c <= '\\u{00ff}')\n}\nfn is_namechar(c: char) -> bool {\n is_uppercase(c) || is_lowercase(c) || is_digit(c) || (c == '@') || (c == '_')\n}\n\npub struct Lexer {\n scanner: Scanner,\n token: Token,\n token_start: SourceIndex,\n token_end: SourceIndex,\n eof: bool,\n}\n\nimpl Lexer\nwhere\n S: Source,\n{\n pub fn new(scanner: Scanner) -> Self {\n let start = scanner.start();\n let mut lexer = Lexer {\n scanner,\n token: Token::EOF,\n token_start: start + ByteOffset(0),\n token_end: start + ByteOffset(0),\n eof: false,\n };\n lexer.advance();\n lexer\n }\n\n pub fn lex(&mut self) -> Option<::Item> {\n if self.eof && self.token == Token::EOF {\n return None;\n }\n\n let token = std::mem::replace(&mut self.token, Token::EOF);\n //let result = if let Token::Error(err) = token {\n // Some(Err(err))\n //} else {\n let result = Some(Ok((\n self.token_start.clone(),\n token,\n self.token_end.clone(),\n )));\n //};\n\n self.advance();\n\n result\n }\n\n fn advance(&mut self) {\n self.advance_start();\n self.token = self.tokenize();\n }\n\n fn advance_start(&mut self) {\n let mut position: SourceIndex;\n loop {\n let (pos, c) = self.scanner.read();\n position = pos;\n\n if c == '\\0' {\n self.eof = true;\n return;\n }\n\n if c.is_whitespace() {\n self.scanner.advance();\n continue;\n }\n\n if c == '#' {\n 'inner: loop {\n let (pos, c) = self.scanner.read();\n\n if c == '\\n' {\n break 'inner;\n }\n\n if c == '\\0' {\n self.eof = true;\n return;\n }\n\n self.skip();\n }\n continue;\n }\n\n break;\n }\n\n self.token_start = position;\n }\n\n fn pop(&mut self) -> char {\n let (pos, c) = self.scanner.pop();\n self.token_end = pos + ByteOffset::from_char_len(c);\n c\n }\n fn peek(&mut self) -> char {\n self.scanner.peek().1\n }\n fn peek_next(&mut self) -> char {\n self.scanner.peek_next().1\n }\n fn read(&mut self) -> char {\n self.scanner.read().1\n }\n fn skip(&mut self) {\n self.pop();\n }\n pub fn span(&self) -> SourceSpan {\n SourceSpan::new(self.token_start, self.token_end)\n }\n fn slice(&self) -> &str {\n self.scanner.slice(self.span())\n }\n fn slice_span(&self, span: impl Into>) -> &str {\n self.scanner.slice(span)\n }\n fn ident(&self) -> Ident {\n let symbol = Symbol::intern(self.slice());\n Ident::new(symbol, self.span())\n }\n fn skip_whitespace(&mut self) {\n let mut c: char;\n while self.read().is_whitespace() {\n self.skip();\n }\n }\n\n fn tokenize(&mut self) -> Token {\n let mut c = self.read();\n\n if c == '\\0' {\n self.eof = true;\n return Token::EOF;\n }\n\n if c.is_whitespace() {\n self.skip_whitespace();\n }\n\n match self.read() {\n '(' => pop!(self, Token::ParenOpen),\n ')' => pop!(self, Token::ParenClose),\n '{' => pop!(self, Token::CurlyOpen),\n '}' => pop!(self, Token::CurlyClose),\n '[' => pop!(self, Token::SquareOpen),\n ']' => pop!(self, Token::SquareClose),\n '<' => pop!(self, Token::Less),\n '>' => pop!(self, Token::Greater),\n '%' => match self.peek() {\n '{' => pop2!(self, Token::MapOpen),\n c if c.is_alphanumeric() => self.lex_variable(),\n _ => unimplemented!(),\n },\n ',' => pop!(self, Token::Comma),\n ':' => pop!(self, Token::Colon),\n ';' => pop!(self, Token::Semicolon),\n '/' => pop!(self, Token::ForwardSlash),\n '|' => pop!(self, Token::Pipe),\n '=' => match self.peek() {\n '>' => pop2!(self, Token::FatArrow),\n '=' => pop2!(self, Token::EqualsEquals),\n _ => pop!(self, Token::Equals),\n },\n '_' => pop!(self, Token::Underscore),\n '@' => pop!(self, Token::At),\n '!' => pop!(self, Token::Bang),\n c if c == 'a' => match self.peek() {\n '\\'' => self.lex_atom(),\n _ => self.lex_ident(),\n },\n c if c.is_alphabetic() => self.lex_ident(),\n c if c.is_numeric() => self.lex_integer(),\n '\"' => self.lex_string(),\n c => unimplemented!(\"{}\", c),\n }\n }\n\n fn lex_ident(&mut self) -> Token {\n let c = self.pop();\n debug_assert!(c.is_alphabetic());\n\n loop {\n match self.read() {\n '_' => self.skip(),\n '0'..='9' => self.skip(),\n c if c.is_alphabetic() => self.skip(),\n _ => break,\n }\n }\n\n let ident = self.ident();\n\n if let Some(tok) = KEYWORDS.get(&ident.name) {\n tok.clone()\n } else {\n Token::Ident(ident)\n }\n }\n\n fn lex_string(&mut self) -> Token {\n let c = self.pop();\n debug_assert!(c == '\"');\n\n loop {\n match self.read() {\n '\\\\' => {\n self.skip();\n self.skip();\n }\n '\"' => {\n break;\n }\n _ => self.skip(),\n }\n }\n\n let symbol = Symbol::intern(&self.slice()[1..]);\n self.skip();\n let ident = Ident::new(symbol, self.span());\n\n Token::String(ident)\n }\n\n fn lex_variable(&mut self) -> Token {\n let c = self.pop();\n debug_assert!(c == '%');\n\n loop {\n match self.read() {\n '_' => self.skip(),\n '0'..='9' => self.skip(),\n c if c.is_alphabetic() => self.skip(),\n _ => break,\n }\n }\n\n let symbol = Symbol::intern(&self.slice()[1..]);\n let ident = Ident::new(symbol, self.span());\n\n Token::Variable(ident)\n }\n\n fn lex_integer(&mut self) -> Token {\n let c = self.pop();\n debug_assert!(c.is_numeric() || c == '-');\n\n loop {\n match self.read() {\n c if c.is_numeric() => self.skip(),\n _ => break,\n }\n }\n\n let int = self.slice().parse().unwrap();\n Token::Integer(int)\n }\n\n fn lex_atom(&mut self) -> Token {\n debug_assert!(self.pop() == 'a');\n debug_assert!(self.pop() == '\\'');\n\n loop {\n match self.read() {\n '\\'' => {\n self.skip();\n break;\n }\n '\\\\' => {\n self.skip();\n self.skip();\n }\n c => {\n self.skip();\n }\n }\n }\n\n let slice = self.slice();\n let inner_slice = &self.slice()[2..(slice.len() - 1)];\n\n let ident = Ident::new(Symbol::intern(inner_slice), self.span());\n\n Token::Atom(ident)\n }\n}\n\nimpl Iterator for Lexer\nwhere\n S: Source,\n{\n type Item = Result<(SourceIndex, Token, SourceIndex), ParserError>;\n\n fn next(&mut self) -> Option {\n let t = self.lex();\n t\n }\n}\n" }, { "path": "libeir_ir/src/text/parser/mod.rs", "content": "use std::sync::Arc;\n\nuse libeir_diagnostics::{CodeMap, SourceIndex};\nuse libeir_intern::Ident;\nuse libeir_util_parse::{\n self as parse, error_tee, ErrorReceiver, Parse, Scanner, Source, SourceError,\n};\n\nuse crate::FunctionIdent;\n\nmod lexer;\nuse lexer::{Lexer, Token};\n\nmod errors;\nuse self::errors::Errors;\npub use self::errors::ParserError;\n\nuse super::lower::LowerMap;\n\npub type Parser = parse::Parser<()>;\n\ntype ParserErrorReceiver<'a> = dyn ErrorReceiver + 'a;\n\n/// Used in the grammar for easy span creation\nmacro_rules! span {\n ($l:expr, $r:expr) => {\n SourceSpan::new($l, $r)\n };\n ($i:expr) => {\n SourceSpan::new($i, $i)\n };\n}\n\n#[cfg_attr(rustfmt, rustfmt_skip)]\n#[allow(unknown_lints)]\n#[allow(clippy)]\n#[allow(unused_variables, dead_code, unused_imports, unused_parens)]\npub(crate) mod grammar {\n // During the build step, `build.rs` will output the generated parser to `OUT_DIR` to avoid\n // adding it to the source directory, so we just directly include the generated parser here.\n //\n // Even with `.gitignore` and the `exclude` in the `Cargo.toml`, the generated parser can still\n // end up in the source directory. This could happen when `cargo build` builds the file out of\n // the Cargo cache (`$HOME/.cargo/registrysrc`), and the build script would then put its output\n // in that cached source directory because of https://github.com/lalrpop/lalrpop/issues/280.\n // Later runs of `cargo vendor` then copy the source from that directory, including the\n // generated file.\n include!(concat!(env!(\"OUT_DIR\"), \"/text/parser/grammar.rs\"));\n}\n\npub struct NamedFunction {\n pub name: Ident,\n pub function: super::ast::Function,\n}\n\nimpl Parse for super::ast::Module {\n type Parser = self::grammar::ModuleParser;\n type Error = ParserError;\n type Config = ();\n type Token = std::result::Result<(SourceIndex, Token, SourceIndex), ParserError>;\n\n fn root_file_error(source: std::io::Error, path: std::path::PathBuf) -> Self::Error {\n ParserError::RootFileError { source, path }\n }\n\n fn parse_tokens(errors: &mut ParserErrorReceiver, tokens: S) -> Result\n where\n S: IntoIterator>,\n {\n let result = self::grammar::ModuleParser::new().parse(errors, tokens);\n\n let ret;\n match result {\n Ok(ok) => ret = ok,\n Err(err) => {\n errors.error(err.into());\n return Err(());\n }\n }\n\n if (*errors).is_failed() {\n Err(())\n } else {\n Ok(ret)\n }\n }\n\n fn parse(_parser: &Parser, errors: &mut ParserErrorReceiver, source: S) -> Result\n where\n S: Source,\n {\n let scanner = Scanner::new(source);\n let lexer = Lexer::new(scanner);\n Self::parse_tokens(errors, lexer)\n }\n}\nimpl Parse for NamedFunction {\n type Parser = self::grammar::StandaloneFunctionParser;\n type Error = ParserError;\n type Config = ();\n type Token = std::result::Result<(SourceIndex, Token, SourceIndex), ParserError>;\n\n fn root_file_error(source: std::io::Error, path: std::path::PathBuf) -> Self::Error {\n ParserError::RootFileError { source, path }\n }\n\n fn parse_tokens(errors: &mut ParserErrorReceiver, tokens: S) -> Result\n where\n S: IntoIterator>,\n {\n let result = self::grammar::StandaloneFunctionParser::new().parse(errors, tokens);\n\n let name;\n let function;\n match result {\n std::result::Result::Ok((i, f)) => {\n name = i;\n function = f;\n }\n std::result::Result::Err(err) => {\n errors.error(err.into());\n return Err(());\n }\n }\n\n if (*errors).is_failed() {\n Err(())\n } else {\n Ok(NamedFunction { name, function })\n }\n }\n\n fn parse<'a, S>(\n _parser: &Parser,\n errors: &'a mut ParserErrorReceiver<'a>,\n source: S,\n ) -> Result\n where\n S: Source,\n {\n let scanner = Scanner::new(source);\n let lexer = Lexer::new(scanner);\n Self::parse_tokens(errors, lexer)\n }\n}\n\nimpl FunctionIdent {\n pub fn parse(string: &str) -> std::result::Result {\n lazy_static::lazy_static! {\n static ref FUNCTION_IDENT_RE: regex::Regex = {\n regex::Regex::new(\"^([^/]+):([^:]+)/(\\\\d+)$\").unwrap()\n };\n }\n\n let captures = FUNCTION_IDENT_RE\n .captures(string)\n .map(Ok)\n .unwrap_or(Err(()))?;\n\n let res = FunctionIdent {\n module: Ident::from_str(&captures[1]),\n name: Ident::from_str(&captures[2]),\n arity: captures[3].parse().unwrap(),\n };\n Ok(res)\n }\n\n pub fn parse_with_module(string: &str, module: Ident) -> std::result::Result {\n lazy_static::lazy_static! {\n static ref FUNCTION_IDENT_RE: regex::Regex = {\n regex::Regex::new(\"^([^:]+)/(\\\\d+)$\").unwrap()\n };\n }\n\n let captures = FUNCTION_IDENT_RE\n .captures(string)\n .map(Ok)\n .unwrap_or(Err(()))?;\n\n let res = FunctionIdent {\n module,\n name: Ident::from_str(&captures[1]),\n arity: captures[2].parse().unwrap(),\n };\n Ok(res)\n }\n}\n\npub fn module_codemap(text: &str, codemap: Arc) -> (Result, Errors) {\n let mut errors = Errors::new();\n\n let parser = Parser::new((), codemap);\n\n let res = match parser.parse_string(&mut errors, text) {\n Ok(module) => {\n let module: super::ast::Module = module;\n\n error_tee(&mut errors, |mut errors| {\n let mut adapter = errors.make_into_adapter();\n\n match module.lower(&mut adapter) {\n Ok(module) => Ok(module),\n Err(()) => Err(()),\n }\n })\n }\n Err(()) => Err(()),\n };\n\n (res, errors)\n}\n\npub fn module(text: &str) -> (Result, Errors) {\n module_codemap(text, Arc::new(CodeMap::new()))\n}\n\npub fn module_unwrap(text: &str) -> crate::Module {\n let codemap = Arc::new(CodeMap::new());\n match module_codemap(text, codemap.clone()) {\n (Ok(module), errors) => {\n errors.print(&codemap);\n module\n }\n (Err(()), errors) => {\n errors.print(&codemap);\n panic!();\n }\n }\n}\n\npub fn function_map_codemap(\n text: &str,\n codemap: Arc,\n) -> (Result<(crate::Function, LowerMap), ()>, Errors) {\n let mut errors = Errors::new();\n\n let parser = Parser::new((), codemap);\n\n let ret = match parser.parse_string(&mut errors, text) {\n Ok(named) => {\n let named: NamedFunction = named;\n\n error_tee(&mut errors, |mut errors| {\n let mut adapter = errors.make_into_adapter();\n\n match named.function.lower(&mut adapter, named.name) {\n Ok(res) => Ok(res),\n Err(()) => Err(()),\n }\n })\n }\n Err(()) => Err(()),\n };\n\n (ret, errors)\n}\n\npub fn function_map(text: &str) -> (Result<(crate::Function, LowerMap), ()>, Errors) {\n function_map_codemap(text, Arc::new(CodeMap::new()))\n}\n\npub fn function_codemap(\n text: &str,\n codemap: Arc,\n) -> (Result, Errors) {\n match function_map_codemap(text, codemap) {\n (Ok((fun, _)), errors) => (Ok(fun), errors),\n (Err(()), errors) => (Err(()), errors),\n }\n}\n\npub fn function(text: &str) -> (Result, Errors) {\n match function_map(text) {\n (Ok((fun, _)), errors) => (Ok(fun), errors),\n (Err(()), errors) => (Err(()), errors),\n }\n}\n\npub fn function_unwrap(text: &str) -> crate::Function {\n let codemap = Arc::new(CodeMap::new());\n match function_codemap(text, codemap.clone()) {\n (Ok(fun), errors) => {\n errors.print(&codemap);\n fun\n }\n (Err(()), errors) => {\n errors.print(&codemap);\n panic!();\n }\n }\n}\n\npub fn function_map_unwrap(text: &str) -> (crate::Function, LowerMap) {\n let codemap = Arc::new(CodeMap::new());\n match function_map_codemap(text, codemap.clone()) {\n (Ok(fun), errors) => {\n errors.print(&codemap);\n fun\n }\n (Err(()), errors) => {\n errors.print(&codemap);\n panic!();\n }\n }\n}\n\n#[cfg(test)]\nmod test {\n\n use std::sync::Arc;\n\n use super::function_unwrap;\n use super::{NamedFunction, Parser};\n use crate::text::ast;\n\n use libeir_diagnostics::{CodeMap, SourceSpan};\n use libeir_intern::Ident;\n use libeir_util_parse::Errors;\n\n use pretty_assertions::assert_eq;\n\n #[test]\n fn parse_empty_function() {\n let codemap = Arc::new(CodeMap::new());\n let mut errors = Errors::new();\n\n let parser = Parser::new((), codemap);\n\n let _module: NamedFunction = parser\n .parse_string(&mut errors, \"a'foo':a'foo'/1 {}\")\n .unwrap();\n }\n\n #[test]\n #[should_panic]\n fn lower_empty_function_fails() {\n function_unwrap(\"a'foo':a'foo'/1 {}\");\n }\n\n #[test]\n fn parse_kitchen_sink() {\n let codemap = Arc::new(CodeMap::new());\n let mut errors = Errors::new();\n let parser = Parser::new((), codemap);\n let module: ast::Module = parser\n .parse_string(\n &mut errors,\n \"\na'kitchen_sink' {\n a'something'/1 {\n entry(%return, %throw, %num):\n %something = a'true';\n %fun = a'a':a'b'/a'c';\n %foobar(%woo, %hoo);\n }\n a'second_fun'/0 {}\n}\n\",\n )\n .unwrap();\n\n //let ref_module = ast::Module {\n // span: SourceSpan::UNKNOWN,\n // name: Ident::from_str(\"kitchen_sink\"),\n // items: vec![\n // ast::ModuleItem::Function(ast::Function {\n // span: SourceSpan::UNKNOWN,\n // name: Ident::from_str(\"something\"),\n // arity: 1.into(),\n // items: vec![\n // ast::FunctionItem::Label(ast::Label {\n // span: SourceSpan::UNKNOWN,\n // name: ast::Value::Block(Ident::from_str(\"entry\")),\n // args: vec![\n // ast::Value::Value(Ident::from_str(\"return\")),\n // ast::Value::Value(Ident::from_str(\"throw\")),\n // ast::Value::Value(Ident::from_str(\"num\")),\n // ],\n // }),\n // ast::FunctionItem::Assignment(ast::Assignment {\n // span: SourceSpan::UNKNOWN,\n // lhs: ast::Value::Value(Ident::from_str(\"something\")),\n // rhs: ast::Value::Atom(Ident::from_str(\"true\")),\n // }),\n // ast::FunctionItem::Assignment(ast::Assignment {\n // span: SourceSpan::UNKNOWN,\n // lhs: ast::Value::Value(Ident::from_str(\"fun\")),\n // rhs: ast::Value::CaptureFunction(\n // Box::new(ast::Value::Atom(Ident::from_str(\"a\"))),\n // Box::new(ast::Value::Atom(Ident::from_str(\"b\"))),\n // Box::new(ast::Value::Atom(Ident::from_str(\"c\"))),\n // ),\n // }),\n // ast::FunctionItem::Op(ast::Op::CallControlFlow(ast::CallControlFlowOp {\n // span: SourceSpan::UNKNOWN,\n // target: ast::Value::Value(Ident::from_str(\"foobar\")),\n // args: vec![\n // ast::Value::Value(Ident::from_str(\"woo\")),\n // ast::Value::Value(Ident::from_str(\"hoo\")),\n // ],\n // })),\n // ],\n // }),\n // ast::ModuleItem::Function(ast::Function {\n // span: SourceSpan::UNKNOWN,\n // name: Ident::from_str(\"second_fun\"),\n // arity: 0.into(),\n // items: vec![],\n // }),\n // ],\n //};\n\n //assert_eq!(module, ref_module);\n }\n\n #[test]\n fn lower_add_one() {\n let _fun = function_unwrap(\n \"\na'foo':a'add_one'/1 {\n entry(%return, %throw, %num):\n %add_fun = a'erlang':a'+'/2;\n %add_fun(%return, %throw, %num, 1);\n}\n\",\n );\n }\n\n #[test]\n fn location() {\n let _fun = function_unwrap(\n \"\na'foo':a'bar'/1 {\n !location [\\\"foo\\\":\\\"bar\\\"@\\\"foo.erl\\\":12];\n entry(%ret, %thr, %num):\n %ret(%num);\n}\n\",\n );\n }\n}\n" }, { "path": "libeir_ir/src/text/printer/constant.rs", "content": "use pretty::{Arena, DocAllocator, RefDoc};\n\nuse crate::{AtomicTerm, Const, ConstKind, ConstantContainer};\n\npub fn constant_to_doc<'a>(\n arena: &'a Arena<'a>,\n container: &ConstantContainer,\n constant: Const,\n) -> RefDoc<'a, ()> {\n constant_to_doc_state(arena, container, constant, ConstantState::Normal)\n}\n\n#[derive(Debug, Copy, Clone)]\nenum ConstantState {\n Normal,\n ListTail,\n}\n\nmacro_rules! norm_state {\n ($arena:expr, $state:expr) => {\n match $state {\n ConstantState::Normal => $arena.nil(),\n ConstantState::ListTail => $arena\n .space()\n .append($arena.text(\"|\"))\n .append($arena.space()),\n }\n };\n}\n\nfn constant_to_doc_state<'a>(\n arena: &'a Arena<'a>,\n container: &ConstantContainer,\n constant: Const,\n state: ConstantState,\n) -> RefDoc<'a, ()> {\n match container.const_kind(constant) {\n ConstKind::Atomic(atomic) => norm_state!(arena, state)\n .append(atomic_to_doc(arena, atomic))\n .into_doc(),\n ConstKind::ListCell { head, tail } => match state {\n ConstantState::Normal => arena\n .nil()\n .append(arena.text(\"[\"))\n .append(constant_to_doc_state(\n arena,\n container,\n *head,\n ConstantState::Normal,\n ))\n .append(constant_to_doc_state(\n arena,\n container,\n *tail,\n ConstantState::ListTail,\n ))\n .append(arena.text(\"]\"))\n .into_doc(),\n ConstantState::ListTail => arena\n .nil()\n .append(arena.text(\",\"))\n .append(arena.space())\n .append(constant_to_doc_state(\n arena,\n container,\n *head,\n ConstantState::Normal,\n ))\n .append(constant_to_doc_state(\n arena,\n container,\n *tail,\n ConstantState::ListTail,\n ))\n .into_doc(),\n },\n ConstKind::Tuple { entries } => {\n norm_state!(arena, state)\n .append(arena.text(\"{\"))\n .append(arena.intersperse(\n entries.as_slice(&container.const_pool).iter().map(|c| {\n constant_to_doc_state(arena, container, *c, ConstantState::Normal)\n }),\n arena.text(\",\").append(arena.space()),\n ))\n .append(arena.text(\"}\"))\n .into_doc()\n }\n ConstKind::Map { keys, values } => norm_state!(arena, state)\n .append(arena.text(\"%{\"))\n .append(\n arena.intersperse(\n keys.as_slice(&container.const_pool)\n .iter()\n .zip(values.as_slice(&container.const_pool).iter())\n .map(|(k, v)| {\n arena\n .nil()\n .append(constant_to_doc_state(\n arena,\n container,\n *k,\n ConstantState::Normal,\n ))\n .append(arena.space())\n .append(arena.text(\"=>\"))\n .append(arena.space())\n .append(constant_to_doc_state(\n arena,\n container,\n *v,\n ConstantState::Normal,\n ))\n }),\n arena.text(\",\").append(arena.space()),\n ),\n )\n .append(arena.text(\"}\"))\n .into_doc(),\n }\n}\n\nfn atomic_to_doc<'a>(arena: &'a Arena<'a>, atomic: &AtomicTerm) -> RefDoc<'a, ()> {\n arena.text(format!(\"{}\", atomic)).into_doc()\n}\n" }, { "path": "libeir_ir/src/text/printer/mod.rs", "content": "#![allow(unused)]\n\nuse std::collections::BTreeMap;\nuse std::error::Error;\nuse std::fmt::Write;\nuse std::marker::PhantomData;\n\nuse cranelift_entity::EntityRef;\nuse petgraph::visit::Dfs;\nuse pretty::{Arena, DocAllocator, RefDoc};\n\nuse crate::graph::EntityVisitMap;\nuse crate::{\n BinOp, Block, CallKind, Const, Function, LogicOp, Module, OpKind, PrimOpKind, Value, ValueKind,\n};\n\nmod constant;\nmod operation;\n\ntype DynError = Box;\n\n//pub trait EirPrint\n//where\n// B: BlockIteratorConfig,\n// V: ValueFormatter,\n// L: BlockValueLayout,\n//{\n// type Context;\n// fn to_eir_text(&self, config: &FormatConfig, context: &Self::Context) -> String;\n//}\n\n//impl EirPrint for Block\n//where\n// B: BlockIteratorConfig,\n// V: ValueFormatter,\n// L: BlockValueLayout,\n//{\n//}\n\nfn get_value_list<'a>(fun: &'a Function, value: Value) -> Option<&'a [Value]> {\n if let Some(prim) = fun.value_primop(value) {\n match fun.primop_kind(prim) {\n crate::PrimOpKind::ValueList => return Some(fun.primop_reads(prim)),\n _ => (),\n }\n }\n None\n}\n\npub struct FormatConfig\nwhere\n B: BlockIteratorConfig,\n V: ValueFormatter,\n L: BlockValueLayout,\n{\n pub width: usize,\n\n pub print_locations: bool,\n\n /// Encapsulates the iteration order for blocks within a function.\n pub block_iterator_config: B,\n\n /// Formatter for values within a function.\n pub value_formatter: V,\n\n /// Layout for values within a function.\n pub block_value_layout: L,\n}\n\npub type StandardFormatConfig =\n FormatConfig;\nimpl Default for StandardFormatConfig {\n fn default() -> Self {\n FormatConfig {\n width: 80,\n print_locations: true,\n block_iterator_config: DfsBlockIteratorConfig,\n value_formatter: StandardValueFormatter,\n block_value_layout: ReferencePrimopBlockValueLayout::default(),\n }\n }\n}\n\npub struct FormatState<'a> {\n pub function: &'a Function,\n pub nesting: usize,\n}\n\n/// Iteration strategy for blocks within a function\npub trait BlockIteratorConfig {\n type Iter: BlockIterator;\n fn new(&self, fun: &Function) -> Self::Iter;\n}\n/// Implementation of block iteration strategy.\n/// ## Invariants\n/// * Each block MUST be returned at most once.\npub trait BlockIterator {\n fn next(&mut self, fun: &Function) -> Option;\n}\n\npub struct DfsBlockIteratorConfig;\nimpl BlockIteratorConfig for DfsBlockIteratorConfig {\n type Iter = DfsBlockIterator;\n fn new(&self, fun: &Function) -> Self::Iter {\n let graph = fun.block_graph();\n let entry = fun.block_entry();\n let dfs = Dfs::new(&graph, entry);\n DfsBlockIterator { dfs }\n }\n}\npub struct DfsBlockIterator {\n dfs: Dfs>,\n}\nimpl BlockIterator for DfsBlockIterator {\n fn next(&mut self, fun: &Function) -> Option {\n self.dfs.next(&fun.block_graph())\n }\n}\n\n#[derive(Debug, Copy, Clone, Eq, PartialEq)]\n#[allow(dead_code)]\npub enum ValueSite {\n Decl,\n Use,\n}\npub trait ValueFormatter {\n fn value(&self, out: &mut String, fun: &Function, site: ValueSite, value: Value);\n}\n\n/// This value formatter prints values in the format supported by the\n/// parser, and is considered the standard format.\npub struct StandardValueFormatter;\nimpl ValueFormatter for StandardValueFormatter {\n fn value(&self, out: &mut String, fun: &Function, _site: ValueSite, value: Value) {\n match fun.value_kind(value) {\n ValueKind::Block(block) => write!(out, \"{}\", block).unwrap(),\n _ => write!(out, \"%{}\", value.index()).unwrap(),\n }\n }\n}\n\npub trait BlockValueLayout {\n /// Lays out the root scope for the module. This is called once\n /// at the beginning of processing a module.\n fn layout_module(&mut self, fun: &Function);\n /// Lays out the given block. This will be called once for each block.\n fn layout(&mut self, fun: &Function, block: Block);\n\n /// Values for the current layout.\n fn values(&self) -> &[Value];\n\n /// Queries whether the given value should be laid out inline, or if\n /// it should be referenced by value.\n fn should_layout(&self, value: Value, within: Option) -> bool;\n}\n\npub struct ReferencePrimopBlockValueLayout {\n values: Vec,\n values_set: BTreeMap,\n}\nimpl Default for ReferencePrimopBlockValueLayout {\n fn default() -> Self {\n ReferencePrimopBlockValueLayout {\n values: Vec::new(),\n values_set: BTreeMap::new(),\n }\n }\n}\nimpl BlockValueLayout for ReferencePrimopBlockValueLayout {\n fn layout_module(&mut self, fun: &Function) {}\n fn layout(&mut self, fun: &Function, block: Block) {\n self.values.clear();\n self.values_set.clear();\n\n fun.block_walk_nested_values::<_, ()>(block, &mut |value| {\n if fun.value_primop(value).is_some() {\n self.values.push(value);\n }\n Ok(())\n });\n\n for (idx, value) in self.values.iter().enumerate() {\n self.values_set.insert(*value, idx);\n }\n\n let mut idx = 0;\n let values_set = &self.values_set;\n self.values.retain(|val| {\n let ret = values_set[val] == idx;\n idx += 1;\n ret\n });\n }\n\n fn values(&self) -> &[Value] {\n &self.values\n }\n\n fn should_layout(&self, value: Value, within: Option) -> bool {\n !self.values_set.contains_key(&value)\n }\n}\n\npub trait BlockFormatSink {\n type LineIndex: Copy;\n\n fn write_indent(&mut self, num: usize) -> Result<(), DynError> {\n for _ in 0..num {\n self.write_str(\" \")?;\n }\n Ok(())\n }\n\n fn write_str(&mut self, string: &str) -> Result<(), DynError>;\n fn commit_line(&mut self) -> Result;\n\n /// Informs the sink that the given range of lines\n /// contains the given blocks.\n /// Blocks will never overlap, and this will be called\n /// at most once for each block.\n fn block_lines(&mut self, _block: Block, _range: (Self::LineIndex, Self::LineIndex)) {}\n}\n\npub struct StringSink {\n string: String,\n}\nimpl StringSink {\n pub fn new() -> Self {\n StringSink {\n string: String::new(),\n }\n }\n pub fn finalize(self) -> String {\n self.string\n }\n}\nimpl BlockFormatSink for StringSink {\n type LineIndex = ();\n fn write_str(&mut self, string: &str) -> Result<(), DynError> {\n self.string.push_str(string);\n Ok(())\n }\n fn commit_line(&mut self) -> Result<(), DynError> {\n self.string.push('\\n');\n Ok(())\n }\n}\n\npub(crate) struct FunctionFormatData<'a, B, V, L>\nwhere\n B: BlockIteratorConfig,\n V: ValueFormatter,\n L: BlockValueLayout,\n{\n pub arena: &'a Arena<'a>,\n pub buf: String,\n pub value_buf: Vec,\n pub config: PhantomData>,\n}\nimpl<'a, B, V, L> FunctionFormatData<'a, B, V, L>\nwhere\n B: BlockIteratorConfig,\n V: ValueFormatter,\n L: BlockValueLayout,\n{\n pub(crate) fn block_to_doc(\n &mut self,\n config: &mut FormatConfig,\n state: &mut FormatState,\n block: Block,\n ) -> RefDoc<'a, ()> {\n let arena = self.arena;\n\n let pre;\n if config.print_locations {\n let loc = state.function.block_location(block);\n let loc_str = state.function.locations.format_loc(loc);\n pre = arena\n .nil()\n .append(arena.text(\"!location\"))\n .append(arena.space())\n .append(arena.as_string(loc))\n .append(arena.space())\n .append(arena.as_string(loc_str))\n .append(arena.text(\";\"))\n .append(arena.hardline());\n } else {\n pre = arena.nil();\n }\n\n let ident = arena.as_string(block);\n let args = arena\n .intersperse(\n state.function.block_args(block).iter().map(|v| {\n self.buf.clear();\n config.value_formatter.value(\n &mut self.buf,\n state.function,\n ValueSite::Decl,\n *v,\n );\n arena.as_string(&self.buf)\n }),\n arena.text(\", \"),\n )\n .parens();\n let header = ident.append(args).append(\":\").group();\n\n let body = self.block_body_to_doc(config, state, block);\n\n pre.append(header)\n .append(arena.hardline().append(body).nest(2))\n .into_doc()\n }\n\n pub(crate) fn block_body_to_doc(\n &mut self,\n config: &mut FormatConfig,\n state: &mut FormatState,\n block: Block,\n ) -> RefDoc<'a, ()> {\n let arena = self.arena;\n\n //let mut value_buf = Vec::new();\n //state.function.block_walk_nested_values::<_, ()>(block, &mut |val| {\n // match state.function.value_kind(val) {\n // ValueKind::PrimOp(prim) => {\n // value_buf.push(val);\n // },\n // _ => (),\n // }\n // Ok(())\n //});\n //println!(\"value buf: {:?}\", value_buf);\n\n config.block_value_layout.layout(state.function, block);\n let value_buf = config.block_value_layout.values();\n\n let values = arena.concat(\n value_buf\n .iter()\n .rev()\n .map(|v| self.value_assign_to_doc(config, state, *v))\n .map(|v| arena.nil().append(v).append(arena.hardline())),\n );\n\n let op = self.block_op_to_doc(config, state, block);\n\n values.append(op).into_doc()\n }\n\n pub(crate) fn value_assign_to_doc(\n &mut self,\n config: &FormatConfig,\n state: &mut FormatState,\n value: Value,\n ) -> RefDoc<'a, ()> {\n let arena = self.arena;\n\n let value_kind = state.function.value_kind(value);\n let doc = match value_kind {\n ValueKind::PrimOp(prim) => {\n let prim_kind = state.function.primop_kind(prim);\n let reads = state.function.primop_reads(prim);\n\n match prim_kind {\n PrimOpKind::CaptureFunction => {\n assert!(reads.len() == 3);\n arena.nil().append(self.format_callee(config, state, reads))\n }\n PrimOpKind::Tuple => arena\n .intersperse(\n reads\n .iter()\n .map(|r| self.value_use(config, state, *r, Some(value))),\n arena.text(\",\").append(arena.space()),\n )\n .enclose(arena.text(\"{\"), arena.text(\"}\")),\n PrimOpKind::ValueList => arena\n .intersperse(\n reads\n .iter()\n .map(|r| self.value_use(config, state, *r, Some(value))),\n arena.text(\",\").append(arena.space()),\n )\n .enclose(arena.text(\"<\"), arena.text(\">\")),\n PrimOpKind::ListCell => {\n assert!(reads.len() == 2);\n arena\n .nil()\n .append(arena.text(\"[\"))\n .append(self.value_use(config, state, reads[0], Some(value)))\n .append(arena.space())\n .append(arena.text(\"|\"))\n .append(arena.space())\n .append(self.value_use(config, state, reads[1], Some(value)))\n .append(arena.text(\"]\"))\n }\n PrimOpKind::BinOp(BinOp::Equal) => {\n assert!(reads.len() == 2);\n arena\n .nil()\n .append(self.value_use(config, state, reads[0], Some(value)))\n .append(arena.space())\n .append(arena.text(\"==\"))\n .append(arena.space())\n .append(self.value_use(config, state, reads[1], Some(value)))\n }\n PrimOpKind::LogicOp(LogicOp::And) => arena\n .intersperse(\n reads\n .iter()\n .map(|r| self.value_use(config, state, *r, Some(value))),\n arena.text(\",\").append(arena.space()),\n )\n .enclose(\"and[\", \"]\"),\n PrimOpKind::LogicOp(LogicOp::Or) => arena\n .intersperse(\n reads\n .iter()\n .map(|r| self.value_use(config, state, *r, Some(value))),\n arena.text(\",\").append(arena.space()),\n )\n .enclose(\"or[\", \"]\"),\n _ => unimplemented!(\"{:?}\", prim_kind),\n }\n }\n _ => unimplemented!(\"{:?}\", value_kind),\n };\n\n self.buf.clear();\n config\n .value_formatter\n .value(&mut self.buf, state.function, ValueSite::Decl, value);\n let value_doc = arena.as_string(&self.buf);\n\n arena\n .nil()\n .append(value_doc)\n .append(arena.space())\n .append(arena.text(\"=\"))\n .append(arena.space())\n .append(doc)\n .append(arena.text(\";\"))\n .into_doc()\n }\n\n fn constant(\n &mut self,\n _config: &FormatConfig,\n state: &mut FormatState,\n constant: Const,\n ) -> RefDoc<'a, ()> {\n self::constant::constant_to_doc(&self.arena, state.function.cons(), constant)\n }\n\n fn value_use_only(\n &mut self,\n config: &FormatConfig,\n state: &mut FormatState,\n value: Value,\n ) -> RefDoc<'a, ()> {\n self.buf.clear();\n config\n .value_formatter\n .value(&mut self.buf, state.function, ValueSite::Use, value);\n self.arena.as_string(&self.buf).into_doc()\n }\n\n fn value_use(\n &mut self,\n config: &FormatConfig,\n state: &mut FormatState,\n value: Value,\n within: Option,\n ) -> RefDoc<'a, ()> {\n if config.block_value_layout.should_layout(value, within) {\n match state.function.value_kind(value) {\n ValueKind::Const(cons) => self.constant(config, state, cons),\n _ => self.value_use_only(config, state, value),\n }\n } else {\n self.value_use_only(config, state, value)\n }\n }\n\n fn format_callee(\n &mut self,\n config: &FormatConfig,\n state: &mut FormatState,\n reads: &[Value],\n ) -> RefDoc<'a, ()> {\n let arena = self.arena;\n\n // Resolve arity first, since we should always know arity\n let ac = state.function.value_const(reads[2]).unwrap();\n let arity = self.constant(config, state, ac);\n\n let m = reads[0];\n let f = reads[1];\n let mk = state.function.value_kind(m);\n if let ValueKind::Const(mc) = mk {\n let doc = self.constant(config, state, mc);\n let fk = state.function.value_kind(f);\n if let ValueKind::Const(fc) = fk {\n arena\n .nil()\n .append(doc)\n .append(arena.text(\":\"))\n .append(self.constant(config, state, fc))\n .append(arena.text(\"/\"))\n .append(arity)\n .into_doc()\n } else {\n arena\n .nil()\n .append(doc)\n .append(arena.text(\":\"))\n .append(self.value_use_only(config, state, f))\n .append(arena.text(\"/\"))\n .append(arity)\n .into_doc()\n }\n } else {\n arena\n .nil()\n .append(self.value_use_only(config, state, m))\n .append(arena.text(\":\"))\n .append(self.value_use_only(config, state, f))\n .append(arena.text(\"/\"))\n .append(arity)\n .into_doc()\n }\n }\n}\n\nfn format_function_body_state(\n config: &mut FormatConfig,\n state: &mut FormatState,\n sink: &mut S,\n) -> Result<(), DynError>\nwhere\n B: BlockIteratorConfig,\n V: ValueFormatter,\n L: BlockValueLayout,\n S: BlockFormatSink,\n{\n let function = state.function;\n let mut block_iter = config.block_iterator_config.new(function);\n\n let arena = Arena::new();\n let mut ctx = FunctionFormatData {\n arena: &arena,\n buf: String::new(),\n value_buf: Vec::new(),\n config: PhantomData,\n };\n\n let inner_width = config.width - (state.nesting * 2);\n\n while let Some(block) = block_iter.next(function) {\n let doc = ctx.block_to_doc(config, state, block);\n\n ctx.buf.clear();\n doc.render_fmt(inner_width, &mut ctx.buf).unwrap();\n\n let mut first_line = None;\n let mut last_line = None;\n\n for line in ctx.buf.lines() {\n sink.write_indent(state.nesting)?;\n sink.write_str(line)?;\n let line = sink.commit_line()?;\n\n first_line = Some(first_line.unwrap_or(line));\n last_line = Some(line);\n }\n\n sink.block_lines(block, (first_line.unwrap(), last_line.unwrap()));\n }\n\n Ok(())\n}\n\npub fn format_function_body(\n function: &Function,\n config: &mut FormatConfig,\n sink: &mut S,\n) -> Result<(), DynError>\nwhere\n B: BlockIteratorConfig,\n V: ValueFormatter,\n L: BlockValueLayout,\n S: BlockFormatSink,\n{\n let mut state = FormatState {\n function,\n nesting: 0,\n };\n format_function_body_state(config, &mut state, sink)\n}\n\npub fn format_module(\n module: &Module,\n config: &mut FormatConfig,\n sink: &mut S,\n) -> Result<(), DynError>\nwhere\n B: BlockIteratorConfig,\n V: ValueFormatter,\n L: BlockValueLayout,\n S: BlockFormatSink,\n{\n sink.write_str(&format!(\"{} {{\\n\", module.name().name.as_str().get()));\n\n let num_functions = module.function_iter().count();\n for (i, fun) in module.function_iter().enumerate() {\n let function = fun.function();\n let ident = function.ident();\n sink.write_str(&format!(\" {}/{} {{\\n\", &ident.name, ident.arity));\n let mut state = FormatState {\n function,\n nesting: 2,\n };\n format_function_body_state(config, &mut state, sink)?;\n if i + 1 < num_functions {\n sink.write_str(\" }\\n\\n\");\n } else {\n sink.write_str(\" }\\n\");\n }\n }\n\n sink.write_str(\"}\\n\");\n\n Ok(())\n}\n\nimpl Function {\n pub fn to_text(&self, config: &mut FormatConfig) -> String\n where\n B: BlockIteratorConfig,\n V: ValueFormatter,\n L: BlockValueLayout,\n {\n let mut sink = StringSink::new();\n format_function_body(self, config, &mut sink).unwrap();\n sink.finalize()\n }\n\n pub fn to_text_standard(&self) -> String {\n self.to_text(&mut StandardFormatConfig::default())\n }\n\n pub fn block_to_text(&self, block: Block, config: &mut FormatConfig) -> String\n where\n B: BlockIteratorConfig,\n V: ValueFormatter,\n L: BlockValueLayout,\n {\n let mut sink = StringSink::new();\n\n let arena = Arena::new();\n let mut ctx = FunctionFormatData {\n arena: &arena,\n buf: String::new(),\n value_buf: Vec::new(),\n config: PhantomData,\n };\n\n let mut state = FormatState {\n function: self,\n nesting: 0,\n };\n\n let doc = ctx.block_to_doc(config, &mut state, block);\n\n ctx.buf.clear();\n doc.render_fmt(config.width, &mut ctx.buf).unwrap();\n ctx.buf\n }\n}\n\nimpl Module {\n pub fn to_text(&self, config: &mut FormatConfig) -> String\n where\n B: BlockIteratorConfig,\n V: ValueFormatter,\n L: BlockValueLayout,\n {\n let mut sink = StringSink::new();\n format_module(self, config, &mut sink).unwrap();\n sink.finalize()\n }\n\n pub fn to_text_standard(&self) -> String {\n self.to_text(&mut StandardFormatConfig::default())\n }\n}\n\n#[cfg(test)]\nmod tests {\n use super::{format_function_body, FormatConfig, StandardFormatConfig, StringSink};\n\n #[test]\n fn woo() {\n let ir = crate::parse_function_unwrap(\n \"\na'woo':a'hoo'/1 {\n entry(%ret, %thr, %a):\n %f1 = a'erlang':a'+'/2;\n %f1(%a, 2) => b2 except %thr;\n b2(%b):\n %f2 = a'erlang':a'/'/2;\n %f2(%b, 2) => %ret except %thr;\n}\n\",\n );\n let text = ir.to_text(&mut StandardFormatConfig::default());\n println!(\"{}\", text);\n }\n}\n" }, { "path": "libeir_ir/src/text/printer/operation.rs", "content": "use log::warn;\nuse pretty::{DocAllocator, RefDoc};\n\nuse crate::binary::{BinaryEntrySpecifier, Endianness};\nuse crate::traits::FormatOpCtx;\nuse crate::{BasicType, Block, CallKind, DynValue, MatchKind, OpKind, Value};\n\nuse super::{\n get_value_list, BlockIteratorConfig, BlockValueLayout, FormatConfig, FormatState,\n FunctionFormatData, ValueFormatter,\n};\n\npub struct FormatOpCtxImpl<'a, 'b, 'doc, B, V, L>\nwhere\n B: BlockIteratorConfig,\n V: ValueFormatter,\n L: BlockValueLayout,\n{\n format_data: &'a mut FunctionFormatData<'doc, B, V, L>,\n config: &'a FormatConfig,\n state: &'a mut FormatState<'b>,\n}\n\nimpl<'a, 'b, 'doc, B, V, L> FormatOpCtx<'doc> for FormatOpCtxImpl<'a, 'b, 'doc, B, V, L>\nwhere\n B: BlockIteratorConfig,\n V: ValueFormatter,\n L: BlockValueLayout,\n{\n fn arena(&self) -> &'doc pretty::Arena<'doc> {\n self.format_data.arena\n }\n\n fn value_use_to_doc(&mut self, value: DynValue) -> RefDoc<'doc, ()> {\n let val = self.state.function.value_get(value).unwrap();\n self.format_data\n .value_use(self.config, self.state, val, None)\n }\n}\n\nfn binary_specifier_to_doc<'a>(\n arena: &'a pretty::Arena<'a>,\n spec: &BinaryEntrySpecifier,\n) -> RefDoc<'a, ()> {\n let f_endianness = |end| match end {\n &Endianness::Big => arena.text(\"big\"),\n &Endianness::Little => arena.text(\"little\"),\n &Endianness::Native => arena.text(\"native\"),\n };\n let f_signed = |signed| match signed {\n true => arena.text(\"signed\"),\n false => arena.text(\"unsigned\"),\n };\n\n match spec {\n BinaryEntrySpecifier::Integer {\n signed,\n endianness,\n unit,\n } => {\n let items = [\n f_signed(*signed),\n f_endianness(endianness),\n arena.as_string(unit),\n ];\n arena\n .text(\"integer\")\n .append(\n arena\n .intersperse(items.iter().cloned(), arena.text(\",\"))\n .parens(),\n )\n .into_doc()\n }\n BinaryEntrySpecifier::Float { endianness, unit } => {\n let items = [f_endianness(endianness), arena.as_string(unit)];\n arena\n .text(\"float\")\n .append(\n arena\n .intersperse(items.iter().cloned(), arena.text(\",\"))\n .parens(),\n )\n .into_doc()\n }\n BinaryEntrySpecifier::Bytes { unit } => arena\n .text(\"bytes\")\n .append(arena.as_string(unit).parens())\n .into_doc(),\n BinaryEntrySpecifier::Bits { unit } => arena\n .text(\"bits\")\n .append(arena.as_string(unit).parens())\n .into_doc(),\n BinaryEntrySpecifier::Utf8 => arena.text(\"utf8\").append(arena.nil().parens()).into_doc(),\n BinaryEntrySpecifier::Utf16 { endianness } => arena\n .text(\"utf16\")\n .append(f_endianness(endianness))\n .into_doc(),\n BinaryEntrySpecifier::Utf32 { endianness } => arena\n .text(\"utf32\")\n .append(f_endianness(endianness))\n .into_doc(),\n }\n}\n\nimpl<'a, B, V, L> FunctionFormatData<'a, B, V, L>\nwhere\n B: BlockIteratorConfig,\n V: ValueFormatter,\n L: BlockValueLayout,\n{\n pub fn block_op_to_doc(\n &mut self,\n config: &FormatConfig,\n state: &mut FormatState,\n block: Block,\n ) -> RefDoc<'a, ()> {\n let arena = self.arena;\n\n let op_opt = state.function.block_kind(block);\n if op_opt.is_none() {\n return arena.text(\"EMPTY_BLOCK\").into_doc();\n }\n\n let op = op_opt.unwrap();\n let reads = state.function.block_reads(block);\n\n let op_doc = match op {\n OpKind::Match { branches } => {\n let dests = reads[0];\n let num_dests = state.function.value_list_length(dests);\n let num_branches = branches.len();\n let mut branches_formatted = Vec::with_capacity(num_branches);\n for (i, kind) in branches.iter().enumerate() {\n let block = state.function.value_list_get_n(dests, i).unwrap();\n let block_val = self.value_use(config, state, block, None);\n let args_vl = reads[i + 2];\n let num_args = state.function.value_list_length(args_vl);\n let mut args = Vec::with_capacity(num_args);\n for n in 0..num_args {\n args.push(state.function.value_list_get_n(args_vl, n).unwrap());\n }\n let formatted = match kind {\n MatchKind::Value => {\n let val = self.value_use(config, state, args[0], None);\n let block_args = arena\n .intersperse(\n args.iter()\n .skip(1)\n .map(|v| self.value_use(config, state, *v, None)),\n arena.text(\",\").append(arena.softline()),\n )\n .nest(1)\n .parens();\n let body = arena.nil().append(block_val).append(block_args);\n arena\n .nil()\n .append(arena.text(\"value\"))\n .append(arena.space())\n .append(val)\n .append(arena.space())\n .append(arena.text(\"=>\"))\n .append(arena.space())\n .append(arena.nil().append(body))\n }\n MatchKind::Type(ty) => {\n let block_args = arena\n .intersperse(\n args.iter().map(|v| self.value_use(config, state, *v, None)),\n arena.text(\",\").append(arena.softline()),\n )\n .nest(1)\n .parens();\n let body = arena.nil().append(block_val).append(block_args);\n arena\n .nil()\n .append(arena.text(\"is_type\"))\n .append(arena.space())\n .append(arena.text(type_to_text(ty)))\n .append(arena.space())\n .append(arena.text(\"=>\"))\n .append(arena.space())\n .append(arena.nil().append(body))\n }\n MatchKind::Binary(ref spec) => {\n let doc = binary_specifier_to_doc(arena, spec);\n arena.nil().append(doc)\n }\n MatchKind::Tuple(arity) => {\n let block_args = arena\n .intersperse(\n args.iter().map(|v| self.value_use(config, state, *v, None)),\n arena.text(\",\").append(arena.softline()),\n )\n .nest(1)\n .parens();\n let body = arena.nil().append(block_val).append(block_args);\n arena\n .nil()\n .append(arena.text(\"{}\"))\n .append(arena.space())\n .append(arena.text(format!(\"arity {}\", arity)))\n .append(arena.space())\n .append(arena.text(\"=>\"))\n .append(arena.space())\n .append(arena.nil().append(body))\n }\n MatchKind::ListCell => {\n let block_args = arena\n .intersperse(\n args.iter().map(|v| self.value_use(config, state, *v, None)),\n arena.text(\",\").append(arena.softline()),\n )\n .nest(1)\n .parens();\n let body = arena.nil().append(block_val).append(block_args);\n arena\n .nil()\n .append(arena.text(\"[]\"))\n .append(arena.space())\n .append(arena.text(\"=>\"))\n .append(arena.space())\n .append(arena.nil().append(body))\n }\n MatchKind::MapItem => {\n let val = self.value_use(config, state, args[0], None);\n let block_args = arena\n .intersperse(\n args.iter()\n .skip(1)\n .map(|v| self.value_use(config, state, *v, None)),\n arena.text(\",\").append(arena.softline()),\n )\n .nest(1)\n .parens();\n let body = arena.nil().append(block_val).append(block_args);\n arena\n .nil()\n .append(val)\n .append(arena.space())\n .append(arena.text(\"=>\"))\n .append(arena.space())\n .append(arena.nil().append(body))\n }\n MatchKind::Wildcard => {\n let block_args = arena\n .intersperse(\n args.iter().map(|v| self.value_use(config, state, *v, None)),\n arena.text(\",\").append(arena.softline()),\n )\n .nest(1)\n .parens();\n let body = arena.nil().append(block_val).append(block_args);\n arena\n .nil()\n .append(arena.text(\"_\"))\n .append(arena.space())\n .append(arena.text(\"=>\"))\n .append(arena.space())\n .append(arena.nil().append(body))\n }\n };\n branches_formatted.push(formatted.indent(2));\n }\n\n let selector = self.value_use(config, state, reads[1], None);\n\n arena\n .nil()\n .append(arena.text(\"match\"))\n .append(arena.space())\n .append(selector)\n .append(arena.space())\n .append(\n arena\n .hardline()\n .append(arena.intersperse(branches_formatted, arena.hardline()))\n .append(arena.hardline())\n .braces(),\n )\n }\n OpKind::Call(CallKind::Function) => {\n let callee_val = self.value_use(config, state, reads[0], None);\n let call_args = arena\n .intersperse(\n reads\n .iter()\n .skip(3)\n .map(|v| self.value_use(config, state, *v, None)),\n arena.text(\",\").append(arena.softline()),\n )\n .nest(1)\n .parens();\n let flow_val = self.value_use(config, state, reads[1], None);\n let exc_val = self.value_use(config, state, reads[2], None);\n arena\n .nil()\n .append(callee_val)\n .append(call_args)\n .append(arena.space())\n .append(arena.text(\"=>\"))\n .append(arena.space())\n .append(flow_val)\n .append(arena.space())\n .append(arena.text(\"except\"))\n .append(arena.space())\n .append(exc_val)\n }\n OpKind::Call(CallKind::ControlFlow) => {\n let fun_val = self.value_use(config, state, reads[0], None);\n let call_args = arena\n .intersperse(\n reads\n .iter()\n .skip(1)\n .map(|v| self.value_use(config, state, *v, None)),\n arena.text(\",\").append(arena.softline()),\n )\n .nest(1)\n .parens();\n arena.nil().append(fun_val).append(call_args)\n }\n OpKind::TraceCaptureRaw => {\n assert!(reads.len() == 1);\n let arg = self.value_use(config, state, reads[0], None);\n arena\n .nil()\n .append(arena.text(\"trace_capture_raw\"))\n .append(arena.space())\n .append(arg)\n }\n OpKind::UnpackValueList(n) => {\n assert!(reads.len() == 2);\n let block = self.value_use(config, state, reads[0], None);\n let val = self.value_use(config, state, reads[1], None);\n arena\n .nil()\n .append(arena.text(\"unpack\"))\n .append(arena.space())\n .append(val)\n .append(arena.space())\n .append(arena.text(\"arity\"))\n .append(arena.space())\n .append(arena.as_string(&format!(\"{}\", n)))\n .append(arena.space())\n .append(arena.text(\"=>\"))\n .append(arena.space())\n .append(block)\n }\n OpKind::IfBool => match reads.len() {\n 3 => arena\n .nil()\n .append(arena.text(\"if_bool\"))\n .append(arena.space())\n .append(self.value_use(config, state, reads[2], None))\n .append(arena.space())\n .append(self.value_use(config, state, reads[0], None))\n .append(arena.space())\n .append(self.value_use(config, state, reads[1], None)),\n 4 => arena\n .nil()\n .append(arena.text(\"if_bool\"))\n .append(arena.space())\n .append(self.value_use(config, state, reads[3], None))\n .append(arena.space())\n .append(self.value_use(config, state, reads[0], None))\n .append(arena.space())\n .append(self.value_use(config, state, reads[1], None))\n .append(arena.space())\n .append(self.value_use(config, state, reads[2], None)),\n _ => panic!(),\n },\n OpKind::Unreachable => arena.text(\"unreachable\"),\n OpKind::Dyn(op) => {\n if let Some(printer) = state.function.dialect().get_op_printer(&**op) {\n let mut ctx_impl = FormatOpCtxImpl {\n format_data: self,\n config,\n state,\n };\n\n let doc = printer.to_doc(&mut ctx_impl, block);\n arena.nil().append(doc)\n } else {\n let call_args = arena\n .intersperse(\n reads\n .iter()\n .map(|v| self.value_use(config, state, *v, None)),\n arena.text(\",\").append(arena.softline()),\n )\n .nest(1)\n .parens();\n arena.as_string(op.name()).append(call_args)\n }\n }\n _ => {\n warn!(\"Unimplemented printer for OP: {:?}\", op);\n arena.text(\"unknown\")\n }\n };\n\n op_doc.append(arena.text(\";\")).into_doc()\n }\n}\n\nfn type_to_text(ty: &BasicType) -> String {\n match ty {\n BasicType::List => \"list\".to_owned(),\n BasicType::ListCell => \"cons\".to_owned(),\n BasicType::Nil => \"nil\".to_owned(),\n BasicType::Tuple(arity) => format!(\"tuple({})\", arity),\n BasicType::Map => \"map\".to_owned(),\n BasicType::Number => \"number\".to_owned(),\n BasicType::Float => \"float\".to_owned(),\n BasicType::Integer => \"integer\".to_owned(),\n BasicType::SmallInteger => \"smallint\".to_owned(),\n BasicType::BigInteger => \"bigint\".to_owned(),\n }\n}\n" }, { "path": "libeir_ir/src/text/printer.old.rs", "content": "#![allow(clippy::write_with_newline)]\n\nuse std::io::{ Write, Error as IoError };\n\nuse crate::{ Module, Function, FunctionIdent };\nuse crate::{ Block, Value };\nuse crate::{ OpKind, PrimOpKind, BinOp, MatchKind, BasicType, BinaryEntrySpecifier, Endianness, CallKind };\nuse crate::AtomTerm;\nuse crate::ValueKind;\nuse crate::pattern::{ PatternContainer, PatternNode, PatternNodeKind };\n\nuse cranelift_entity::EntityRef;\n\nuse std::collections::{HashSet, VecDeque, BTreeSet};\n\n// Desired syntax:\n\n// ```\n// something {\n//\n// something:something/2@1.1 {\n// entry(%0, %1):\n// %2, %3 = call woo:hoo(%0) except l0(%3);\n// tombstone %3;\n// jump l1(%2);\n//\n// l0(%4):\n// tombstone %2;\n// return_error %4;\n//\n// l1(%5):\n// return_ok %5;\n//\n// l2():\n// %6 = match_start on: %1, values: [%0] {\n// clause {\n// pattern [$0 = 0 | []];\n// };\n// };\n// jump l3();\n// l3():\n// match_body %6 fail err() leaves [clause1()];\n//\n// err():\n// return_error a'nil';\n//\n// clause1():\n// %7 = case_calues [$0];\n// case_guard_ok %7;\n//\n// }\n//\n// }\n// ```\n\npub trait EirAnnotator {\n fn annotate_function(&mut self, out: &mut String, fun: &Function);\n fn annotate_block(&mut self, out: &mut String, fun: &Function, block: Block);\n}\n\n//pub struct EirLiveValuesAnnotator {\n// live: Option,\n//}\n//impl EirLiveValuesAnnotator {\n// pub fn new() -> Self {\n// EirLiveValuesAnnotator {\n// live: None,\n// }\n// }\n//}\n//impl EirAnnotator for EirLiveValuesAnnotator {\n// fn annotate_function(&mut self, out: &mut String, fun: &Function) {\n// self.live = Some(fun.live_values());\n// }\n// fn annotate_op(&mut self, out: &mut String, fun: &Function, op: Op) {\n// let live = self.live.as_ref().unwrap();\n// if let Some(l) = live.flow_live.get(&op) {\n// out.push_str(\" live:\");\n// println!(\"LVLEN: {:?}\", live);\n// for var in l.iter(&live.pool) {\n// out.push_str(&format!(\" %{}\", var.index()));\n// }\n// }\n// }\n// fn annotate_ebb(&mut self, out: &mut String, fun: &Function, ebb: Ebb) {\n// let live = self.live.as_ref().unwrap();\n// let l = &live.ebb_live[&ebb];\n// out.push_str(\"yay!\");\n// }\n//}\n\n#[derive(Default)]\npub struct ToEirTextContext {\n out_buf: String,\n annotators: Vec>,\n}\n\nimpl ToEirTextContext {\n pub fn new() -> Self {\n Self::default()\n }\n pub fn add_annotator(&mut self, ann: T) where T: EirAnnotator + 'static {\n self.annotators.push(Box::new(ann));\n }\n pub fn annotate_function(&mut self, fun: &Function) {\n for ann in self.annotators.iter_mut() {\n ann.annotate_function(&mut self.out_buf, fun);\n }\n }\n pub fn annotate_block(&mut self, fun: &Function, block: Block) -> Option {\n self.out_buf.clear();\n for ann in self.annotators.iter_mut() {\n ann.annotate_block(&mut self.out_buf, fun, block);\n }\n if !self.out_buf.is_empty() {\n Some(self.out_buf.to_string())\n } else {\n None\n }\n }\n}\n\npub trait ToEirText {\n fn to_eir_text(&self, ctx: &mut ToEirTextContext, indent: usize, out: &mut dyn Write) -> std::io::Result<()>;\n}\npub trait ToEirTextFun {\n fn to_eir_text_fun(&self, ctx: &mut ToEirTextContext, fun: &Function, indent: usize,\n out: &mut dyn Write) -> std::io::Result<()>;\n}\n\nfn write_indent(out: &mut dyn Write, indent: usize) -> std::io::Result<()> {\n for _ in 0..indent {\n write!(out, \" \")?;\n }\n Ok(())\n}\n\nimpl ToEirText for FunctionIdent {\n fn to_eir_text(&self, _ctx: &mut ToEirTextContext, indent: usize, out: &mut dyn Write) -> std::io::Result<()> {\n write_indent(out, indent)?;\n write!(out, \"{}:{}/{}\",\n self.module, self.name, self.arity)?;\n Ok(())\n }\n}\n\npub fn print_constants(_ctx: &mut ToEirTextContext, _fun: &Function, _indent: usize, _out: &mut dyn Write) -> std::io::Result<()> {\n // TODO\n //let mut used_values = HashSet::new();\n //fun.used_values(&mut used_values);\n\n //let mut values: Vec<_> = used_values.iter().cloned().collect();\n //values.sort();\n\n //for value in values.iter() {\n // let typ = fun.value(*value);\n // match typ {\n // ValueType::Constant(cons) => {\n // write_indent(out, indent)?;\n // write!(out, \"%{} = \", value.index())?;\n // cons.to_eir_text(ctx, indent+1, out)?;\n // write!(out, \";\\n\")?;\n // },\n // ValueType::Variable => (),\n // }\n //}\n\n Ok(())\n}\n\nimpl ToEirText for Module {\n fn to_eir_text(&self, ctx: &mut ToEirTextContext, indent: usize, out: &mut dyn Write) -> std::io::Result<()> {\n let funs: Vec<_> = self.index_iter().collect();\n\n write_indent(out, indent)?;\n write!(out, \"{} {{\\n\\n\", AtomTerm(self.name().name))?;\n\n for idx in funs.iter() {\n let fun_def = &self[*idx];\n let fun = fun_def.function();\n fun.to_eir_text(ctx, indent+1, out)?;\n write!(out, \"\\n\\n\")?;\n }\n\n write_indent(out, indent)?;\n write!(out, \"}}\")?;\n\n Ok(())\n }\n}\n\nimpl ToEirText for Function {\n fn to_eir_text(&self, ctx: &mut ToEirTextContext, indent: usize, out: &mut dyn Write) -> std::io::Result<()> {\n ctx.annotate_function(self);\n let ident = self.ident();\n\n write_indent(out, indent)?;\n write!(out, \"{}/{} {{\\n\", AtomTerm(ident.name.name), ident.arity)?;\n\n // Constants\n print_constants(ctx, self, indent+1, out)?;\n write!(out, \"\\n\")?;\n\n // Blocks\n let mut walked = BTreeSet::new();\n let mut to_walk = VecDeque::new();\n to_walk.push_back(self.block_entry());\n\n while let Some(block) = to_walk.pop_front() {\n if walked.contains(&block) { continue; }\n walked.insert(block);\n\n self.block_walk_nested_values::<_, Result<(), ()>>(block, &mut |v| {\n if let Some(inner) = self.value_block(v) {\n to_walk.push_back(inner);\n }\n Ok(())\n }).unwrap();\n\n block.to_eir_text_fun(ctx, self, indent+1, out)?;\n write!(out, \"\\n\")?;\n }\n\n write_indent(out, indent)?;\n write!(out, \"}}\")?;\n\n Ok(())\n }\n}\n\nfn format_pattern(_ctx: &mut ToEirTextContext, pat: &PatternContainer, _indent: usize,\n annotated_nodes: &HashSet,\n node: PatternNode, out: &mut dyn Write) -> std::io::Result<()> {\n if annotated_nodes.contains(&node) {\n write!(out, \"n{} @ \", node.index())?;\n }\n match pat.node_kind(node) {\n PatternNodeKind::Wildcard => write!(out, \"_\")?,\n _ => write!(out, \"?\")?,\n }\n\n Ok(())\n}\n\nfn get_value_list<'a>(fun: &'a Function, value: Value) -> Option<&'a [Value]> {\n if let Some(prim) = fun.value_primop(value) {\n match fun.primop_kind(prim) {\n crate::PrimOpKind::ValueList =>\n return Some(fun.primop_reads(prim)),\n _ => (),\n }\n }\n None\n}\n\nimpl ToEirTextFun for Block {\n fn to_eir_text_fun(&self, ctx: &mut ToEirTextContext, fun: &Function,\n indent: usize, out: &mut dyn Write)\n -> std::io::Result<()>\n {\n\n write_indent(out, indent)?;\n write!(out, \"{}(\", self)?;\n format_value_list(fun.block_args(*self), fun, out)?;\n write!(out, \"):\\n\")?;\n\n fun.block_walk_nested_values::<_, IoError>(*self, &mut |value| {\n match fun.value_kind(value) {\n ValueKind::PrimOp(prim) => {\n write_indent(out, indent+1)?;\n write!(out, \"%{} = \", value.index())?;\n\n let reads = fun.primop_reads(prim);\n\n match fun.primop_kind(prim) {\n PrimOpKind::CaptureFunction => {\n assert!(reads.len() == 3);\n format_value(reads[0], fun, out)?;\n write!(out, \":\")?;\n format_value(reads[1], fun, out)?;\n write!(out, \"/\")?;\n format_value(reads[2], fun, out)?;\n }\n PrimOpKind::ListCell => {\n assert!(reads.len() == 2);\n write!(out, \"[\")?;\n format_value(reads[0], fun, out)?;\n write!(out, \" | \")?;\n format_value(reads[1], fun, out)?;\n write!(out, \"]\")?;\n }\n PrimOpKind::ValueList => {\n write!(out, \"<\")?;\n format_value_list(reads, fun, out)?;\n write!(out, \">\")?;\n }\n PrimOpKind::BinOp(BinOp::Equal) => {\n assert!(reads.len() == 2);\n format_value(reads[0], fun, out)?;\n write!(out, \" == \")?;\n format_value(reads[1], fun, out)?;\n }\n PrimOpKind::Tuple => {\n write!(out, \"{{\")?;\n for (i, value) in reads.iter().enumerate() {\n if i != 0 {\n write!(out, \", \")?;\n }\n format_value(*value, fun, out)?;\n }\n write!(out, \"}}\")?;\n }\n kind => {\n write!(out, \"{:?}\", kind)?;\n write!(out, \"(\")?;\n format_value_list(reads, fun, out)?;\n write!(out, \")\")?;\n },\n }\n\n write!(out, \";\\n\")?;\n }\n _ => (),\n }\n Ok(())\n })?;\n\n let args = fun.block_reads(*self);\n if let Some(kind) = fun.block_kind(*self) {\n write_indent(out, indent+1)?;\n match kind {\n OpKind::Case { clauses } => {\n let clauses_num = clauses.len(&fun.pool.clause);\n\n let values_start = 1 + (clauses_num * 2);\n\n write!(out, \"case \")?;\n format_value(args[values_start], fun, out)?;\n write!(out, \" {{\")?;\n write!(out, \"\\n\")?;\n\n for clause_num in 0..clauses_num {\n let clause = clauses.get(0, &fun.pool.clause).unwrap();\n let clause_nodes = fun.pat().clause_root_nodes(clause);\n\n let base = 1 + (2 * clause_num);\n let guard = args[base];\n let body = args[base + 1];\n\n let mut annotated_nodes = HashSet::new();\n for bind in fun.pat().clause_binds(clause) {\n annotated_nodes.insert(*bind);\n }\n\n // Pattern body\n write_indent(out, indent + 2)?;\n write!(out, \"(\")?;\n if !clause_nodes.is_empty() {\n write!(out, \"\\n\")?;\n }\n\n for node in clause_nodes {\n write_indent(out, indent + 3)?;\n format_pattern(ctx, fun.pat(), indent+3, &annotated_nodes, *node, out)?;\n write!(out, \"\\n\")?;\n }\n\n if !clause_nodes.is_empty() {\n write_indent(out, indent + 2)?;\n }\n write!(out, \")\")?;\n\n // Guard\n write!(out, \" guard \")?;\n format_value(guard, fun, out)?;\n\n // Body\n write!(out, \" => \")?;\n format_value(body, fun, out)?;\n write!(out, \"(\")?;\n let mut first = true;\n for bind in fun.pat().clause_binds(clause) {\n if !first {\n write!(out, \", \")?;\n }\n first = false;\n\n write!(out, \"n{}\", bind.index())?;\n }\n write!(out, \");\")?;\n\n write!(out, \"\\n\")?;\n }\n\n write_indent(out, indent + 2)?;\n write!(out, \"_ => \")?;\n format_value(args[0], fun, out)?;\n write!(out, \";\")?;\n write!(out, \"\\n\")?;\n\n write_indent(out, indent + 1)?;\n write!(out, \"}}\")?;\n\n }\n OpKind::Match { branches } => {\n let targets_opt = get_value_list(fun, args[0]);\n let targets_one = &[args[0]];\n let targets = targets_opt.unwrap_or(targets_one);\n\n write!(out, \"match \")?;\n format_value(args[1], fun, out)?;\n write!(out, \" {{\\n\")?;\n\n for ((kind, arg), target) in branches.iter()\n .zip(args[2..].iter())\n .zip(targets.iter())\n {\n write_indent(out, indent + 2)?;\n match kind {\n MatchKind::Value => {\n write!(out, \"value \")?;\n format_value(*arg, fun, out)?;\n }\n MatchKind::ListCell => {\n write!(out, \"[]\")?;\n }\n MatchKind::Wildcard => {\n write!(out, \"_\")?;\n }\n MatchKind::Tuple(n) => {\n write!(out, \"{{}} arity {}\", n)?;\n }\n MatchKind::Type(BasicType::Map) => {\n write!(out, \"type %{{}}\")?;\n }\n MatchKind::Type(_) => {\n unimplemented!()\n }\n MatchKind::MapItem => {\n write!(out, \"%{{ \")?;\n format_value(*arg, fun, out)?;\n write!(out, \"}}\")?;\n }\n MatchKind::Binary(spec) => {\n write!(out, \"binary \")?;\n\n match spec {\n BinaryEntrySpecifier::Integer { signed, endianness, unit } => {\n if *signed {\n write!(out, \"signed \")?;\n } else {\n write!(out, \"unsigned \")?;\n }\n match *endianness {\n Endianness::Big => write!(out, \"big \")?,\n Endianness::Little => write!(out, \"little \")?,\n Endianness::Native => write!(out, \"native \")?,\n }\n write!(out, \"unit {} \", unit)?;\n write!(out, \"size \")?;\n format_value(*arg, fun, out)?;\n }\n BinaryEntrySpecifier::Bytes { unit } => {\n write!(out, \"unit {} \", unit)?;\n write!(out, \"size \")?;\n format_value(*arg, fun, out)?;\n }\n _ => unimplemented!(\"{:?}\", spec),\n }\n\n }\n }\n write!(out, \" => \")?;\n format_value(*target, fun, out)?;\n write!(out, \";\\n\")?;\n }\n\n write_indent(out, indent + 1)?;\n write!(out, \"}}\")?;\n }\n OpKind::Call(CallKind::ControlFlow) => {\n format_value(args[0], fun, out)?;\n write!(out, \"(\")?;\n format_value_list(&args[1..], fun, out)?;\n write!(out, \")\")?;\n }\n OpKind::Call(CallKind::Function) => {\n format_value(args[0], fun, out)?;\n write!(out, \"(\")?;\n format_value_list(&args[3..], fun, out)?;\n write!(out, \") => \")?;\n format_value(args[1], fun, out)?;\n write!(out, \" except \")?;\n format_value(args[2], fun, out)?;\n }\n OpKind::Intrinsic(name) => {\n write!(out, \"intrinsic {}(\", name)?;\n format_value_list(args, fun, out)?;\n write!(out, \")\")?;\n }\n OpKind::Unreachable => {\n write!(out, \"unreachable\")?;\n }\n OpKind::IfBool => {\n match args.len() {\n 3 => {\n write!(out, \"if_bool \")?;\n format_value(args[2], fun, out)?;\n write!(out, \" \")?;\n format_value(args[0], fun, out)?;\n write!(out, \" \")?;\n format_value(args[1], fun, out)?;\n }\n 4 => {\n write!(out, \"if_bool \")?;\n format_value(args[3], fun, out)?;\n write!(out, \" \")?;\n format_value(args[0], fun, out)?;\n write!(out, \" \")?;\n format_value(args[1], fun, out)?;\n write!(out, \" \")?;\n format_value(args[2], fun, out)?;\n }\n _ => panic!(),\n }\n }\n OpKind::TraceCaptureRaw => {\n assert!(args.len() == 1);\n write!(out, \"trace_capture_raw \")?;\n format_value(args[0], fun, out)?;\n }\n OpKind::UnpackValueList(n) => {\n assert!(args.len() == 2);\n write!(out, \"unpack \")?;\n format_value(args[1], fun, out)?;\n write!(out, \" arity {} => \", n)?;\n format_value(args[0], fun, out)?;\n }\n _ => {\n write!(out, \"{:?}(\", kind)?;\n format_value_list(args, fun, out)?;\n write!(out, \")\")?;\n }\n }\n\n write!(out, \";\")?;\n }\n\n Ok(())\n }\n}\n\nfn format_value(value: Value, fun: &Function, out: &mut dyn Write) -> std::io::Result<()> {\n match fun.value_kind(value) {\n ValueKind::Block(block) => write!(out, \"{}\", block)?,\n ValueKind::Const(cons) => {\n fun.cons().write(cons, out);\n },\n _ => write!(out, \"%{}\", value.index())?,\n }\n Ok(())\n}\n\nfn format_value_list(values: &[Value], fun: &Function,\n out: &mut dyn Write) -> std::io::Result<()> {\n for (idx, value) in values.iter().enumerate() {\n if idx != 0 {\n write!(out, \", \")?;\n }\n format_value(*value, fun, out)?;\n }\n Ok(())\n}\n" }, { "path": "libeir_ir/src/traits/mod.rs", "content": "mod op_branches;\npub use op_branches::OpBranches;\n\nmod printer;\npub use printer::{FormatOpCtx, OpPrinter};\n\nmod parser;\npub use parser::OpParser;\n" }, { "path": "libeir_ir/src/traits/op_branches.rs", "content": "use crate::{Block, Function, Value};\nuse meta_table::impl_cast_from;\n\n/// When an operation implements this trait, it has knowledge about some/all of\n/// its outgoing control flow branches.\npub trait OpBranches {\n /// The number of branches this specific instance of the operation has.\n /// This may be dynamic, but needs to be solely decided by the operation\n /// itself.\n fn branches_len(&self) -> usize;\n\n /// Returns the target of `branch_n`.\n /// This may not be called with a `branch_n` >= `branch_len`.\n fn branch_num(&self, fun: &Function, block: Block, branch_n: usize) -> Value;\n}\nimpl_cast_from!(OpBranches);\n" }, { "path": "libeir_ir/src/traits/parser.rs", "content": "use crate::text::ast::DynToken;\nuse crate::text::LowerContext;\nuse crate::Block;\n\npub trait OpParser: Send + Sync {\n fn parse(\n &self,\n context: &mut LowerContext,\n block: Block,\n tokens: &[DynToken],\n ) -> Result<(), ()>;\n}\n" }, { "path": "libeir_ir/src/traits/printer.rs", "content": "use crate::{Block, DynValue};\nuse meta_table::impl_cast_from;\nuse pretty::RefDoc;\n\npub trait FormatOpCtx<'doc> {\n fn arena(&self) -> &'doc pretty::Arena<'doc>;\n fn value_use_to_doc(&mut self, value: DynValue) -> RefDoc<'doc, ()>;\n}\n\npub trait OpPrinter {\n fn to_doc<'doc>(&self, ctx: &mut dyn FormatOpCtx<'doc>, block: Block) -> RefDoc<'doc, ()>;\n}\nimpl_cast_from!(OpPrinter);\n" }, { "path": "libeir_lowerutils/Cargo.toml", "content": "[package]\nname = \"libeir_lowerutils\"\nversion = \"0.1.0\"\nauthors = [\"Hans Elias B. Josephsen \"]\nedition = \"2018\"\nlicense = \"MIT OR Apache-2.0\"\n\n# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html\n\n[dependencies]\nlibeir_ir = { path = \"../libeir_ir\" }\n\ncranelift-entity = \"0.56.0\"\npetgraph = \"0.4\"\n" }, { "path": "libeir_lowerutils/src/lib.rs", "content": "use std::collections::{BTreeMap, BTreeSet};\n\nuse libeir_ir::{Block, Function, Value};\nuse libeir_ir::{CallKind, OpKind};\nuse libeir_ir::{FunctionTree, LiveValues};\n\nuse petgraph::visit::IntoNeighbors;\n\n#[cfg(test)]\nmod tests;\n\n#[derive(Debug, Clone)]\npub struct LowerData {\n /// The live value set is generated as part of the analysis.\n /// It is returned so this calculation doesn't need to happen several\n /// times.\n pub live: LiveValues,\n\n pub func_tree: FunctionTree,\n}\n\nenum Escape {\n Return,\n Throw,\n}\n\npub fn analyze(fun: &Function) -> LowerData {\n let live = fun.live_values();\n let func_tree = fun.func_tree(&live, true);\n\n LowerData { live, func_tree }\n}\n" }, { "path": "libeir_lowerutils/src/tests.rs", "content": "use libeir_ir::parse_function_unwrap;\n\n#[test]\nfn simple_function() {\n let fun = parse_function_unwrap(\n \"\na'foo':a'bar'/1 {\n entry(%ret, %thr, %a):\n if_bool %a one two;\n one():\n %ret(a'true');\n two():\n %ret(a'foo');\n}\n\",\n );\n\n let analyzed = super::analyze(&fun);\n dbg!(analyzed);\n}\n\n#[test]\nfn nested_functions() {\n let fun = parse_function_unwrap(\n \"\na'foo':a'bar'/1 {\n entry(%ret, %thr, %a):\n %ret(inner);\n inner(%iret, %ithr):\n %iret(%a);\n}\n\",\n );\n\n let analyzed = super::analyze(&fun);\n dbg!(analyzed);\n}\n" }, { "path": "libeir_passes/Cargo.toml", "content": "[package]\nname = \"libeir_passes\"\nversion = \"0.1.0\"\nauthors = [\"Hans Elias B. Josephsen \"]\nedition = \"2018\"\nlicense = \"MIT OR Apache-2.0\"\n\n[dependencies]\nmatches = \"0.1.8\"\ncranelift-entity = \"0.56.0\"\ncranelift-bforest = { git = \"https://github.com/hansihe/wasmtime.git\", branch = \"main\" }\n\npetgraph = \"0.4\"\nbumpalo = { git = \"https://github.com/hansihe/bumpalo\", branch = \"master\", features = [\"nightly\"] }\nfnv = \"1.0.3\"\nlog = \"0.4\"\nhashbrown = { git = \"https://github.com/rust-lang/hashbrown.git\", features = [\"raw\", \"nightly\"] }\n\nlibeir_ir = { path = \"../libeir_ir\" }\nlibeir_intern = { path = \"../libeir_intern\" }\nlibeir_util_pattern_compiler = { path = \"../util/libeir_util_pattern_compiler\" }\nlibeir_util_dot_graph = { path = \"../util/libeir_util_dot_graph\" }\nlibeir_diagnostics = { path = \"../libeir_diagnostics\" }\nlibeir_util_datastructures = { path = \"../util/libeir_util_datastructures\" }\n\n\n[dev-dependencies]\nenv_logger = \"0.7\"\n" }, { "path": "libeir_passes/src/compile_pattern/erlang_pattern_provider.rs", "content": "use cranelift_entity::{entity_impl, EntityList, ListPool, PrimaryMap};\nuse libeir_util_pattern_compiler::{ExpandedClauseNodes, PatternProvider};\n\nuse hashbrown::HashMap;\nuse std::collections::BTreeMap;\n\nuse libeir_ir::constant::Const;\nuse libeir_ir::pattern::{\n PatternClause, PatternContainer, PatternNode, PatternNodeKind, PatternValue,\n};\nuse libeir_ir::BinaryEntrySpecifier;\nuse libeir_ir::{Function, PrimOp, Value, ValueKind};\n\nuse super::ValueBind;\n\n#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash, PartialOrd, Ord)]\npub enum ValueOrConst {\n Value(Value),\n Const(Const),\n PrimOp(PrimOp),\n Node(PatternNode),\n}\nimpl ValueOrConst {\n fn from_value(val_bind: ValueBind, fun: &Function) -> Self {\n match val_bind {\n ValueBind::Value(val) => match fun.value_kind(val) {\n ValueKind::Const(cons) => ValueOrConst::Const(cons),\n ValueKind::Argument(_, _) => ValueOrConst::Value(val),\n ValueKind::PrimOp(prim) => ValueOrConst::PrimOp(prim),\n kind => panic!(\"{:?}\", kind),\n },\n ValueBind::Node(node) => ValueOrConst::Node(node),\n }\n }\n}\n\n#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]\npub enum NodeKind {\n /// Matched on equality to value\n Value(ValueOrConst),\n\n /// Binary operations take an optional size value.\n /// When expanded, it expands to the value node, and the tail of the\n /// binary.\n Binary {\n specifier: BinaryEntrySpecifier,\n size: Option,\n has_tail: bool,\n },\n /// Tuple is matched its length\n TupleSize(usize),\n /// A list cell is a singleton\n ListCell,\n /// Matches that the value is a map.\n /// If there are matches on items within the map,\n /// those are expanded to several MapItems.\n Map,\n /// A map is matched by an interned value.\n /// This matches only a single k=>v mapping in a map.\n MapItem(ValueOrConst),\n\n // Meta\n ValueList,\n Wildcard,\n}\n\nimpl NodeKind {\n pub fn num_children(self) -> usize {\n match self {\n NodeKind::Value(_) => 0,\n NodeKind::TupleSize(num) => num,\n NodeKind::ListCell => 2,\n NodeKind::Map => panic!(),\n NodeKind::MapItem(_) => 1,\n NodeKind::ValueList => panic!(),\n NodeKind::Wildcard => 0,\n NodeKind::Binary { has_tail: true, .. } => 2,\n NodeKind::Binary { has_tail: false, .. } => 1,\n }\n }\n}\n\n#[derive(Debug, Clone)]\npub struct NodeData {\n kind: NodeKind,\n children: EntityList,\n}\n\n#[derive(Debug, Clone)]\npub struct ErlangPatternProvider<'a> {\n fun: Option<&'a Function>,\n\n nodes: PrimaryMap,\n vars: PrimaryMap,\n\n /// Root node for each clause\n root_nodes: Vec,\n /// Root variable in the match\n root_var: Var,\n\n wildcard: Node,\n\n node_pool: ListPool,\n\n node_map: BTreeMap,\n}\n\n#[derive(Copy, Clone, Eq, PartialEq, Hash, PartialOrd, Ord)]\npub struct Node(u32);\nentity_impl!(Node, \"node\");\n\n#[derive(Copy, Clone, Eq, PartialEq, Hash, PartialOrd, Ord)]\npub struct Var(u32);\nentity_impl!(Var, \"var\");\n\nimpl<'a> ErlangPatternProvider<'a> {\n pub fn new() -> Self {\n let mut nodes = PrimaryMap::new();\n let wildcard = nodes.push(NodeData {\n kind: NodeKind::Wildcard,\n children: EntityList::new(),\n });\n\n let mut vars = PrimaryMap::new();\n let root_var = vars.push(());\n\n ErlangPatternProvider {\n fun: None,\n\n nodes,\n vars,\n\n root_nodes: Vec::new(),\n root_var,\n\n wildcard,\n\n node_pool: ListPool::new(),\n\n node_map: BTreeMap::new(),\n }\n }\n\n pub fn add_child(&mut self, node: Node, kind: NodeKind, pat_node: PatternNode) -> Node {\n let next = self.nodes.push(NodeData {\n kind,\n children: EntityList::new(),\n });\n self.nodes[node].children.push(next, &mut self.node_pool);\n self.node_map.insert(pat_node, next);\n next\n }\n\n pub fn add_clause(&mut self) -> Node {\n let next = self.nodes.push(NodeData {\n kind: NodeKind::ValueList,\n children: EntityList::new(),\n });\n self.root_nodes.push(next);\n next\n }\n\n fn wildcard(&self) -> Node {\n self.wildcard\n }\n\n pub fn pattern_node_to_cfg_node(&self, pat: PatternNode) -> Node {\n *self.node_map.get(&pat).unwrap()\n }\n}\n\nimpl<'a> PatternProvider for ErlangPatternProvider<'a> {\n type PatternNodeKey = Node;\n type PatternNodeKind = NodeKind;\n type CfgVariable = Var;\n\n const WILDCARD: NodeKind = NodeKind::Wildcard;\n\n fn get_root(&self) -> ExpandedClauseNodes {\n ExpandedClauseNodes {\n variables: vec![self.root_var],\n clauses: self.root_nodes.len(),\n nodes: self.root_nodes.clone(),\n }\n }\n\n fn kind_includes(&self, kind: NodeKind, key: Node) -> bool {\n let node_kind = self.nodes[key].kind;\n if node_kind == kind {\n return true;\n }\n\n //match (kind, node_kind) {\n // (NodeKind::Value(l), NodeKind::Value(r)) =>\n // if l\n // _ => false,\n //}\n false\n }\n\n fn get_kind(&self, key: Node) -> NodeKind {\n self.nodes[key].kind\n }\n\n fn get_wildcard_node(&self) -> Node {\n self.wildcard\n }\n\n fn expand_clause_nodes(\n &mut self,\n clause_nodes: Vec,\n kind: NodeKind,\n ) -> ExpandedClauseNodes {\n if clause_nodes.len() == 0 {\n return ExpandedClauseNodes {\n clauses: 0,\n variables: vec![],\n nodes: vec![],\n };\n }\n\n for node in clause_nodes.iter() {\n let node_kind = self.nodes[*node].kind;\n assert!(node_kind == kind);\n }\n\n //let typ = &self.nodes[clause_nodes[0]];\n //let kind = typ.kind;\n //let base_len = typ.children.len(&self.node_pool);\n //for node in &clause_nodes {\n // assert!(self.nodes[*node].kind == kind);\n //}\n\n match kind {\n NodeKind::ValueList => {\n let len = self.nodes[clause_nodes[0]].children.len(&self.node_pool);\n\n let mut exp = ExpandedClauseNodes {\n clauses: clause_nodes.len(),\n variables: {\n let vars = &mut self.vars;\n (0..len).map(|_| vars.push(())).collect()\n },\n nodes: vec![],\n };\n\n for node_id in clause_nodes {\n let node = &self.nodes[node_id];\n let children = node.children.as_slice(&self.node_pool);\n\n assert!(children.len() == len);\n\n for child in children {\n exp.nodes.push(*child);\n }\n }\n\n exp\n }\n NodeKind::Map => {\n // Map is a special case in expansion.\n // We want to expand each value into a separate column.\n\n let mut values_map = HashMap::new();\n for node in &clause_nodes {\n let sub = &self.nodes[*node];\n for child_id in sub.children.as_slice(&self.node_pool) {\n let child = &self.nodes[*child_id];\n if let NodeKind::MapItem(idx) = child.kind {\n let key = (*node, idx);\n if !values_map.contains_key(&key) {\n values_map.insert(key, Vec::new());\n }\n values_map.get_mut(&key).unwrap().push(*child_id);\n } else {\n unreachable!();\n }\n }\n }\n\n let mut values = BTreeMap::new();\n for ((_node, key_value), val) in values_map.iter() {\n if let Some(max) = values.get_mut(key_value) {\n let n_max = val.len();\n if n_max > *max {\n *max = n_max;\n }\n } else {\n values.insert(*key_value, val.len());\n }\n }\n\n let value_map = self.vars.push(());\n let mut exp = ExpandedClauseNodes {\n clauses: clause_nodes.len(),\n variables: values\n .values()\n .flat_map(|num| 0..*num)\n .map(|_| value_map)\n .collect(),\n nodes: vec![],\n };\n\n for node in clause_nodes.iter() {\n for (value, num) in values.iter() {\n let vals = values_map.get(&(*node, *value));\n for n in 0..*num {\n if let Some(child_id) = vals.and_then(|v| v.get(n)) {\n exp.nodes.push(*child_id);\n } else {\n exp.nodes.push(self.wildcard());\n }\n }\n }\n }\n\n exp\n }\n _ => {\n let expected_children = kind.num_children();\n\n let mut exp = ExpandedClauseNodes {\n clauses: clause_nodes.len(),\n variables: {\n let vars = &mut self.vars;\n (0..expected_children).map(|_| vars.push(())).collect()\n },\n nodes: vec![],\n };\n\n for node_id in clause_nodes {\n let node = &self.nodes[node_id];\n println!(\"{:?}\", node);\n let children = node.children.as_slice(&self.node_pool);\n\n assert_eq!(children.len(), expected_children);\n for child in children {\n exp.nodes.push(*child);\n }\n }\n\n exp\n }\n }\n }\n}\n\nfn pattern_node_to_provider(\n fun: &Function,\n pat: &PatternContainer,\n //node_map: &mut HashMap,\n value_map: &HashMap,\n provider: &mut ErlangPatternProvider,\n node: PatternNode,\n parent: Node,\n n: usize,\n) -> Node {\n // Cheap and safe since we don't modify any patterns\n let kind = pat.node_kind(node).clone();\n\n match &kind {\n PatternNodeKind::Wildcard => provider.add_child(parent, NodeKind::Wildcard, node),\n PatternNodeKind::Tuple(entries) => {\n let tuple = provider.add_child(\n parent,\n NodeKind::TupleSize(entries.len(&pat.node_pool)),\n node,\n );\n for entry_num in 0..(entries.len(&pat.node_pool)) {\n let entry = entries.get(entry_num, &pat.node_pool).unwrap();\n pattern_node_to_provider(fun, pat, value_map, provider, entry, tuple, n + 1);\n }\n tuple\n }\n PatternNodeKind::List { head, tail } => {\n let node = provider.add_child(parent, NodeKind::ListCell, node);\n pattern_node_to_provider(fun, pat, value_map, provider, *head, node, n + 1);\n pattern_node_to_provider(fun, pat, value_map, provider, *tail, node, n + 1);\n node\n }\n PatternNodeKind::Map { keys, values } => {\n let map_parent = provider.add_child(parent, NodeKind::Map, node);\n\n let len = keys.len(&pat.value_pool);\n assert!(values.len(&pat.node_pool) == len);\n\n let mut dedup = HashMap::new();\n for n in 0..len {\n let key = keys.get(n, &pat.value_pool).unwrap();\n let key_val_or_const = ValueOrConst::from_value(value_map[&key], fun);\n\n let val = values.get(n, &pat.node_pool).unwrap();\n\n if !dedup.contains_key(&key_val_or_const) {\n dedup.insert(key_val_or_const, Vec::new());\n }\n dedup.get_mut(&key_val_or_const).unwrap().push(val);\n }\n\n // TODO: Currently we just give up here and put duplicate\n // values in separate columns. We most likely want to take\n // care of merging these in a separate stage within pattern\n // match compilation.\n for (key, values) in dedup.iter() {\n for value in values {\n let entry_parent =\n provider.add_child(map_parent, NodeKind::MapItem(*key), node);\n pattern_node_to_provider(\n fun,\n pat,\n value_map,\n provider,\n *value,\n entry_parent,\n n + 1,\n );\n }\n }\n\n map_parent\n }\n PatternNodeKind::Const(cons) => {\n let val = ValueOrConst::Const(*cons);\n provider.add_child(parent, NodeKind::Value(val), node)\n }\n PatternNodeKind::Value(pat_val) => {\n let val = value_map[&pat_val];\n let val_or_const = ValueOrConst::from_value(val, fun);\n provider.add_child(parent, NodeKind::Value(val_or_const), node)\n }\n PatternNodeKind::Binary {\n specifier,\n value,\n size,\n remaining,\n } => {\n let size_val = size.map(|v| ValueOrConst::from_value(value_map[&v], fun));\n\n let binary_entry = provider.add_child(\n parent,\n NodeKind::Binary {\n specifier: *specifier,\n size: size_val,\n has_tail: remaining.is_some(),\n },\n node,\n );\n\n pattern_node_to_provider(fun, pat, value_map, provider, *value, binary_entry, n + 1);\n if let Some(remaining) = *remaining {\n pattern_node_to_provider(\n fun,\n pat,\n value_map,\n provider,\n remaining,\n binary_entry,\n n + 1,\n );\n }\n\n binary_entry\n }\n }\n}\n\npub(super) fn pattern_to_provider<'a>(\n fun: &Function,\n pat: &PatternContainer,\n clauses: &[PatternClause],\n //node_map: &mut HashMap,\n value_map: &HashMap,\n) -> ErlangPatternProvider<'a> {\n let mut provider = ErlangPatternProvider::new();\n let mut roots = Vec::new();\n for clause in clauses {\n let node = provider.add_clause();\n roots.push(node);\n\n for value_num in 0..pat.clause_root_nodes(*clause).len() {\n let value = pat.clause_root_nodes(*clause)[value_num];\n pattern_node_to_provider(fun, pat, value_map, &mut provider, value, node, 0);\n }\n }\n provider\n}\n" }, { "path": "libeir_passes/src/compile_pattern/lower_cfg.rs", "content": "use bumpalo::Bump;\n\nuse libeir_ir::pattern::{PatternClause, PatternContainer, PatternNode};\nuse libeir_ir::FunctionBuilder;\nuse libeir_ir::{BasicType, Block, Value};\n\nuse libeir_util_pattern_compiler::{CfgNodeKind, EdgeRef, NodeIndex, PatternCfg};\n\nuse libeir_diagnostics::SourceSpan;\n\nuse super::erlang_pattern_provider::{ErlangPatternProvider, NodeKind, ValueOrConst, Var};\nuse super::BFnvHashMap;\n\npub struct DecisionTreeDestinations<'bump> {\n pub fail: Value,\n pub guards: Vec,\n pub bodies: Vec,\n}\n\nstruct LowerCtx<'a, 'b, 'bump> {\n provider: &'a ErlangPatternProvider<'b>,\n destinations: &'a DecisionTreeDestinations<'bump>,\n mapping: BFnvHashMap<'bump, Var, Value>,\n}\n\nimpl<'a, 'b, 'bump> LowerCtx<'a, 'b, 'bump> {\n fn node_to_value(\n &self,\n node: PatternNode,\n idx: NodeIndex,\n cfg: &PatternCfg,\n ) -> Value {\n // PatternNode => PatternCfg Node\n let prov_node = self.provider.pattern_node_to_cfg_node(node);\n // PatternCfg Node => PatternCfg Var\n let prov_var = cfg.leaf_bindings[&idx][&prov_node];\n // PatternCfg Var => Value\n self.mapping[&prov_var]\n }\n\n fn value_or_const_to_value(\n &self,\n bind: ValueOrConst,\n idx: NodeIndex,\n b: &mut FunctionBuilder,\n cfg: &PatternCfg,\n ) -> Value {\n match bind {\n ValueOrConst::Value(val) => val,\n ValueOrConst::Const(cons) => b.value(cons),\n ValueOrConst::PrimOp(prim) => b.value(prim),\n ValueOrConst::Node(node) => self.node_to_value(node, idx, cfg),\n }\n }\n\n fn get_var_value(&self, var: Var) -> Value {\n self.mapping[&var]\n }\n\n fn bind(&mut self, var: Var, val: Value) {\n self.mapping.insert(var, val);\n }\n}\n\npub fn lower_cfg(\n bump: &Bump,\n b: &mut FunctionBuilder,\n pat: &PatternContainer,\n provider: &ErlangPatternProvider,\n cfg: &PatternCfg,\n clauses: &[PatternClause],\n destinations: &DecisionTreeDestinations,\n) -> Block {\n assert!(destinations.guards.len() == destinations.bodies.len());\n\n let entry_kind = &cfg.graph[cfg.entry];\n assert!(*entry_kind == CfgNodeKind::Root);\n\n let mut ctx = LowerCtx {\n provider,\n mapping: BFnvHashMap::with_hasher_in(Default::default(), &bump),\n destinations,\n };\n\n let entry_block = b.block_insert();\n let entry_arg = b.block_arg_insert(entry_block);\n\n let mut block = entry_block;\n\n // First node is a dummy root node\n let value_list_node = {\n let mut edges = cfg.graph.edges(cfg.entry);\n let edge = edges.next().unwrap();\n assert!(edges.next().is_none());\n\n let edge_weight = edge.weight();\n assert!(edge_weight.kind == Some(NodeKind::Wildcard));\n assert!(edge_weight.variable_binds.len() == 1);\n\n ctx.bind(edge_weight.variable_binds[0], entry_arg);\n\n edge.target()\n };\n\n let outgoing: Vec<_> = cfg.graph.edges(value_list_node).collect();\n if outgoing.len() == 2 {\n // This will always be a ValueList and a Wildcard\n let val_list_target = outgoing\n .iter()\n .find(|o| o.weight().kind == Some(NodeKind::ValueList))\n .unwrap();\n assert!(outgoing\n .iter()\n .find(|o| o.weight().kind == Some(NodeKind::Wildcard))\n .is_some());\n\n if let CfgNodeKind::Match(var) = cfg.graph[value_list_node] {\n let var_list_len = val_list_target.weight().variable_binds.len();\n block = b.op_unpack_value_list(block, ctx.get_var_value(var), var_list_len);\n } else {\n unreachable!()\n }\n\n // Insert variable binds for all value list elements\n for (idx, var) in val_list_target.weight().variable_binds.iter().enumerate() {\n let val = b.fun().block_args(block)[idx];\n ctx.bind(*var, val);\n }\n\n lower_cfg_rec(\n bump,\n b,\n pat,\n &mut ctx,\n cfg,\n clauses,\n block,\n val_list_target.target(),\n );\n } else if outgoing.len() == 0 {\n // Fail immediately\n b.op_call_flow(block, destinations.fail, &[]);\n } else {\n unreachable!();\n }\n\n entry_block\n}\n\nfn lower_cfg_rec(\n bump: &Bump,\n b: &mut FunctionBuilder,\n pat: &PatternContainer,\n ctx: &mut LowerCtx,\n cfg: &PatternCfg,\n clauses: &[PatternClause],\n block: Block,\n node: NodeIndex,\n) {\n let block_value = b.fun().block_value(block);\n let block_span = b\n .fun()\n .value_locations(block_value)\n .map(|spans| spans.first().copied().unwrap_or(SourceSpan::UNKNOWN))\n .unwrap_or(SourceSpan::UNKNOWN);\n match cfg.graph[node] {\n CfgNodeKind::Root => unreachable!(),\n CfgNodeKind::Match(var) => {\n let match_val = ctx.get_var_value(var);\n let span = b\n .fun()\n .value_locations(match_val)\n .map(|spans| spans.first().copied().unwrap_or(SourceSpan::UNKNOWN))\n .unwrap_or(SourceSpan::UNKNOWN);\n\n let mut wildcard_node = None;\n\n let mut match_builder = b.op_match_build(span);\n\n for outgoing in cfg.graph.edges(node) {\n let weight = outgoing.weight();\n let kind = weight.kind.unwrap();\n\n match kind {\n NodeKind::Wildcard => {\n assert!(wildcard_node.is_none());\n wildcard_node = Some(outgoing);\n }\n NodeKind::Binary { specifier, size, has_tail } => {\n if has_tail {\n assert!(weight.variable_binds.len() == 2);\n } else {\n assert!(weight.variable_binds.len() == 1);\n }\n\n let size =\n size.map(|v| ctx.value_or_const_to_value(v, outgoing.target(), b, cfg));\n let mut ok = match_builder.push_binary(specifier, size, b);\n\n let args = b.block_args(ok);\n assert!(args.len() == 2);\n let arg0 = args[0];\n let arg1 = args[1];\n\n ctx.bind(weight.variable_binds[0], arg0);\n if has_tail {\n ctx.bind(weight.variable_binds[1], arg1);\n } else {\n let mut inner_builder = b.op_match_build(span);\n let empty_binary = b.value(Vec::::new());\n let next = inner_builder.push_value(empty_binary, b);\n inner_builder.finish(ok, arg1, b);\n ok = next;\n }\n\n lower_cfg_rec(bump, b, pat, ctx, cfg, clauses, ok, outgoing.target());\n }\n NodeKind::TupleSize(size) => {\n assert!(size == weight.variable_binds.len());\n\n let ok = match_builder.push_tuple(size, b);\n\n {\n let args = b.block_args(ok);\n assert!(args.len() == size);\n\n for (var, val) in weight.variable_binds.iter().zip(args.iter()) {\n ctx.bind(*var, *val);\n }\n }\n\n // Ok\n lower_cfg_rec(bump, b, pat, ctx, cfg, clauses, ok, outgoing.target());\n }\n NodeKind::ListCell => {\n assert!(weight.variable_binds.len() == 2);\n\n let ok = match_builder.push_list_cell(b);\n\n {\n let args = b.block_args(ok);\n assert!(args.len() == 2);\n\n ctx.bind(weight.variable_binds[0], args[0]);\n ctx.bind(weight.variable_binds[1], args[1]);\n }\n\n // Ok\n lower_cfg_rec(bump, b, pat, ctx, cfg, clauses, ok, outgoing.target());\n }\n NodeKind::Map => {\n let ok = match_builder.push_type(BasicType::Map, b);\n\n for bind in weight.variable_binds.iter() {\n ctx.bind(*bind, match_val);\n }\n\n lower_cfg_rec(bump, b, pat, ctx, cfg, clauses, ok, outgoing.target());\n }\n NodeKind::MapItem(val_or_const) => {\n assert!(weight.variable_binds.len() == 1);\n\n let val = ctx.value_or_const_to_value(val_or_const, node, b, cfg);\n\n let ok = match_builder.push_map_item(val, b);\n let ok_arg = b.block_args(ok)[0];\n ctx.bind(weight.variable_binds[0], ok_arg);\n\n lower_cfg_rec(bump, b, pat, ctx, cfg, clauses, ok, outgoing.target());\n }\n NodeKind::Value(val_or_const) => {\n let val = ctx.value_or_const_to_value(val_or_const, node, b, cfg);\n let ok = match_builder.push_value(val, b);\n lower_cfg_rec(bump, b, pat, ctx, cfg, clauses, ok, outgoing.target());\n }\n _ => unimplemented!(\"{:?}\", kind),\n }\n }\n\n let wildcard_edge = wildcard_node.unwrap();\n assert!(wildcard_edge.weight().variable_binds.len() == 0);\n let wildcard_block = match_builder.push_wildcard(span, b);\n lower_cfg_rec(\n bump,\n b,\n pat,\n ctx,\n cfg,\n clauses,\n wildcard_block,\n wildcard_edge.target(),\n );\n\n match_builder.finish(block, match_val, b);\n }\n CfgNodeKind::Fail => {\n b.op_call_flow(block, ctx.destinations.fail, &[]);\n }\n CfgNodeKind::Leaf(leaf_num) => {\n let clause = clauses[leaf_num];\n\n let mut args = vec![];\n let num_binds = pat.clause_binds(clause).len();\n for bind_num in 0..num_binds {\n let bind_node = pat.clause_binds(clause)[bind_num];\n let val = ctx.node_to_value(bind_node, node, cfg);\n args.push(val);\n }\n\n // Call to guard lambda\n let (ok_block, thr_block) =\n b.op_call_function(block_span, block, ctx.destinations.guards[leaf_num], &args);\n let ok_ret = b.block_args(ok_block)[0];\n\n // Throw is unreachable\n b.op_unreachable(block_span, thr_block);\n\n // Conditional on return\n let (true_block, false_block, non_block) = b.op_if_bool(block_span, ok_block, ok_ret);\n b.op_unreachable(block_span, non_block);\n\n // If guard succeeds, we enter the body\n b.op_call_flow(true_block, ctx.destinations.bodies[leaf_num], &args);\n\n // If guard fails, continue in CFG\n {\n let mut edges = cfg.graph.edges(node);\n let edge = edges.next().unwrap();\n assert!(edges.next().is_none());\n\n lower_cfg_rec(bump, b, pat, ctx, cfg, clauses, false_block, edge.target());\n }\n }\n }\n}\n" }, { "path": "libeir_passes/src/compile_pattern/mod.rs", "content": "use bumpalo::Bump;\nuse hashbrown::HashMap;\n\nuse fnv::FnvBuildHasher;\ntype BFnvHashMap<'bump, K, V> = HashMap;\n\nuse libeir_ir::operation::case::Case;\nuse libeir_ir::FunctionBuilder;\nuse libeir_ir::PatternNode;\nuse libeir_ir::Value;\n\nuse libeir_util_pattern_compiler::to_decision_tree;\n\nmod erlang_pattern_provider;\nuse self::erlang_pattern_provider::pattern_to_provider;\n\nmod lower_cfg;\nuse self::lower_cfg::lower_cfg;\nuse self::lower_cfg::DecisionTreeDestinations;\n\nuse super::FunctionPass;\n\n#[cfg(test)]\nmod tests;\n\npub struct CompilePatternPass {\n bump: Option,\n}\n\nimpl CompilePatternPass {\n pub fn new() -> Self {\n CompilePatternPass {\n bump: Some(Bump::new()),\n }\n }\n}\n\nimpl FunctionPass for CompilePatternPass {\n fn name(&self) -> &str {\n \"compile_pattern\"\n }\n fn run_function_pass(&mut self, b: &mut FunctionBuilder) {\n self.compile_pattern(b);\n }\n}\n\nimpl CompilePatternPass {\n pub fn compile_pattern(&mut self, b: &mut FunctionBuilder) {\n let mut bump = self.bump.take().unwrap();\n\n {\n // Find all pattern matching constructs\n let case_blocks = {\n let fun = b.fun();\n\n let mut case_blocks = Vec::new_in(&bump);\n\n let graph = fun.block_graph();\n for block in graph.dfs_iter() {\n if fun.block_kind(block).unwrap().get_dyn::().is_some() {\n case_blocks.push(block);\n }\n }\n\n case_blocks\n };\n\n for block in case_blocks.iter().cloned() {\n let no_match;\n let mut guards = Vec::new_in(&bump);\n let mut bodies = Vec::new_in(&bump);\n let match_val;\n let mut values = Vec::new_in(&bump);\n //let mut clauses = Vec::new_in(&bump);\n\n let case = b\n .fun()\n .block_kind(block)\n .unwrap()\n .get_dyn::()\n .unwrap();\n let num_clauses = case.clauses().len();\n\n // Extract arguments from block reads\n {\n let reads = b.fun().block_reads(block);\n let mut r_iter = reads.iter();\n\n // First entry is always no_match\n no_match = *r_iter.next().unwrap();\n\n // Guards and bodies\n for _ in 0..num_clauses {\n guards.push(*r_iter.next().unwrap());\n bodies.push(*r_iter.next().unwrap());\n }\n\n // Match value\n match_val = *r_iter.next().unwrap();\n\n // Values\n while let Some(val) = r_iter.next() {\n values.push(*val);\n }\n }\n\n let op = b.block_clear_take(block).unwrap();\n let case = op.get_dyn::().unwrap();\n\n let destinations = DecisionTreeDestinations {\n fail: no_match,\n guards,\n bodies,\n };\n\n // Get/validate number of roots\n let mut roots_num = None;\n for clause in case.clauses().iter() {\n let num = case.pat().clause_root_nodes(*clause).len();\n if let Some(num_old) = roots_num {\n assert!(num == num_old);\n } else {\n roots_num = Some(num);\n }\n }\n\n let mut value_map = HashMap::new();\n {\n // Create map of PatternValue => Value\n let mut value_idx = 0;\n for clause in case.clauses().iter() {\n for value in case.pat().clause_values(*clause) {\n value_map.insert(*value, ValueBind::Value(values[value_idx]));\n value_idx += 1;\n }\n }\n assert!(values.len() == value_idx);\n\n // Create map of PatternValue => PatternNode\n value_map.extend(\n case.clauses()\n .iter()\n .flat_map(|clause| case.pat().clause_node_binds_iter(*clause))\n .map(|(k, v)| (k, ValueBind::Node(v))),\n );\n }\n\n let mut provider =\n pattern_to_provider(b.fun(), case.pat(), case.clauses(), &value_map);\n let decision_tree = to_decision_tree(&mut provider);\n\n let mut out = Vec::new();\n decision_tree.to_dot(&mut out).unwrap();\n\n let cfg_entry = lower_cfg(\n &bump,\n b,\n case.pat(),\n &provider,\n &decision_tree,\n case.clauses(),\n &destinations,\n );\n\n b.block_clear(block);\n b.op_call_flow(block, cfg_entry, &[match_val]);\n }\n }\n\n bump.reset();\n self.bump = Some(bump);\n }\n}\n\n#[derive(Debug, Copy, Clone)]\npub(super) enum ValueBind {\n Value(Value),\n Node(PatternNode),\n}\n" }, { "path": "libeir_passes/src/compile_pattern/tests.rs", "content": "\n" }, { "path": "libeir_passes/src/dummy_location.rs", "content": "\n" }, { "path": "libeir_passes/src/lib.rs", "content": "#![deny(warnings)]\n#![feature(allocator_api)]\n\nuse log::{info, trace};\n\nuse libeir_ir::{FunctionBuilder, Module};\n\npub mod util;\n\nmod compile_pattern;\npub use self::compile_pattern::CompilePatternPass;\n\nmod naive_inline_closures;\npub use self::naive_inline_closures::NaiveInlineClosuresPass;\n\nmod simplify_cfg;\npub use self::simplify_cfg::SimplifyCfgPass;\n\nmod validate;\npub use self::validate::ValidatePass;\n\npub trait FunctionPass {\n fn name(&self) -> &str;\n fn run_function_pass(&mut self, b: &mut FunctionBuilder);\n}\n\nenum PassType {\n Function(Box),\n}\n\npub struct PassManager {\n passes: Vec,\n}\n\nimpl PassManager {\n pub fn new() -> Self {\n PassManager { passes: Vec::new() }\n }\n\n pub fn push_function_pass

(&mut self, pass: P)\n where\n P: FunctionPass + 'static,\n {\n self.passes.push(PassType::Function(Box::new(pass)));\n }\n\n pub fn run(&mut self, module: &mut Module) {\n for fun_def in module.function_iter_mut() {\n let fun = fun_def.function_mut();\n let ident = *fun.ident();\n\n let mut b = FunctionBuilder::new(fun);\n b.fun().graph_validate_global();\n trace!(\"{}\", b.fun().to_text_standard());\n for pass in self.passes.iter_mut() {\n match pass {\n PassType::Function(fun_pass) => {\n info!(\"======== {} FUNCTION_PASS: {}\", ident, fun_pass.name());\n fun_pass.run_function_pass(&mut b);\n trace!(\"{}\", b.fun().to_text_standard());\n }\n }\n b.fun().graph_validate_global();\n }\n }\n }\n}\n\nimpl Default for PassManager {\n fn default() -> Self {\n let mut man = PassManager::new();\n //man.push_function_pass(SimplifyCfgPass::new());\n man.push_function_pass(ValidatePass::new());\n man.push_function_pass(CompilePatternPass::new());\n man.push_function_pass(ValidatePass::new());\n man.push_function_pass(NaiveInlineClosuresPass::new());\n man.push_function_pass(ValidatePass::new());\n man.push_function_pass(SimplifyCfgPass::new());\n man.push_function_pass(ValidatePass::new());\n man.push_function_pass(NaiveInlineClosuresPass::new());\n man.push_function_pass(ValidatePass::new());\n man\n }\n}\n" }, { "path": "libeir_passes/src/naive_inline_closures/mod.rs", "content": "use std::collections::BTreeSet;\n\nuse libeir_ir::FunctionBuilder;\nuse libeir_ir::{Block, OpKind};\nuse libeir_ir::{MangleTo, Mangler};\n\nuse super::FunctionPass;\n\n#[cfg(test)]\nmod tests;\n\n/// Very basic closure inlining pass.\npub struct NaiveInlineClosuresPass {\n calls_buf: Vec<(Block, Block)>,\n mangler: Mangler,\n}\n\nimpl NaiveInlineClosuresPass {\n pub fn new() -> Self {\n NaiveInlineClosuresPass {\n calls_buf: Vec::new(),\n mangler: Mangler::new(),\n }\n }\n}\n\nimpl FunctionPass for NaiveInlineClosuresPass {\n fn name(&self) -> &str {\n \"naive_inline_closures\"\n }\n fn run_function_pass(&mut self, b: &mut FunctionBuilder) {\n self.inline_closures(b);\n }\n}\n\nimpl NaiveInlineClosuresPass {\n pub fn inline_closures(&mut self, b: &mut FunctionBuilder) {\n self.calls_buf.clear();\n\n let live_block_graph = b.fun().live_block_graph();\n\n let sccs = petgraph::algo::kosaraju_scc(&live_block_graph);\n\n let mut in_big_scc = BTreeSet::new();\n for scc in sccs.iter() {\n if scc.len() > 1 {\n for node in scc.iter() {\n in_big_scc.insert(*node);\n }\n }\n }\n\n for block in b.fun().block_graph().dfs_post_order_iter() {\n // We perform inlining if the block satisfies the following\n // conditions:\n // 1. The block is a call operation\n // 2. The target of the call operation is another block\n // 3. There is at least one block argument to the block\n // 4. The target block does not form a cycle to itself in the block graph\n\n // OP must be Call\n if let OpKind::Call(_) = b.fun().block_kind(block).unwrap() {\n let reads = b.fun().block_reads(block);\n\n // Call target must be block\n let target = match b.fun().value_block(reads[0]) {\n Some(t) => t,\n None => continue,\n };\n\n // Arguments must contain block\n\n let contains_block = reads[1..].iter().any(|a| b.fun().value_block(*a).is_some());\n if !contains_block {\n continue;\n }\n\n // Check if the target block is in a SCC with other nodes than\n // just itself. If this is the case, then it might call itself,\n // and we can't do inlining naively.\n // TODO: This might have false positives?\n if in_big_scc.contains(&target) {\n continue;\n }\n\n self.calls_buf.push((block, target));\n }\n }\n\n for (block, target) in self.calls_buf.iter().cloned() {\n // Signature of new entry block has no arguments\n let new_target = b.block_insert();\n b.block_copy_body_map(target, new_target, |v| Some(v));\n\n self.mangler.start(MangleTo(new_target));\n\n // Add renames to current call arguments\n {\n let source_args = &b.fun().block_reads(block)[1..];\n let target_args = b.fun().block_args(target);\n assert!(source_args.len() == target_args.len());\n\n for (from, to) in target_args.iter().zip(source_args.iter()) {\n self.mangler\n .add_rename_nofollow(MangleTo(*from), MangleTo(*to));\n }\n }\n\n // Run mangling on the scope\n let new_block = self.mangler.run(b);\n\n // Clear the current block and insert a call to the new block\n b.block_clear(block);\n b.op_call_flow(block, new_block, &[]);\n }\n }\n}\n" }, { "path": "libeir_passes/src/naive_inline_closures/tests.rs", "content": "use libeir_ir::{parse_function_unwrap, StandardFormatConfig};\n\nuse crate::FunctionPass;\n\n#[test]\nfn inline_basic_function() {\n let mut fun = parse_function_unwrap(\n \"\na'foo':a'fun_shadowing'/1 {\n entry(%ret, %thr, %A):\n b1();\n b1():\n inner(ret, thr, %A);\n inner(%iret, %ithr, %B):\n %iret(%B);\n\n ret(%rv):\n %ret(%rv);\n thr(%rt1, %rt2, %rt3):\n %thr(%rt1, %rt2, %rt3);\n\n}\n\",\n );\n let mut b = fun.builder();\n\n let mut pass = super::NaiveInlineClosuresPass::new();\n pass.run_function_pass(&mut b);\n\n let after = parse_function_unwrap(\n \"\na'foo':a'fun_shadowing'/1 {\n entry(%ret, %thr, %A):\n b1();\n b1():\n b2();\n b2():\n ret(%A);\n ret(%rv):\n %ret(%rv);\n}\n\",\n );\n\n assert!(b\n .fun()\n .graph_eq(b.fun().block_entry(), &after, after.block_entry())\n .is_ok());\n}\n\n#[test]\nfn inline_nested_functions() {\n let mut fun = parse_function_unwrap(\n \"\na'foo':a'fun_shadowing'/1 {\n entry(%ret, %thr, %A):\n b1();\n b1():\n ainner(ret, thr, %A);\n\n ainner(%iret, %ithr, %B):\n anext();\n anext():\n binner(aret, athr, %B);\n aret(%aretv):\n %iret(%aretv);\n athr(%athr1, %athr2, %athr3):\n %ithr(%athr1, %athr2, %athr3);\n\n binner(%bret, %bthr, %C):\n bnext();\n bnext():\n %bret(%C);\n\n ret(%rv):\n %ret(%rv);\n thr(%rt1, %rt2, %rt3):\n %thr(%rt1, %rt2, %rt3);\n\n}\n\",\n );\n let mut b = fun.builder();\n\n let mut pass = super::NaiveInlineClosuresPass::new();\n pass.run_function_pass(&mut b);\n\n println!(\"{}\", b.fun().to_text(&mut StandardFormatConfig::default()));\n\n let after = parse_function_unwrap(\n \"\na'foo':a'fun_shadowing'/1 {\n entry(%ret, %thr, %A):\n b1();\n b1():\n b2();\n b2():\n b3();\n b3():\n b4();\n b4():\n b5();\n b5():\n ret1(%A);\n ret1(%B):\n ret(%B);\n ret(%rv):\n %ret(%rv);\n}\n\",\n );\n\n assert!(b\n .fun()\n .graph_eq(b.fun().block_entry(), &after, after.block_entry())\n .is_ok());\n}\n" }, { "path": "libeir_passes/src/simplify_cfg/analyze/call.rs", "content": "use libeir_ir::Block;\n\nuse super::AnalysisContext;\n\npub(super) fn propagate(ctx: &mut AnalysisContext, block: Block) -> bool {\n let reads = ctx.fun.block_reads(block);\n\n let target = ctx.follow(reads[0]);\n ctx.set_branch(target);\n\n if let Some(target_block) = ctx.fun.value_block(target) {\n for ((idx, read), _arg) in reads\n .iter()\n .skip(1)\n .enumerate()\n .zip(ctx.fun.block_args(target_block))\n {\n ctx.add_rename(target_block, *read, idx);\n }\n\n true\n } else {\n false\n }\n}\n" }, { "path": "libeir_passes/src/simplify_cfg/analyze/if_bool.rs", "content": "use libeir_ir::Block;\n\nuse super::AnalysisContext;\n\npub(super) fn propagate(ctx: &mut AnalysisContext, block: Block) -> bool {\n let reads = ctx.fun.block_reads(block);\n\n let val = match reads.len() {\n 3 => reads[2],\n 4 => reads[3],\n _ => panic!(),\n };\n let val = ctx.follow(val);\n\n if let Some(cons) = ctx.fun.value_const(val) {\n let branch = match ctx.fun.cons().as_bool(cons) {\n Some(true) => 0,\n Some(false) => 1,\n None => {\n if reads.len() == 3 {\n panic!(\"IfBool without fallback branch on non-bool value\")\n } else {\n 2\n }\n }\n };\n let target = reads[branch];\n ctx.set_branch(target);\n\n true\n } else {\n false\n }\n}\n" }, { "path": "libeir_passes/src/simplify_cfg/analyze/mod.rs", "content": "use std::collections::{BTreeMap, BTreeSet, VecDeque};\n\nuse bumpalo::Bump;\n\nuse libeir_util_datastructures::pooled_entity_set::{EntitySet, EntitySetPool};\n\nuse super::BFnvHashMap;\n\nuse libeir_ir::{Block, CallKind, OpKind, Value, ValueKind};\nuse libeir_ir::{Function, LiveBlockGraph, LiveValues};\n\nuse log::trace;\n\nuse super::chain_graph::{Chain, Node};\n\nmod call;\nmod if_bool;\nmod unpack_value_list;\n\ntype BlockEdge = (Block, Block);\n\n#[derive(Debug)]\npub struct GraphAnalysis<'bump> {\n pub entry: Block,\n\n pub static_branches: BFnvHashMap<'bump, Block, Value>,\n pub static_branches_blocks: BFnvHashMap<'bump, Block, Block>,\n\n pub trees: BFnvHashMap<'bump, Block, TreeData<'bump>>,\n\n pub phis: BFnvHashMap<'bump, Value, CondValue<'bump>>,\n pub static_renames: BFnvHashMap<'bump, Value, Value>,\n}\n\n#[derive(Debug)]\npub struct TreeData<'bump> {\n pub entry_edges: BFnvHashMap<'bump, Block, ()>,\n pub edges: BFnvHashMap<'bump, BlockEdge, ()>,\n pub blocks: BFnvHashMap<'bump, Block, ()>,\n pub entry_values: BFnvHashMap<'bump, Value, (Block, usize)>,\n}\n\nimpl<'bump> GraphAnalysis<'bump> {\n fn is_before(&self, lhs: Block, rhs: Block) -> bool {\n let mut curr = lhs;\n\n loop {\n if let Some(prev) = self.static_branches_blocks.get(&curr) {\n curr = *prev;\n } else {\n return false;\n }\n\n if curr == rhs {\n return true;\n }\n }\n }\n\n fn is_value_relevant(&self, tree_target: Block, value: Value) -> bool {\n if let Some(cond) = self.phis.get(&value) {\n let tree = &self.trees[&tree_target];\n\n // Check if it's instead relevant to another tree\n if !tree.blocks.contains_key(&cond.block) && cond.block != tree_target {\n false\n } else {\n true\n }\n } else {\n false\n }\n }\n}\n\n#[derive(Debug)]\npub struct ChainAnalysis<'bump> {\n pub target: Block,\n\n pub blocks: BFnvHashMap<'bump, Block, ()>,\n pub edges: BFnvHashMap<'bump, BlockEdge, ()>,\n pub entry_edges: BFnvHashMap<'bump, Block, ()>,\n\n //pub orig_args: BTreeSet,\n pub args: BFnvHashMap<'bump, Value, ()>,\n\n pub cond_map: BFnvHashMap<'bump, Value, CondValue<'bump>>,\n pub static_map: BFnvHashMap<'bump, Value, Value>,\n\n pub renames_required: bool,\n}\n\n#[derive(Debug)]\npub struct CondValue<'bump> {\n pub value: Value,\n pub value_index: usize,\n pub block: Block,\n pub sources: BFnvHashMap<'bump, Block, PhiSource>,\n}\n\n#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]\npub struct PhiSource {\n /// The value on the other side of the phi.\n /// If this is None, then this is an anonymous entry edge.\n value: Option,\n /// The block calling the phi.\n /// If this is None, then this is an anonymous entry edge.\n caller: Option,\n /// The block that is called as the entry edge.\n /// This MUST be part of the chain.\n called: Block,\n /// The index of the argment on the called block.\n arg_index: usize,\n /// The argument value itself.\n arg: Value,\n}\n\n#[derive(Debug)]\npub struct EntryEdgeAnalysis<'bump> {\n //pub caller: Block,\n pub callee: Block,\n\n // The mappings that are specific for this entry edge.\n // Should not be inserted into the global map, the args should be\n // `map_value`d through this map.\n pub mappings: BFnvHashMap<'bump, Value, PhiSource>,\n\n // The arguments that should be used when calling the target block.\n // These need to be called with `map_value` in case the value is a primop.\n pub args: Vec,\n //pub looping_vars: BTreeSet,\n}\n\nstruct AnalysisContext<'bump, 'a> {\n bump: &'bump Bump,\n\n pub fun: &'a Function,\n pub graph: &'a LiveBlockGraph<'a>,\n\n current: Option,\n\n static_renames: &'a mut BFnvHashMap<'bump, Value, Value>,\n static_branches: &'a mut BFnvHashMap<'bump, Block, Value>,\n phis: &'a mut BFnvHashMap<'bump, Value, CondValue<'bump>>,\n}\nimpl<'bump, 'a> AnalysisContext<'bump, 'a> {\n fn init_block(&mut self, block: Block) {\n self.current = Some(block);\n }\n\n /// Follows the provided value according to the current static mappings\n pub fn follow(&self, mut val: Value) -> Value {\n while let Some(next) = self.static_renames.get(&val) {\n val = *next;\n }\n val\n }\n\n /// The current block statically branches to the target value\n pub fn set_branch(&mut self, target: Value) {\n self.static_branches.insert(self.current.unwrap(), target);\n }\n\n pub fn add_rename(&mut self, callee: Block, caller_read: Value, callee_arg_num: usize) {\n let caller = self.current.unwrap();\n let callee_arg = self.fun.block_args(callee)[callee_arg_num];\n\n #[cfg(debug)]\n {\n if let Some(p) = self.static_branches.get(caller) {\n assert!(self.fun.value_block(*p) == Some(callee));\n } else {\n panic!();\n }\n }\n\n let incoming_count = self.graph.incoming(callee).count();\n let incoming = self.graph.incoming(callee).next();\n assert!(incoming_count > 0);\n if incoming_count == 1 && incoming.unwrap() == caller {\n self.static_renames.insert(callee_arg, caller_read);\n }\n\n if !self.phis.contains_key(&callee_arg) {\n let cond = CondValue {\n block: callee,\n value: callee_arg,\n value_index: callee_arg_num,\n sources: BFnvHashMap::with_hasher_in(Default::default(), self.bump),\n };\n self.phis.insert(callee_arg, cond);\n }\n\n let phi_source = PhiSource {\n value: Some(caller_read),\n caller: Some(caller),\n called: callee,\n arg_index: callee_arg_num,\n arg: callee_arg,\n };\n self.phis\n .get_mut(&callee_arg)\n .unwrap()\n .sources\n .insert(caller, phi_source);\n }\n}\n\npub fn analyze_graph<'bump, 'fun>(\n bump: &'bump Bump,\n fun: &'fun Function,\n graph: &'fun LiveBlockGraph,\n) -> GraphAnalysis<'bump> {\n let entry = fun.block_entry();\n\n let mut static_branches = BFnvHashMap::with_hasher_in(Default::default(), bump);\n let mut phis = BFnvHashMap::with_hasher_in(Default::default(), bump);\n let mut static_renames = BFnvHashMap::with_hasher_in(Default::default(), bump);\n\n // Find all blocks we care about, these are the ones we iterate over\n let mut relevant_blocks = BTreeSet::new();\n for block in graph.dfs_iter() {\n match fun.block_kind(block).unwrap() {\n OpKind::Call(CallKind::ControlFlow) => {\n relevant_blocks.insert(block);\n }\n OpKind::IfBool => {\n relevant_blocks.insert(block);\n }\n OpKind::UnpackValueList(_) => {\n relevant_blocks.insert(block);\n }\n _ => (),\n }\n }\n\n let mut ctx = AnalysisContext {\n bump,\n\n fun,\n graph,\n\n current: None,\n\n static_renames: &mut static_renames,\n static_branches: &mut static_branches,\n phis: &mut phis,\n };\n\n // Propagate value renames until we reach an equilibrium.\n // This will perform branch elimination and constant propagation\n // in one single step.\n let mut handled_blocks = BTreeSet::new();\n loop {\n let mut changed = false;\n\n for block in relevant_blocks.iter() {\n // If the block is already statically resolved, we can skip it.\n if handled_blocks.contains(block) {\n continue;\n }\n\n ctx.init_block(*block);\n\n let res = match fun.block_kind(*block).unwrap() {\n OpKind::Call(CallKind::ControlFlow) => self::call::propagate(&mut ctx, *block),\n OpKind::IfBool => self::if_bool::propagate(&mut ctx, *block),\n OpKind::UnpackValueList(n) => {\n self::unpack_value_list::propagate(&mut ctx, *block, *n)\n }\n _ => unreachable!(),\n };\n\n // If the propagation implementation indicated that it has been\n // resolved, then we have a change in this iteration.\n if res {\n changed = true;\n handled_blocks.insert(*block);\n }\n }\n\n // If this iteration contains no changes, then we are done.\n if !changed {\n break;\n }\n }\n\n trace!(\"======== Results after initial traversal:\");\n trace!(\"Phis: {:?}\", ctx.phis);\n trace!(\"Static renames: {:?}\", ctx.static_renames);\n trace!(\"========\");\n\n // Populate incoming edges in phis\n for phi in ctx.phis.values_mut() {\n for incoming in graph.incoming(phi.block) {\n if !phi.sources.contains_key(&incoming) {\n phi.sources.insert(\n incoming,\n PhiSource {\n // Not relevant since the edge is not part of the tree\n value: None,\n caller: None,\n\n called: phi.block,\n arg_index: phi.value_index,\n arg: phi.value,\n },\n );\n }\n }\n }\n\n // Generate `static_branches_blocks`\n let mut static_branches_blocks = BFnvHashMap::with_hasher_in(Default::default(), bump);\n for (from, to) in static_branches.iter() {\n if let Some(to_block) = fun.value_block(*to) {\n static_branches_blocks.insert(*from, to_block);\n }\n }\n\n // Group chains\n // TODO: Handle cycles\n let mut trees = BFnvHashMap::with_hasher_in(Default::default(), bump);\n for (from, to) in static_branches.iter() {\n let mut next_target_value = *to;\n let mut target_block = *from;\n\n let mut to_has_block = None;\n\n // Walk chain of branches until target is reached\n loop {\n // If the next value is a block\n if let Some(to_block) = fun.value_block(next_target_value) {\n // .. the target is that block\n target_block = to_block;\n\n if to_has_block.is_none() {\n to_has_block = Some(to_block);\n }\n\n // If that block has an outgoing branch,\n // walk that next and continue\n if let Some(next) = static_branches.get(&to_block) {\n next_target_value = *next;\n continue;\n }\n }\n\n // If the chains map doesn't contain the target, seed it\n if !trees.contains_key(&target_block) {\n let mut tree = TreeData {\n edges: BFnvHashMap::with_hasher_in(Default::default(), bump),\n blocks: BFnvHashMap::with_hasher_in(Default::default(), bump),\n entry_edges: BFnvHashMap::with_hasher_in(Default::default(), bump),\n entry_values: BFnvHashMap::with_hasher_in(Default::default(), bump),\n };\n tree.blocks.insert(target_block, ());\n trees.insert(target_block, tree);\n }\n\n // Update the current chain with this edge\n let tree = trees.get_mut(&target_block).unwrap();\n tree.blocks.insert(*from, ());\n if let Some(to_block) = to_has_block {\n tree.edges.insert((*from, to_block), ());\n }\n\n break;\n }\n }\n\n // Find incoming edges into the chain\n for tree in trees.values_mut() {\n for block in tree.blocks.keys() {\n if *block == entry {\n tree.entry_edges.insert(*block, ());\n for (arg_idx, arg) in fun.block_args(*block).iter().enumerate() {\n tree.entry_values.insert(*arg, (*block, arg_idx));\n }\n }\n for incoming in graph.incoming(*block) {\n let edge = (incoming, *block);\n if tree.edges.contains_key(&edge) {\n continue;\n }\n\n tree.entry_edges.insert(*block, ());\n for (arg_idx, arg) in fun.block_args(*block).iter().enumerate() {\n tree.entry_values.insert(*arg, (*block, arg_idx));\n }\n }\n }\n }\n\n let analysis = GraphAnalysis {\n entry,\n static_branches,\n static_branches_blocks,\n phis,\n static_renames,\n trees,\n };\n\n trace!(\"GRAPH ANALYSIS: {:?}\", analysis);\n\n analysis\n}\n\npub struct ChainMapping {\n entry_to_chain: BTreeMap,\n block_to_entries: BTreeMap>,\n}\nimpl ChainMapping {\n pub fn iter_entries_for<'a>(&'a self, block: Block) -> impl Iterator + 'a {\n self.block_to_entries[&block].iter().cloned()\n }\n pub fn entry_to_chain(&self, entry: Block) -> Chain {\n self.entry_to_chain[&entry]\n }\n}\n\npub fn build_node<'bump>(\n bump: &'bump Bump,\n fun: &Function,\n //graph: &LiveBlockGraph,\n live: &LiveValues,\n analysis: &'bump GraphAnalysis,\n target: Block,\n block_graph: &ChainMapping,\n last_loc: Block,\n value: Value,\n chain_graph: &mut super::chain_graph::ChainGraph,\n existing_nodes: &mut BTreeMap,\n) -> (bool, Node) {\n trace!(\"{:?} {:?}\", value, fun.value_kind(value));\n\n let tree = &analysis.trees[&target];\n\n match fun.value_kind(value) {\n ValueKind::Argument(block, arg_index) => {\n trace!(\"ARGUMENT {} {}\", block, arg_index);\n\n trace!(\"A1\");\n\n // If it's not an argument of a block in the chain, we simply refer\n // to the scope.\n if !tree.blocks.contains_key(&block) {\n return (false, chain_graph.insert_scoped(value));\n }\n\n if !(block == last_loc || analysis.is_before(block, last_loc)) {\n return (false, chain_graph.insert_scoped(value));\n }\n\n trace!(\"A2 last_loc: {}\", last_loc);\n\n // Look up existing node\n if let Some(existing) = existing_nodes.get(&value) {\n return (true, *existing);\n }\n\n trace!(\"A6\");\n\n // If the value is a phi, we build recursively\n let v_phi = chain_graph.insert_phi(0, value);\n\n // If there exists a phi for the value, add those to phi\n if let Some(phi) = analysis.phis.get(&value) {\n for (from_block, source) in phi.sources.iter() {\n if let Some(from_val) = source.value {\n let (_req, node) = build_node(\n bump,\n fun,\n //graph,\n live,\n analysis,\n target,\n block_graph,\n *from_block,\n from_val,\n chain_graph,\n existing_nodes,\n );\n for entry in block_graph.iter_entries_for(*from_block) {\n let chain = block_graph.entry_to_chain(entry);\n chain_graph.phi_add_entry(v_phi, chain, node);\n }\n }\n }\n }\n\n // If current block is an entry, add that to the phi\n if tree.entry_edges.contains_key(&block) {\n let chain = block_graph.entry_to_chain(block);\n let node = chain_graph.insert_chain_entry_arg(chain, arg_index, value);\n chain_graph.phi_add_entry(v_phi, chain, node);\n }\n\n existing_nodes.insert(value, v_phi);\n (true, v_phi)\n }\n ValueKind::Block(block) => {\n // Look up existing node\n if let Some(existing) = existing_nodes.get(&value) {\n return (true, *existing);\n }\n\n let env = live.live_at(block);\n\n let v_block = chain_graph.insert_block_capture(value, block);\n for dep_value in env.iter() {\n let (_req, node) = build_node(\n bump,\n fun,\n //graph,\n live,\n analysis,\n target,\n block_graph,\n last_loc,\n dep_value,\n chain_graph,\n existing_nodes,\n );\n chain_graph.add_dep(v_block, node, dep_value);\n }\n\n existing_nodes.insert(value, v_block);\n (true, v_block)\n }\n ValueKind::PrimOp(prim) => {\n // Look up existing node\n if let Some(existing) = existing_nodes.get(&value) {\n return (true, *existing);\n }\n\n let v_prim = chain_graph.insert_prim(value);\n let mut required = false;\n for p_read in fun.primop_reads(prim) {\n let (req, dep_node) = build_node(\n bump,\n fun,\n //graph,\n live,\n analysis,\n target,\n block_graph,\n last_loc,\n *p_read,\n chain_graph,\n existing_nodes,\n );\n chain_graph.add_dep(v_prim, dep_node, *p_read);\n if req {\n required = true;\n }\n }\n\n existing_nodes.insert(value, v_prim);\n (required, v_prim)\n }\n ValueKind::Const(_) => (false, chain_graph.insert_scoped(value)),\n }\n}\n\npub fn analyze_chain<'bump>(\n bump: &'bump Bump,\n target: Block,\n fun: &Function,\n graph: &LiveBlockGraph,\n live: &LiveValues,\n analysis: &'bump GraphAnalysis,\n) -> super::chain_graph::ChainGraph {\n let tree = &analysis.trees[&target];\n\n let mut chain_graph = super::chain_graph::ChainGraph::new(target);\n\n // Mapping from entry `Block`s to its `Chain`.\n let mut entry_to_chain: BTreeMap = BTreeMap::new();\n // Mapping from all `Block`s to all `Chain`s each is part of.\n let mut block_to_entries: BTreeMap> = BTreeMap::new();\n\n for (entry_block, _) in tree.entry_edges.iter() {\n let mut block_chain = Vec::new();\n\n block_chain.push(*entry_block);\n\n // Walk blocks in order, adding to chain list\n let mut curr = *entry_block;\n loop {\n if let Some(next) = analysis.static_branches_blocks.get(&curr) {\n curr = *next;\n block_chain.push(curr);\n if curr == target {\n break;\n }\n } else {\n break;\n }\n }\n\n let num_args = fun.block_args(*entry_block).len();\n\n // Create map of `Block` to all `Chain`s it's part of.\n for block in block_chain.iter() {\n block_to_entries\n .entry(*block)\n .or_insert_with(|| BTreeSet::new())\n .insert(*entry_block);\n }\n\n // Create chain in graph\n let chain = chain_graph.entry_chain(num_args, block_chain.clone());\n\n assert!(!entry_to_chain.contains_key(entry_block));\n entry_to_chain.insert(*entry_block, chain);\n }\n\n let chain_mapping = ChainMapping {\n entry_to_chain,\n block_to_entries,\n };\n\n let mut existing_nodes = BTreeMap::new();\n\n for root_value in live.live_in(target).iter() {\n let (required, node) = build_node(\n bump,\n fun,\n live,\n analysis,\n target,\n &chain_mapping,\n target,\n root_value,\n &mut chain_graph,\n &mut existing_nodes,\n );\n if required {\n chain_graph.mark_root(root_value, node);\n }\n }\n\n //chain_graph.gen_dot(&std::path::Path::new(\"woo_bef.png\"));\n chain_graph.process();\n //chain_graph.gen_dot(&std::path::Path::new(\"woo.png\"));\n\n chain_graph\n}\n" }, { "path": "libeir_passes/src/simplify_cfg/analyze/unpack_value_list.rs", "content": "use libeir_ir::{Block, PrimOpKind};\n\nuse super::AnalysisContext;\n\npub(super) fn propagate(ctx: &mut AnalysisContext, block: Block, n: usize) -> bool {\n let reads = ctx.fun.block_reads(block);\n\n assert!(reads.len() == 2);\n\n let target = ctx.follow(reads[0]);\n let list = ctx.follow(reads[1]);\n\n if let Some(target_block) = ctx.fun.value_block(target) {\n let target_args = ctx.fun.block_args(target_block);\n assert!(n == target_args.len());\n\n // Value list of length 1 can't exist, always the value itself\n if n == 1 {\n ctx.set_branch(target);\n ctx.add_rename(target_block, reads[1], 0);\n return true;\n }\n\n if let Some(prim) = ctx.fun.value_primop(list) {\n if let PrimOpKind::ValueList = ctx.fun.primop_kind(prim) {\n let prim_reads = ctx.fun.primop_reads(prim);\n assert!(target_args.len() == prim_reads.len());\n\n ctx.set_branch(target);\n\n for (idx, read) in prim_reads.iter().enumerate() {\n ctx.add_rename(target_block, *read, idx);\n }\n\n return true;\n } else {\n panic!()\n }\n }\n }\n\n false\n}\n" }, { "path": "libeir_passes/src/simplify_cfg/chain_graph/mod.rs", "content": "use log::trace;\n\nuse std::collections::{BTreeMap, BTreeSet};\n\nuse cranelift_entity::{entity_impl, PrimaryMap};\nuse libeir_ir::{Block, PrimOp, Value};\nuse libeir_util_datastructures::pooled_entity_set::{EntitySet, EntitySetPool};\n\nuse libeir_util_dot_graph::{DisplayNid, GraphPrinter, NodeId, PrefixedNid};\n\nuse super::analyze::PhiSource;\nuse crate::util::Walker;\n\npub mod synthesis;\n\n/// Disambiguate between a value that originates within the tree, and one that\n/// is referenced externally.\n///\n/// This is required because of tight loops, a member value may also be accessed\n/// from the last iteration as scoped.\n#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]\npub enum ValueRef {\n Member(Value),\n Scope(Value),\n}\n\n#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]\npub struct Node(u32);\nentity_impl!(Node, \"node\");\nimpl NodeId for Node {\n fn make_id(&self, out: &mut String) {\n use std::fmt::Write;\n write!(out, \"{}\", self).unwrap();\n }\n}\n\n#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]\npub struct Chain(u32);\nentity_impl!(Chain, \"chain\");\nimpl NodeId for Chain {\n fn make_id(&self, out: &mut String) {\n use std::fmt::Write;\n write!(out, \"{}\", self).unwrap();\n }\n}\n\n/// Graph representing value uses in a single static call chain.\n///\n/// Graph has 5 node types:\n/// * Root value. These are externally referencable nodes. They are always tied\n/// to a single source cfg value.\n/// They have a single outgoing edge and no incoming edges.\n/// * Leaf value. These are nodes referencing external values in the source CFG.\n/// They have N incoming edges and no outgoing edges.\n/// * Phi node. Phi nodes perform selection on values from incoming blocks.\n/// They have N incoming edges and M outgoing edges.\n/// * PrimOp node. These construct a primop from M referenced values.\n/// They have N incoming edges and M outgoing edges.\n/// * BlockCapture node. These capture a block as a closure with M referenced\n/// values in the environment.\n/// They have B incoming edges and M outgoing edges.\n///\n/// The primary purpose of this graph is to do reduction of the value use graph\n/// independently of the original control flow. This enables us to later\n/// synthesize a new CFG that performs the same semantically while potentially\n/// being more optimal.\n///\n/// The graph is operated on with a couple of main operations, usually in order:\n/// 1. Graph construction. See public helper functions on the graph.\n/// 2. Graph reduction. See `reduce_phis` function.\n/// 3. CFG synthesis. Generates a new CFG from the reduced value use graph,\n/// according to the strategy used. The strategy needs to decide to schedule\n/// a node before or after phi selection.\n/// * When scheduled after phi selection, the node will only occur once in\n/// the target CFG, but the resulting CFG may be more complex.\n/// * Scheduling a node before phi selection may result in radically simpler\n/// target CFGs from the perspective of the chain itself, but will perform\n/// specialization on the different nodes and can thus result in larger\n/// CFG size overall.\npub struct ChainGraph {\n target_block: Block,\n\n /// Which nodes in the graph are currently active.\n /// This is mainly maintained for printing.\n active_nodes: BTreeSet,\n\n values: BTreeMap,\n terminal_values: BTreeMap,\n\n nodes: PrimaryMap,\n\n /// These are the roots of the chain graph, the entry edges.\n entry_edges: BTreeMap,\n /// These are entry edges that has been found to map to a single terminal.\n uniform_mappings: BTreeMap,\n\n chains: PrimaryMap,\n\n back_edges: BTreeMap,\n\n aliases: BTreeMap,\n node_pool: EntitySetPool,\n}\n\npub struct ChainData {\n /// Only there for debug printing.\n blocks: Vec,\n /// The arguments to the chain entry block.\n /// If `Some(Node)`, this is the `ChainEntry` node with this index.\n args: Vec>,\n}\n\n/// Public API\nimpl ChainGraph {\n pub fn new(target_block: Block) -> Self {\n ChainGraph {\n target_block,\n\n active_nodes: BTreeSet::new(),\n\n values: BTreeMap::new(),\n terminal_values: BTreeMap::new(),\n\n nodes: PrimaryMap::new(),\n\n entry_edges: BTreeMap::new(),\n\n chains: PrimaryMap::new(),\n\n back_edges: BTreeMap::new(),\n\n uniform_mappings: BTreeMap::new(),\n\n aliases: BTreeMap::new(),\n node_pool: EntitySetPool::new(),\n }\n }\n\n pub fn propagate_alias(&self, mut node: Node) -> Node {\n loop {\n if let Some(nnode) = self.aliases.get(&node) {\n node = *nnode;\n } else {\n break node;\n }\n }\n }\n\n pub fn get_terminal_value_node(&self, value: Value) -> Option {\n let mut node = *self.terminal_values.get(&value)?;\n Some(self.propagate_alias(node))\n }\n pub fn get_member_value_node(&self, value: Value) -> Option {\n let mut node = *self.values.get(&value)?;\n Some(self.propagate_alias(node))\n }\n\n pub fn get_member_or_terminal(&self, value: Value) -> Option {\n self.get_member_value_node(value)\n .or_else(|| self.get_terminal_value_node(value))\n }\n\n //pub fn node_is_value(&self, node: Node) -> bool {\n // self.nodes[node].is_value()\n //}\n\n //pub fn mark_root(&mut self, value: Value) {\n // // TODO change to take node?\n // let node = self.get_value_node(value).unwrap();\n // self.entry_edges.insert(value, node);\n //}\n pub fn mark_root(&mut self, value: Value, node: Node) {\n if let Some(old) = self.entry_edges.get(&value) {\n assert!(node == *old);\n }\n self.entry_edges.insert(value, node);\n }\n\n pub fn get_root(&self, value: Value) -> Option {\n self.entry_edges.get(&value).cloned()\n }\n pub fn get_uniform(&self, value: Value) -> Option {\n self.uniform_mappings.get(&value).cloned()\n }\n\n pub fn iter_roots<'a>(&'a self) -> impl Iterator + 'a {\n self.entry_edges.iter().map(|(k, v)| (*k, *v))\n }\n pub fn iter_uniform_mappings<'a>(&'a self) -> impl Iterator + 'a {\n self.uniform_mappings.iter().map(|(k, v)| (*k, *v))\n }\n\n pub fn insert_scoped(&mut self, value: Value) -> Node {\n //if let Some(node) = self.terminal_values.get(&value) {\n // assert!(self.active_nodes.contains(&node));\n // // TODO assert same\n // return *node;\n //}\n let node = self.nodes.push(NodeKind::Scope(value));\n self.active_nodes.insert(node);\n self.terminal_values.insert(value, node);\n node\n }\n\n pub fn insert_chain_entry_arg(&mut self, chain: Chain, arg_index: usize, arg: Value) -> Node {\n //if let Some(node) = self.terminal_values.get(&arg) {\n // assert!(self.active_nodes.contains(&node));\n // // TODO assert same\n // return *node;\n //}\n let entry_arg = EntryArg {\n chain,\n arg_index,\n arg,\n };\n let node = self.nodes.push(NodeKind::EntryArg(entry_arg));\n self.active_nodes.insert(node);\n self.terminal_values.insert(arg, node);\n\n let slot = &mut self.chains[chain].args[arg_index];\n assert!(slot.is_none());\n *slot = Some(node);\n\n node\n }\n\n pub fn insert_phi(&mut self, tier: usize, value: Value) -> Node {\n if let Some(node) = self.values.get(&value) {\n assert!(self.active_nodes.contains(node));\n assert!(self.nodes[*node].is_phi());\n return *node;\n }\n let scope_node = self.insert_scoped(value);\n let node = self.nodes.push(NodeKind::Phi(Phi {\n value: Some((value, scope_node)),\n tier: Some(tier),\n entries: BTreeMap::new(),\n }));\n self.active_nodes.insert(node);\n self.values.insert(value, node);\n node\n }\n\n pub fn phi_add_entry(&mut self, node: Node, chain: Chain, dep: Node) {\n match &mut self.nodes[node] {\n NodeKind::Phi(phi) => {\n phi.entries.insert(chain, dep);\n }\n _ => panic!(),\n }\n }\n\n pub fn insert_prim(&mut self, value: Value) -> Node {\n if let Some(node) = self.values.get(&value) {\n assert!(self.active_nodes.contains(node));\n assert!(self.nodes[*node].is_prim());\n return *node;\n }\n let node = self.nodes.push(NodeKind::Prim(Prim {\n prim: value,\n dependencies: BTreeMap::new(),\n }));\n self.active_nodes.insert(node);\n self.values.insert(value, node);\n node\n }\n\n pub fn insert_block_capture(&mut self, value: Value, block: Block) -> Node {\n if let Some(node) = self.values.get(&value) {\n assert!(self.active_nodes.contains(node));\n assert!(self.nodes[*node].is_block_capture());\n return *node;\n }\n let node = self.nodes.push(NodeKind::BlockCapture(BlockCapture {\n value,\n capture: block,\n dependencies: BTreeMap::new(),\n }));\n self.active_nodes.insert(node);\n self.values.insert(value, node);\n node\n }\n\n pub fn add_dep(&mut self, node: Node, dep: Node, value: Value) {\n match &mut self.nodes[node] {\n NodeKind::Prim(prim) => {\n prim.dependencies.insert(value, dep);\n }\n NodeKind::BlockCapture(cap) => {\n cap.dependencies.insert(value, dep);\n }\n _ => panic!(),\n }\n }\n\n pub fn gen_dot(&self, out: &std::path::Path) {\n let mut g = GraphPrinter::new();\n\n for (node, node_data) in self.nodes.iter() {\n if !self.active_nodes.contains(&node) {\n continue;\n }\n\n g.node(node, &format!(\"{}: {:#?}\", node, node_data));\n\n match node_data {\n NodeKind::Scope(_) => {}\n NodeKind::EntryArg(_) => {}\n NodeKind::Phi(phi) => {\n for (block, from_node) in phi.entries.iter() {\n g.edge(node, *from_node, &format!(\"{:#?}\", (block, from_node)));\n }\n }\n NodeKind::Prim(prim) => {\n for (dep_value, dep_node) in prim.dependencies.iter() {\n g.edge(node, *dep_node, &format!(\"{:#?}\", (dep_value, dep_node)));\n }\n }\n NodeKind::BlockCapture(cap) => {\n for (dep_value, dep_node) in cap.dependencies.iter() {\n g.edge(node, *dep_node, &format!(\"{:#?}\", (dep_value, dep_node)));\n }\n }\n }\n }\n\n for (val, node) in self.entry_edges.iter() {\n let nid = PrefixedNid(\"entry_\", DisplayNid(val));\n g.node(nid, &format!(\"root dep: {}\", val));\n g.edge(nid, DisplayNid(node), \"\");\n }\n\n let mut added_blocks = BTreeSet::new();\n for (chain, chain_data) in self.chains.iter() {\n for block in chain_data.blocks.iter() {\n if !added_blocks.contains(block) {\n added_blocks.insert(block);\n g.node(DisplayNid(*block), &format!(\"{}\", block));\n }\n }\n for (from, to) in chain_data\n .blocks\n .iter()\n .zip(chain_data.blocks.iter().skip(1))\n {\n g.edge(DisplayNid(from), DisplayNid(to), \"\");\n }\n g.edge(\n DisplayNid(chain),\n DisplayNid(chain_data.blocks[0]),\n &format!(\"{:?}\", chain_data.args),\n );\n }\n\n g.finish_run_dot(out);\n }\n\n pub fn chain_count(&self) -> usize {\n self.chains.len()\n }\n\n pub fn entry_chain(&mut self, arity: usize, blocks: Vec) -> Chain {\n self.chains.push(ChainData {\n args: vec![None; arity],\n blocks,\n })\n }\n\n pub fn get_chain_entry_block(&self, chain: Chain) -> Block {\n self.chains[chain].blocks[0]\n }\n\n pub fn node(&self, node: Node) -> &NodeKind {\n &self.nodes[node]\n }\n\n pub fn follow_chain(&self, mut node: Node, chain: Chain) -> Node {\n //println!(\"Follow {} {}\", node, chain);\n loop {\n match &self.nodes[node] {\n NodeKind::Phi(phi) => {\n node = phi.entries[&chain];\n }\n _ => break,\n }\n }\n node\n }\n pub fn follow_chain_maybe(&self, mut node: Node, chain: Chain) -> Option {\n //println!(\"Follow {} {}\", node, chain);\n loop {\n match &self.nodes[node] {\n NodeKind::Phi(phi) => {\n if let Some(next) = phi.entries.get(&chain) {\n node = *next;\n } else {\n return None;\n }\n }\n _ => break,\n }\n }\n Some(node)\n }\n\n pub fn dfs(&self, start: Node, order: &mut Vec) {\n order.clear();\n let mut walker = Walker::with(self.entry_edges.values().cloned().collect());\n while let Some(node) = walker.next() {\n let node_data = &self.nodes[node];\n for dep in node_data.dependencies() {\n walker.put(dep);\n }\n order.push(node);\n }\n }\n\n pub fn process(&mut self) {\n self.expand_phis();\n self.remove_uniform();\n self.reduce_phis2();\n\n //chain_graph.decycle();\n //chain_graph.expand_phis();\n //chain_graph.remove_uniform();\n //chain_graph.reduce_phis();\n }\n}\n\n/// Private API\nimpl ChainGraph {\n fn propagate_graph_aliases(&mut self) {\n let mut tmp = Vec::new();\n\n for node in self.entry_edges.values_mut() {\n if let Some(to) = self.aliases.get(&*node) {\n *node = *to;\n }\n }\n\n for node in self.nodes.values_mut() {\n match node {\n NodeKind::Scope(_) => (),\n NodeKind::EntryArg(_) => (),\n NodeKind::Phi(phi) => {\n for entry_node in phi.entries.values_mut() {\n if let Some(to) = self.aliases.get(&*entry_node) {\n *entry_node = *to;\n }\n }\n }\n NodeKind::Prim(prim) => {\n tmp.clear();\n tmp.extend(prim.dependencies.iter().map(|(k, v)| (*k, *v)));\n prim.dependencies.clear();\n\n for (dep_value, dep_node) in tmp.iter() {\n if let Some(to) = self.aliases.get(dep_node) {\n prim.dependencies.insert(*dep_value, *to);\n } else {\n prim.dependencies.insert(*dep_value, *dep_node);\n }\n }\n }\n NodeKind::BlockCapture(bc) => {\n tmp.clear();\n tmp.extend(bc.dependencies.iter().map(|(k, v)| (*k, *v)));\n bc.dependencies.clear();\n\n for (dep_value, dep_node) in tmp.iter() {\n if let Some(to) = self.aliases.get(dep_node) {\n bc.dependencies.insert(*dep_value, *to);\n } else {\n bc.dependencies.insert(*dep_value, *dep_node);\n }\n }\n }\n }\n }\n }\n\n fn insert_anon_phi(&mut self) -> Node {\n let node = self.nodes.push(NodeKind::Phi(Phi {\n value: None,\n tier: None,\n entries: BTreeMap::new(),\n }));\n self.active_nodes.insert(node);\n node\n }\n}\n\nimpl ChainGraph {\n pub fn remove_uniform(&mut self) {\n 'outer: for (entry_value, entry_node) in self.entry_edges.iter() {\n let mut terminal = None;\n for chain in self.chains.keys() {\n let end = self.follow_chain(*entry_node, chain);\n let end_kind = &self.nodes[end];\n\n if !end_kind.is_terminal() {\n continue 'outer;\n }\n\n if let Some(prev) = terminal {\n let prev_value = self.nodes[prev].terminal_value();\n let curr_value = self.nodes[end].terminal_value();\n\n if prev_value != curr_value {\n continue 'outer;\n }\n\n if self.nodes[end].is_entry_arg() {\n terminal = Some(end);\n }\n } else {\n terminal = Some(end);\n }\n }\n self.uniform_mappings\n .insert(*entry_value, terminal.unwrap());\n }\n\n for entry in self.uniform_mappings.keys() {\n self.entry_edges.remove(entry);\n }\n }\n\n pub fn expand_phis(&mut self) {\n for entry_node in self.entry_edges.values() {\n match &mut self.nodes[*entry_node] {\n NodeKind::Phi(phi) => {\n let (_value, scoped_node) = phi.value.unwrap();\n\n for chain in self.chains.keys() {\n if !phi.entries.contains_key(&chain) {\n phi.entries.insert(chain, scoped_node);\n }\n }\n }\n _ => (),\n }\n }\n }\n\n pub fn reduce_phis2(&mut self) {\n fn collect_relevant_phis(\n graph: &ChainGraph,\n relevant: &mut BTreeSet,\n node: Node,\n parent_relevant: bool,\n ) {\n match &graph.nodes[node] {\n NodeKind::Phi(phi) => {\n if parent_relevant {\n relevant.insert(node);\n }\n\n for dep_node in phi.entries.values() {\n collect_relevant_phis(graph, relevant, *dep_node, false);\n }\n }\n kind => {\n for dep_node in kind.dependencies() {\n collect_relevant_phis(graph, relevant, dep_node, true);\n }\n }\n }\n }\n\n let mut relevant = BTreeSet::new();\n for entry in self.entry_edges.values() {\n collect_relevant_phis(self, &mut relevant, *entry, true);\n }\n\n for phi in relevant.iter() {\n let new = self.insert_anon_phi();\n\n let mut a_node = None;\n let mut is_mono = true;\n\n for chain in self.chains.keys() {\n if let Some(end) = self.follow_chain_maybe(*phi, chain) {\n if let Some(prev) = a_node {\n if end != prev {\n is_mono = false;\n }\n } else {\n a_node = Some(end);\n }\n\n self.phi_add_entry(new, chain, end);\n }\n }\n\n if is_mono {\n self.aliases.insert(*phi, a_node.unwrap());\n } else {\n self.aliases.insert(*phi, new);\n }\n }\n\n self.propagate_graph_aliases();\n }\n}\n\n/// Graph decycle\n//impl ChainGraph {\n//\n// pub fn decycle(&mut self) {\n//\n// #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]\n// enum EdgeRef {\n// Chain(Chain),\n// Value(Value),\n// }\n// impl EdgeRef {\n// fn chain(&self) -> Chain {\n// match self {\n// EdgeRef::Chain(chain) => *chain,\n// _ => unreachable!(),\n// }\n// }\n// fn value(&self) -> Value {\n// match self {\n// EdgeRef::Value(value) => *value,\n// _ => unreachable!(),\n// }\n// }\n// }\n//\n// let mut updates = BTreeMap::new();\n// let mut new_value_nodes = BTreeSet::new();\n//\n// fn rec(\n// cg: &ChainGraph,\n// updates: &mut BTreeMap<(Node, EdgeRef), Value>,\n// new_value_nodes: &mut BTreeSet,\n// last_tier: Option,\n// last_edge: Option<(Node, EdgeRef)>,\n// node: Node,\n// ) {\n// match &cg.nodes[node] {\n// NodeKind::Scope(_value) => (),\n// NodeKind::EntryArg(_entry_arg) => (),\n// NodeKind::Phi(phi) => {\n// let tier = phi.tier.unwrap();\n//\n// if let Some(last_tier) = last_tier {\n// println!(\"{} <= {}\", tier, last_tier);\n// }\n//\n// match last_tier {\n// Some(last_tier) if tier <= last_tier => {\n// println!(\"!!!! {} <= {}\", tier, last_tier);\n//\n// let curr_value = phi.value.unwrap();\n// new_value_nodes.insert(curr_value);\n// updates.insert(last_edge.unwrap(), curr_value);\n// },\n// _ => {\n// for (from_block, value_node) in phi.entries.iter() {\n// rec(\n// cg,\n// updates,\n// new_value_nodes,\n// Some(tier),\n// Some((node, EdgeRef::Chain(*from_block))),\n// *value_node,\n// );\n// }\n// },\n// }\n//\n// },\n// NodeKind::Prim(prim) => {\n// for (from_value, value_node) in prim.dependencies.iter() {\n// rec(\n// cg,\n// updates,\n// new_value_nodes,\n// last_tier,\n// Some((node, EdgeRef::Value(*from_value))),\n// *value_node,\n// );\n// }\n// },\n// NodeKind::BlockCapture(bc) => {\n// for (from_value, value_node) in bc.dependencies.iter() {\n// rec(\n// cg,\n// updates,\n// new_value_nodes,\n// last_tier,\n// Some((node, EdgeRef::Value(*from_value))),\n// *value_node,\n// );\n// }\n// },\n// }\n// }\n//\n// for entry_node in self.entry_edges.values() {\n// rec(self, &mut updates, &mut new_value_nodes, None, None, *entry_node);\n// }\n//\n// println!(\"UPDATES: {:?}\", updates);\n//\n// let mut new_values = BTreeMap::new();\n//\n// for value in new_value_nodes.iter() {\n// if let Some(existing) = self.get_terminal_value_node(*value) {\n// new_values.insert(*value, existing);\n// } else {\n// let node = self.nodes.push(NodeKind::Scope(*value));\n// self.active_nodes.insert(node);\n// self.terminal_values.insert(*value, node);\n// new_values.insert(*value, node);\n// }\n// }\n//\n// for ((node, edge), value) in updates.iter() {\n// let new_target = new_values[value];\n//\n// let node = &mut self.nodes[*node];\n// match node {\n// NodeKind::Scope(_) => unreachable!(),\n// NodeKind::EntryArg(_) => unreachable!(),\n// NodeKind::Phi(phi) => {\n// let chain = edge.chain();\n// phi.entries.insert(chain, new_target);\n// }\n// NodeKind::Prim(prim) => {\n// let value = edge.value();\n// prim.dependencies.insert(value, new_target);\n// }\n// NodeKind::BlockCapture(bc) => {\n// let value = edge.value();\n// bc.dependencies.insert(value, new_target);\n// }\n// }\n// }\n//\n// }\n//\n//}\n\n/// Graph reduction\nimpl ChainGraph {\n /// This will reduce complex chains of phis into either:\n /// * A single phi block. This is done when selection between several\n /// incoming paths is required.\n /// * No phi blocks. This is done when there is only one value selected\n /// reducing the phis.\n pub fn reduce_phis(&mut self) {\n #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]\n pub struct Group(u32);\n entity_impl!(Group, \"group\");\n\n let mut node_pool = EntitySetPool::new();\n\n let mut active_phi_groups: BTreeSet = BTreeSet::new();\n let mut phi_groups: PrimaryMap> = PrimaryMap::new();\n let mut phi_groups_back: BTreeMap = BTreeMap::new();\n\n // Walk the graph while identifying all phi node groups.\n let mut walker = Walker::with(self.entry_edges.values().cloned().collect());\n while let Some(node) = walker.next() {\n let node_data = &self.nodes[node];\n for dep in node_data.dependencies() {\n walker.put(dep);\n }\n if node_data.is_phi() {\n let group = if let Some(group) = phi_groups_back.get(&node) {\n // The node is part of an already identified group.\n *group\n } else {\n // We create a new phi group for this node.\n let mut set = EntitySet::new();\n set.insert(node, &mut node_pool);\n\n let group = phi_groups.push(set);\n active_phi_groups.insert(group);\n\n phi_groups_back.insert(node, group);\n\n group\n };\n\n for dep in node_data.dependencies() {\n if self.nodes[dep].is_phi() {\n if let Some(other_group) = phi_groups_back.get(&dep).cloned() {\n // We can hit a node that's already present in a\n // group if the graph joins from two different root\n // nodes. In this case we simply merge the two.\n\n // We disregard `group`.\n active_phi_groups.remove(&group);\n\n let s_group = phi_groups[group].clone();\n\n // Union into `other_group`\n phi_groups[other_group].union(&s_group, &mut node_pool);\n\n // Update back mappings for all entries in `group`\n for s_node in s_group.iter(&node_pool) {\n phi_groups_back.insert(s_node, other_group);\n }\n } else {\n // Normal case, node is not assigned to a group.\n // Insert it into the current group, create a back\n // mapping.\n phi_groups[group].insert(dep, &mut node_pool);\n phi_groups_back.insert(dep, group);\n }\n }\n }\n }\n }\n\n // These are used to update graph edges\n let mut final_entries: Vec<(Chain, Node)> = Vec::new();\n\n for group in active_phi_groups.iter() {\n final_entries.clear();\n\n let group_set = &phi_groups[*group];\n for node in group_set.iter(&node_pool) {\n match &self.nodes[node] {\n NodeKind::Phi(phi) => {\n // For each entry in the phi..\n for (block, block_node) in phi.entries.iter() {\n // if the entry is not to another node in the group.\n if !self.nodes[*block_node].is_phi() {\n // add the entry to the new phi\n final_entries.push((*block, *block_node));\n }\n }\n }\n _ => unreachable!(),\n }\n }\n\n let new_target;\n\n trace!(\"FINAL ENTRIES: {:?}\", final_entries);\n\n // If there is only one target node, we can completely omit the phi.\n assert!(final_entries.len() > 0);\n let first_node = final_entries[0].1;\n if final_entries.iter().all(|(_b, n)| *n == first_node) {\n new_target = first_node;\n } else {\n // The new phi node that encompasses the entire group\n let new_phi = self.insert_anon_phi();\n\n // Add entries to new phi\n for (chain, from_node) in final_entries.iter() {\n // If the from node is not a phi itself, then it's always\n // from outside the group.\n if !self.nodes[*from_node].is_phi() {\n //self.phi_add_entry(new_phi, *entry_block, *block_node);\n match &mut self.nodes[new_phi] {\n NodeKind::Phi(phi) => {\n // Sanity check, chain will never occur more\n // than once.\n assert!(!phi.entries.contains_key(chain));\n phi.entries.insert(*chain, *from_node);\n }\n _ => panic!(),\n }\n }\n }\n\n new_target = new_phi;\n }\n\n for node in group_set.iter(&node_pool) {\n // Update all nodes in the graph so they reference the new phi\n // instead of entries in the old group\n self.aliases.insert(node, new_target);\n self.active_nodes.remove(&node);\n }\n }\n\n // Propagate all aliases, this will update the graph with our changes.\n self.propagate_graph_aliases();\n }\n}\n\n#[derive(Debug)]\npub enum NodeKind {\n /// External value\n Scope(Value),\n /// Value on entry point of a chain\n EntryArg(EntryArg),\n /// Phi within chain\n Phi(Phi),\n /// Prim with dependencies\n Prim(Prim),\n /// Block capture with dependencies\n BlockCapture(BlockCapture),\n}\nimpl NodeKind {\n pub fn is_phi(&self) -> bool {\n match self {\n NodeKind::Phi(_) => true,\n _ => false,\n }\n }\n pub fn is_prim(&self) -> bool {\n match self {\n NodeKind::Prim(_) => true,\n _ => false,\n }\n }\n pub fn is_block_capture(&self) -> bool {\n match self {\n NodeKind::BlockCapture(_) => true,\n _ => false,\n }\n }\n pub fn is_scope(&self) -> bool {\n match self {\n NodeKind::Scope(_) => true,\n _ => false,\n }\n }\n pub fn is_entry_arg(&self) -> bool {\n match self {\n NodeKind::EntryArg(_) => true,\n _ => false,\n }\n }\n\n pub fn is_terminal(&self) -> bool {\n match self {\n NodeKind::Scope(_) => true,\n NodeKind::EntryArg(_) => true,\n _ => false,\n }\n }\n pub fn terminal_value(&self) -> Value {\n match self {\n NodeKind::Scope(value) => *value,\n NodeKind::EntryArg(entry_arg) => entry_arg.arg,\n _ => unreachable!(),\n }\n }\n\n pub fn dependencies<'a>(&'a self) -> impl Iterator + 'a {\n enum EIter\n where\n A: Iterator,\n B: Iterator,\n C: Iterator,\n {\n A(A),\n B(B),\n C(C),\n None,\n }\n impl Iterator for EIter\n where\n A: Iterator,\n B: Iterator,\n C: Iterator,\n {\n type Item = T;\n fn next(&mut self) -> Option {\n match self {\n EIter::A(a) => a.next(),\n EIter::B(b) => b.next(),\n EIter::C(c) => c.next(),\n EIter::None => None,\n }\n }\n }\n\n match self {\n NodeKind::Phi(i) => EIter::A(i.entries.values().cloned()),\n NodeKind::Prim(i) => EIter::B(i.dependencies.values().cloned()),\n NodeKind::BlockCapture(i) => EIter::C(i.dependencies.values().cloned()),\n NodeKind::Scope(_) => EIter::None,\n NodeKind::EntryArg(_) => EIter::None,\n }\n }\n}\n\n/// A value on the entry point on a chain.\n#[derive(Debug)]\npub struct EntryArg {\n pub chain: Chain,\n pub arg_index: usize,\n pub arg: Value,\n}\n\n/// Selects a value depending on the block it passes through.\n#[derive(Debug)]\npub struct Phi {\n pub value: Option<(Value, Node)>,\n pub tier: Option,\n pub entries: BTreeMap,\n}\n\n/// Composition using primop\n#[derive(Debug)]\npub struct Prim {\n /// The value referencing the original PrimOp.\n /// Used when synthesizing the new CFG.\n pub prim: Value,\n /// Mapping from used value => node\n pub dependencies: BTreeMap,\n}\n\n/// Composition using closure capture\n#[derive(Debug)]\npub struct BlockCapture {\n /// Mainly for debugging.\n pub value: Value,\n /// The block being captured.\n /// Used when synthesizing the new CFG.\n pub capture: Block,\n /// Mapping from used value => node\n pub dependencies: BTreeMap,\n}\n" }, { "path": "libeir_passes/src/simplify_cfg/chain_graph/synthesis/compound.rs", "content": "use log::trace;\n\nuse super::super::ChainGraph;\nuse super::{Synthesis, SynthesisStrategy};\nuse libeir_ir::{Function, LiveValues};\n\n/// Synthesis strategy that dispatches to any number of other strategies\n/// depending on the chain graph.\npub struct CompoundStrategy;\n\nimpl SynthesisStrategy for CompoundStrategy {\n fn try_run(&self, graph: &ChainGraph, fun: &Function, live: &LiveValues) -> Option {\n trace!(\"Trying single entry strategy...\");\n // Try the single strategy.\n // Will only succeed if there is a single entry.\n let single_strategy = super::single::SingleStrategy;\n if let Some(s) = single_strategy.try_run(graph, fun, live) {\n trace!(\"Single entry strategy succeeded!\");\n return Some(s);\n }\n\n trace!(\"Trying terminating target strategy...\");\n let single_strategy = super::terminating_target::TerminatingTargetStrategy;\n if let Some(s) = single_strategy.try_run(graph, fun, live) {\n trace!(\"Terminating target strategy succeeded!\");\n return Some(s);\n }\n\n trace!(\"Falling back to simple strategy...\");\n // Fall back to simple strategy.\n // This will work in every case (except for single entry, this is\n // handled by SingleStrategy above).\n let simple_strategy = super::simple::SimpleStrategy;\n Some(simple_strategy.try_run(graph, fun, live).unwrap())\n }\n}\n" }, { "path": "libeir_passes/src/simplify_cfg/chain_graph/synthesis/mod.rs", "content": "#![allow(dead_code)]\n\nuse std::collections::BTreeMap;\n\nuse super::{Chain, ChainGraph, Node};\nuse cranelift_entity::{entity_impl, EntityList, ListPool, PrimaryMap, SecondaryMap};\nuse libeir_ir::{Function, LiveValues, Value};\nuse libeir_util_datastructures::aux_traits::{AuxDebug, AuxImpl};\nuse libeir_util_datastructures::pooled_entity_set::{EntitySet, EntitySetPool};\n\npub mod compound;\npub mod simple;\npub mod single;\npub mod terminating_target;\n\npub struct Synthesis {\n pub segments: PrimaryMap,\n pub order: Vec,\n\n pub instances: PrimaryMap,\n\n pub substitutions: BTreeMap,\n\n pub segments_back: Option>>,\n\n pub chain_set_pool: EntitySetPool,\n pub node_pool: ListPool,\n pub instance_pool: ListPool,\n pub segment_set_pool: Option>,\n}\n\nimpl std::fmt::Debug for Synthesis {\n fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {\n let mut b = f.debug_struct(\"Synthesis\");\n b.field(\"segments\", &AuxImpl(&self.segments, self));\n b.field(\"order\", &self.order);\n b.field(\"instances\", &self.instances);\n b.field(\"substitutions\", &self.substitutions);\n match &self.segments_back {\n None => {\n let none: Option<()> = None;\n b.field(\"segments_back\", &none)\n }\n Some(inner) => b.field(\n \"segments_back\",\n &AuxImpl(inner, self.segment_set_pool.as_ref().unwrap()),\n ),\n };\n b.finish()\n }\n}\n\nimpl Synthesis {\n pub fn new() -> Self {\n Synthesis {\n segments: PrimaryMap::new(),\n order: Vec::new(),\n\n instances: PrimaryMap::new(),\n\n substitutions: BTreeMap::new(),\n\n segments_back: None,\n\n chain_set_pool: EntitySetPool::new(),\n node_pool: ListPool::new(),\n instance_pool: ListPool::new(),\n segment_set_pool: None,\n }\n }\n\n fn create_segment(&mut self, head: SegmentHeadKind) -> Segment {\n self.segments.push(SegmentData {\n head,\n in_args: EntityList::new(),\n externals: EntityList::new(),\n instances: EntityList::new(),\n body: SegmentBodyKind::None,\n\n chains: EntitySet::new(),\n node_ord: EntityList::new(),\n })\n }\n\n pub fn create_entry_segment(&mut self, chain: Chain, graph: &ChainGraph) -> Segment {\n let segment = self.create_segment(SegmentHeadKind::Entry { chain });\n\n let mut in_args = EntityList::new();\n for arg in graph.chains[chain].args.iter() {\n let instance = match arg {\n Some(arg_node) => self.instances.push(InstanceKind::Arg {\n node: *arg_node,\n by: segment,\n }),\n None => self.instances.push(InstanceKind::NotRelevant),\n };\n in_args.push(instance, &mut self.instance_pool);\n }\n\n self.segments[segment].in_args = in_args;\n\n segment\n }\n\n pub fn create_intermediate_segment(&mut self) -> Segment {\n self.create_segment(SegmentHeadKind::Intermediate)\n }\n\n pub fn segment<'a>(&'a mut self, segment: Segment) -> SegmentBuilder<'a> {\n SegmentBuilder {\n synthesis: self,\n segment,\n out_args: EntityList::new(),\n }\n }\n\n pub fn visit_segment(&mut self, segment: Segment) {\n self.order.push(segment);\n }\n\n pub fn substitute(&mut self, chain: Chain, value: Value) {\n if let Some(prev_val) = self.substitutions.get(&chain) {\n assert!(*prev_val == value);\n } else {\n self.substitutions.insert(chain, value);\n }\n }\n\n /// This will perform necessary postprocessing of the synthesis.\n /// Does things like populate chains to segments, generate node order.\n pub fn postprocess(&mut self, graph: &ChainGraph) {\n let mut pool = EntitySetPool::new();\n let mut back: SecondaryMap> = SecondaryMap::new();\n\n let mut walker = crate::util::Walker::new();\n\n for segment_id in self.order.iter() {\n let segment = &self.segments[*segment_id];\n match segment.body {\n SegmentBodyKind::None => panic!(),\n SegmentBodyKind::Terminal { .. } => {\n walker.put(*segment_id);\n }\n SegmentBodyKind::ToIntermediate { to, .. } => {\n back[to].insert(*segment_id, &mut pool);\n }\n }\n }\n\n let mut segment_order = Vec::new();\n while let Some(segment_id) = walker.next() {\n let segment = &self.segments[segment_id];\n segment_order.push(segment_id);\n for pred in back[segment_id].iter(&pool) {\n walker.put(pred);\n }\n }\n\n for segment_id in segment_order.iter().rev() {\n let segment = &self.segments[*segment_id];\n let mut chains = segment.chains.clone();\n\n match &segment.head {\n SegmentHeadKind::Entry { chain } => {\n chains.insert(*chain, &mut self.chain_set_pool);\n }\n _ => (),\n }\n\n for pred in back[*segment_id].iter(&pool) {\n chains.union(&self.segments[pred].chains, &mut self.chain_set_pool);\n }\n\n self.segments[*segment_id].chains = chains;\n }\n\n self.segment_set_pool = Some(pool);\n self.segments_back = Some(back);\n }\n}\n\npub struct SegmentBuilder<'a> {\n synthesis: &'a mut Synthesis,\n segment: Segment,\n out_args: EntityList,\n}\nimpl<'a> SegmentBuilder<'a> {\n fn create_arg_instance(&mut self, node: Node) -> Instance {\n self.synthesis.instances.push(InstanceKind::Arg {\n node,\n by: self.segment,\n })\n }\n\n fn create_creation_instance(&mut self, node: Node) -> Instance {\n self.synthesis.instances.push(InstanceKind::BaseCreation {\n node,\n by: self.segment,\n })\n }\n\n pub fn push_in_arg(&mut self, node: Node) -> Instance {\n let instance = self.create_arg_instance(node);\n\n let seg = &mut self.synthesis.segments[self.segment];\n assert!(seg.head.is_intermediate());\n assert!(seg.body.is_none());\n\n seg.in_args\n .push(instance, &mut self.synthesis.instance_pool);\n\n instance\n }\n\n pub fn push_external(&mut self, instance: Instance) {\n let seg = &mut self.synthesis.segments[self.segment];\n assert!(seg.body.is_none());\n\n seg.externals\n .push(instance, &mut self.synthesis.instance_pool);\n }\n\n pub fn push_instance(&mut self, node: Node) -> Instance {\n let instance = self.create_creation_instance(node);\n\n let seg = &mut self.synthesis.segments[self.segment];\n assert!(seg.body.is_none());\n\n seg.instances\n .push(instance, &mut self.synthesis.instance_pool);\n\n instance\n }\n\n pub fn push_out_arg(&mut self, instance: Instance) {\n // TODO validate instance in scope?\n self.out_args\n .push(instance, &mut self.synthesis.instance_pool);\n }\n\n pub fn finish_to(&mut self, segment: Segment) {\n let seg = &mut self.synthesis.segments[self.segment];\n assert!(seg.body.is_none());\n seg.body = SegmentBodyKind::ToIntermediate {\n to: segment,\n out_args: self.out_args.clone(),\n };\n }\n\n pub fn finish_target(&mut self, single: bool) {\n let seg = &mut self.synthesis.segments[self.segment];\n assert!(seg.body.is_none());\n seg.body = SegmentBodyKind::Terminal { single };\n }\n}\n\n/// An instance of a node in the syntheized CFG.\n/// Can only be created once, in a single segment.\n/// This is a node that is instantiated in a set of chains.\n/// This is used as an unique id for a node instantiation when rewriting the\n/// EIR.\n#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]\npub struct Instance(u32);\nentity_impl!(Instance, \"instance\");\n\n#[derive(Debug)]\npub enum InstanceKind {\n BaseCreation {\n /// The node this is an instance of.\n node: Node,\n /// The segment that created this instance.\n by: Segment,\n },\n Arg {\n /// The node this is an instance of.\n node: Node,\n /// The segment that created this instance.\n by: Segment,\n },\n NotRelevant,\n}\nimpl InstanceKind {\n pub fn is_relevant(&self) -> bool {\n match self {\n InstanceKind::NotRelevant => false,\n _ => true,\n }\n }\n pub fn node(&self) -> Node {\n match self {\n InstanceKind::BaseCreation { node, .. } => *node,\n InstanceKind::Arg { node, .. } => *node,\n InstanceKind::NotRelevant => unreachable!(),\n }\n }\n}\n\n/// Synthesized segment, mostly equivalent to a block in the resulting EIR.\n#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]\npub struct Segment(u32);\nentity_impl!(Segment, \"segment\");\n\n/// This will:\n/// 1. Select a block according to the `head`\n/// 2. Insert `in_args` and `externals` into the local scope\n/// 3. Map all `instances` to the local scope, insert them into the local scope\n/// 4. Generate the body of the selected block according to `body`\n#[derive(Debug)]\npub struct SegmentData {\n /// The head of the segment, how the block is created, how control flow\n /// enters this segment.\n pub head: SegmentHeadKind,\n /// The instances that are created by arguments on the head.\n /// * If the head is a chain entry, the count must be equal to the entry\n /// argument count.\n /// * If the head is an intermediate block, this length will specify the\n /// argument count.\n pub in_args: EntityList,\n /// The externals of this segment, instances that are asserted to be in\n /// scope, but does not enter the segment through the head.\n pub externals: EntityList,\n /// The instances created by this segment.\n pub instances: EntityList,\n /// The body of the segment, how control flow leaves this segment.\n pub body: SegmentBodyKind,\n\n /// All chains that pass through this segment.\n /// This should not be generated by the strategy, it will be populated\n /// afterwards.\n pub chains: EntitySet,\n /// A valid lowering order for nodes in the segment.\n /// This should not be generated by the strategy, it will be populated\n /// afterwards.\n pub node_ord: EntityList,\n}\n\nimpl AuxDebug for SegmentData {\n fn aux_fmt(&self, f: &mut std::fmt::Formatter<'_>, aux: &Synthesis) -> std::fmt::Result {\n let mut b = f.debug_struct(\"SegmentData\");\n b.field(\"head\", &self.head);\n b.field(\"in_args\", &AuxImpl(&self.in_args, &aux.instance_pool));\n b.field(\"externals\", &AuxImpl(&self.externals, &aux.instance_pool));\n b.field(\"instances\", &AuxImpl(&self.instances, &aux.instance_pool));\n b.field(\"body\", &AuxImpl(&self.body, aux));\n b.field(\"chains\", &AuxImpl(&self.chains, &aux.chain_set_pool));\n b.field(\"node_ord\", &AuxImpl(&self.node_ord, &aux.instance_pool));\n b.finish()\n }\n}\n\n#[derive(Debug)]\npub enum SegmentHeadKind {\n /// The entry point of a chain.\n /// There must be exactly one of these for each chain.\n /// The arity of this block is always the same as on the original entry\n /// block.\n ///\n /// This will:\n /// 1. Create a new block\n /// 2. Add arguments matching arity of orignal entry\n /// 3. Insert mapping \"old entry => this (new entry)\"\n Entry { chain: Chain },\n\n /// An intermediate block in the synthesized CFG.\n /// This can be reached from any number of chains.\n ///\n /// This will:\n /// 1. Create a new block\n /// 2. Create `in_args` on block\n Intermediate,\n}\n\nimpl SegmentHeadKind {\n pub fn is_intermediate(&self) -> bool {\n match self {\n SegmentHeadKind::Intermediate => true,\n _ => false,\n }\n }\n}\n\n#[derive(Debug)]\npub enum SegmentBodyKind {\n /// Not populated\n None,\n\n /// This will call an intermediate block in the synthesized CFG.\n ///\n /// This will:\n /// 1. Create a control flow call within the selected block with `out_args`\n /// as arguments.\n ToIntermediate {\n to: Segment,\n out_args: EntityList,\n },\n\n /// This will specialize the target block into the selected block.\n ///\n /// Specialization will occur with the full local scope. All root value\n /// nodes must be in the local scope for this to be valid.\n ///\n /// Note: Specialization will ONLY happen on the operation within the target\n /// block. This needs to be taken into account by the synthesis strategy, as\n /// incorrect IR will be generated if any successor blocks attempt to access\n /// instances that are not\n Terminal {\n /// There can only ever exist a single segment with `single: true`.\n ///\n /// * If this is true, all result mappings from this will be applied\n /// globally. This is the general and safe mode. This usually means\n /// there will only be a single target segment.\n ///\n /// A notable exception to this is having one `single: true` segment\n /// and one or more `single: false` segments. This can be valid in\n /// very specific cases.\n /// \n /// * If this is false, no result mappings are applied globally, only\n /// when specializing the target operation.\n ///\n /// This is a useful mode when no values from the chain are accessed\n /// in successors of the target block. A trivial example of this is\n /// when a return call is performed in the target block.\n single: bool,\n },\n}\n\nimpl AuxDebug for SegmentBodyKind {\n fn aux_fmt(&self, f: &mut std::fmt::Formatter<'_>, aux: &Synthesis) -> std::fmt::Result {\n match self {\n SegmentBodyKind::None => f.debug_struct(\"None\").finish(),\n SegmentBodyKind::ToIntermediate { to, out_args } => {\n let mut b = f.debug_struct(\"ToIntermediate\");\n b.field(\"to\", to);\n b.field(\"out_args\", &AuxImpl(out_args, &aux.instance_pool));\n b.finish()\n }\n SegmentBodyKind::Terminal { single } => {\n let mut b = f.debug_struct(\"Terminal\");\n b.field(\"single\", single);\n b.finish()\n }\n }\n }\n}\n\nimpl SegmentBodyKind {\n pub fn is_none(&self) -> bool {\n match self {\n SegmentBodyKind::None => true,\n _ => false,\n }\n }\n}\n\npub trait SynthesisStrategy {\n /// If the strategy is compatible with the given graph, returns the\n /// synthesized CFG.\n fn try_run(&self, graph: &ChainGraph, fun: &Function, live: &LiveValues) -> Option;\n}\n" }, { "path": "libeir_passes/src/simplify_cfg/chain_graph/synthesis/simple.rs", "content": "use log::trace;\n\nuse std::collections::BTreeSet;\n\nuse cranelift_entity::EntityList;\nuse libeir_ir::{Function, LiveValues};\nuse libeir_util_datastructures::pooled_entity_set::EntitySet;\n\nuse super::super::{ChainGraph, NodeKind};\nuse super::{SegmentHeadKind, Synthesis, SynthesisStrategy};\nuse crate::util::Walker;\n\n/// A dead simple synthesis strategy. Works in every case.\n/// All nodes before the first phi will be specialized.\n///\n/// Will always generate CFGs of this form:\n///\n/// Entry1 Entry2 Entry3\n/// | | |\n/// --------| | |--------\n/// v v v\n/// Target\npub struct SimpleStrategy;\n\nimpl SynthesisStrategy for SimpleStrategy {\n fn try_run(\n &self,\n graph: &ChainGraph,\n _fun: &Function,\n _live: &LiveValues,\n ) -> Option {\n trace!(\"SIMPLE STRATEGY\");\n\n let mut synthesis = Synthesis::new();\n\n let mut visited_set = BTreeSet::new();\n let mut before_ord = EntityList::new();\n let mut border_set = BTreeSet::new();\n\n // Walk and find all nodes we schedule in the target block, along with\n // the set of nodes that need actual phi nodes/call arguments.\n let mut walker = Walker::with(graph.entry_edges.values().cloned().collect());\n while let Some(node) = walker.next() {\n let node_data = &graph.nodes[node];\n visited_set.insert(node);\n before_ord.push(node, &mut synthesis.node_pool);\n if node_data.is_phi() {\n border_set.insert(node);\n } else {\n for dep in node_data.dependencies() {\n walker.put(dep);\n }\n }\n }\n\n let out_segment = synthesis.create_intermediate_segment();\n {\n let mut osb = synthesis.segment(out_segment);\n\n // The border set are the arguments on the new target block\n for arg in border_set.iter() {\n osb.push_in_arg(*arg);\n }\n\n // Create the root values in the block\n for target in graph.entry_edges.values() {\n osb.push_instance(*target);\n }\n\n // This is the single target block, full mappings\n osb.finish_target(true);\n\n // Order doesn't matter, strategy doesn't use externals\n synthesis.visit_segment(out_segment);\n }\n\n for (chain, _chain_data) in graph.chains.iter() {\n let segment = synthesis.create_entry_segment(chain, graph);\n\n let mut sb = synthesis.segment(segment);\n for out in border_set.iter() {\n let instance = sb.push_instance(*out);\n sb.push_out_arg(instance);\n }\n\n sb.finish_to(out_segment);\n\n synthesis.visit_segment(segment);\n }\n\n Some(synthesis)\n }\n}\n" }, { "path": "libeir_passes/src/simplify_cfg/chain_graph/synthesis/single.rs", "content": "use super::super::{Chain, ChainGraph};\nuse super::{Synthesis, SynthesisStrategy};\nuse libeir_ir::{Function, LiveValues};\n\npub fn can_subsitute(graph: &ChainGraph, fun: &Function, chain: Chain) -> bool {\n let target = graph.target_block;\n let target_reads = fun.block_reads(target);\n let chain_data = &graph.chains[chain];\n\n if fun.block_kind(target).unwrap().is_call() && chain_data.args.len() == target_reads.len() - 1\n {\n chain_data\n .args\n .iter()\n .zip(target_reads.iter().skip(1))\n .map(|(ch, val)| -> Option<()> {\n let ch = (*ch)?;\n\n let node;\n if let Some(to) = graph.get_uniform(*val) {\n node = to;\n } else {\n let start_node = graph.get_root(*val)?;\n node = graph.follow_chain(start_node, chain);\n }\n\n if node == ch {\n Some(())\n } else {\n None\n }\n })\n .all(|v| v.is_some())\n } else {\n false\n }\n}\n\n/// A synthesis strategy that only handles the case of a single entry.\n/// This will inline the destination into the entry.\n///\n/// Entry:\n/// Target OP\n///\npub struct SingleStrategy;\n\nimpl SynthesisStrategy for SingleStrategy {\n fn try_run(&self, graph: &ChainGraph, fun: &Function, _live: &LiveValues) -> Option {\n if graph.chains.len() != 1 {\n return None;\n }\n let chain = graph.chains.keys().next().unwrap();\n\n let mut synthesis = Synthesis::new();\n\n let target = graph.target_block;\n let target_reads = fun.block_reads(target);\n\n if can_subsitute(graph, fun, chain) {\n // If the operation in the target is a call, and all arguments passed to\n // the call are equal to the entry edge, we can do a simple\n // substitution.\n\n synthesis.substitute(chain, target_reads[0]);\n } else {\n let segment = synthesis.create_entry_segment(chain, graph);\n let mut sb = synthesis.segment(segment);\n\n for target in graph.entry_edges.values() {\n sb.push_instance(*target);\n }\n\n sb.finish_target(true);\n\n synthesis.visit_segment(segment);\n }\n\n Some(synthesis)\n }\n}\n" }, { "path": "libeir_passes/src/simplify_cfg/chain_graph/synthesis/terminating_target.rs", "content": "use log::trace;\n\nuse libeir_ir::{Function, LiveValues};\n\nuse super::super::ChainGraph;\nuse super::single::can_subsitute;\nuse super::{Synthesis, SynthesisStrategy};\n\n/// A synthesis strategy that specializes the target into every entry.\n/// This is only valid for target blocks that terminate/don't use any values\n/// from the chain.\n///\n/// Entry1: Entry2:\n/// Target OP Target OP\n/// \npub struct TerminatingTargetStrategy;\n\nimpl SynthesisStrategy for TerminatingTargetStrategy {\n fn try_run(&self, graph: &ChainGraph, fun: &Function, live: &LiveValues) -> Option {\n // TODO change this to check outgoing values instead\n\n let target = graph.target_block;\n let target_reads = fun.block_reads(target);\n\n // This strategy can only be run if NONE of the values defined\n // conditionally in the graph are used outside of the target block.\n // We validate this by going through all outgoing edges, and checking\n // that none of the graph entry edges are live at those block heads.\n let bg = fun.block_graph();\n for outgoing in bg.outgoing(target) {\n for val in live.live_at(outgoing).iter() {\n if graph.entry_edges.contains_key(&val) {\n return None;\n }\n }\n }\n\n // If the body has no reads from the chain, specialization is useless,\n // don't do it.\n fun.block_walk_nested_values::<_, ()>(target, &mut |val| {\n if graph.entry_edges.contains_key(&val) {\n Err(())\n } else {\n Ok(())\n }\n })\n .err()?;\n\n trace!(\"TERMINATING TARGET STRATEGY\");\n\n let mut synthesis = Synthesis::new();\n\n for chain in graph.chains.keys() {\n if can_subsitute(graph, fun, chain) {\n synthesis.substitute(chain, target_reads[0]);\n } else {\n let segment = synthesis.create_entry_segment(chain, graph);\n let mut sb = synthesis.segment(segment);\n\n for target in graph.entry_edges.values() {\n sb.push_instance(*target);\n }\n\n sb.finish_target(false);\n\n synthesis.visit_segment(segment);\n }\n }\n\n Some(synthesis)\n }\n}\n" }, { "path": "libeir_passes/src/simplify_cfg/mod.rs", "content": "#![warn(warnings)]\n\nuse std::collections::BTreeMap;\n\nuse log::{debug, trace};\n\nuse bumpalo::Bump;\nuse fnv::FnvBuildHasher;\nuse hashbrown::HashMap;\ntype BFnvHashMap<'bump, K, V> = HashMap;\n\nuse libeir_ir::Value;\nuse libeir_ir::{FunctionBuilder, MangleTo, Mangler, StandardFormatConfig};\n\nuse super::FunctionPass;\n\nmod analyze;\nmod chain_graph;\nmod rewrite;\n\nuse chain_graph::synthesis::SynthesisStrategy;\n\n#[cfg(test)]\nmod tests;\n\n/// This pass is a powerful cleanup pass, it will do the following:\n/// - Inline closures\n/// - Remove needless call chains\npub struct SimplifyCfgPass {\n map: BTreeMap,\n\n mangler: Mangler,\n\n bump: Option,\n}\n\n// Observations about the pass:\n// * A call to a block can serve \"two purposes\" from the point of view of this pass.\n// 1. A temporary rename within the call chain we are operating on. We don't really\n// care about the value in this case, it can be removed.\n// 2. A bind that blocks in the scope of the target block use. In this case we need\n// to make sure the value is always bound to a singular value that the code after\n// uses.\n// 3. Both. Needs to be handled exactly the same as 2.\n//\n//\n// The functionality of the pass (rewriting call chains), operates as follows:\n// 1. CFG analysis:\n// Locates subgraphs of the CFG that are call chains.\n// These call chains can take one of two forms:\n// * A cyclic graph:\n// This call chain ends in a cycle. This means there is a cycle without\n// control flow or side effects. Any entry edges to the call chain should\n// be rewritten to a call to a operation that sleeps the process forever.\n// * A tree:\n// This is a normal call chain ending in a single target block.\n//\n// The algorithm proceeds as follows for each tree:\n// 1. Value rename analysis:\n// Each edge in a call chain can have any number of value renames.\n// These form a set of conceptual \"phi nodes\",\n// `phi_map: Map>`.\n// 2. Let target_live be the live value set of the target block\n// 3. Generate rename map:\n// Repeat until stable:\n// * For every key k in the union between phi_nodes and target_live:\n// * For every entry (_, v) in the target set:\n// * If v is in phi_nodes:\n// * Add the entries of v to the entries in k\n// 4. Rewrite target:\n// Let there be two variables, call_target and call_args\n// * If the body of the target block is a call to a value\n// and\n// the set of args in the call is equal to the live set of the target:\n// Set call_target to the value of the call, and call_args to the args.\n// * Else:\n// Insert a new block with n arguments\n// where n is the number of elements in the rename map\n// Insert renames for the args into the mangler\n// Set call_target to the new block, and call_args to the elements in the\n// rename map\n// Copy target body to the new block\n// 5. Rewrite calls\n// * If:\n// * The call target is a value\n// * and for every read in the call that is a block, none of the phi\n// values for the chain are live in that block\n// Then:\n// * Replace any callee blocks directly with the value if the sigature matches\n// * Else, replace the body of callee blocks a call to the value\n// * Else, generate a new target block with all the chain phis as arguments,\n// insert mangle mappings for those new arguments.\n// For every entry edge into the chain, clear the body of the callee and\n// generate a call to the new target block\n\nimpl SimplifyCfgPass {\n pub fn new() -> Self {\n SimplifyCfgPass {\n map: BTreeMap::new(),\n mangler: Mangler::new(),\n bump: Some(Bump::new()),\n }\n }\n}\n\nimpl FunctionPass for SimplifyCfgPass {\n fn name(&self) -> &str {\n \"simplify_cfg\"\n }\n fn run_function_pass(&mut self, b: &mut FunctionBuilder) {\n self.simplify_cfg(b);\n }\n}\n\nimpl SimplifyCfgPass {\n fn simplify_cfg(&mut self, b: &mut FunctionBuilder) {\n let mut bump = self.bump.take().unwrap();\n\n let entry = b.fun().block_entry();\n let graph = b.fun().live_block_graph();\n let live = b.fun().live_values();\n\n let block_order: Vec<_> = graph.dfs_post_order_iter().collect();\n trace!(\"BLOCK ORDER {:?}\", block_order);\n\n trace!(\"{}\", b.fun().to_text(&mut StandardFormatConfig::default()));\n\n {\n let analysis = analyze::analyze_graph(&bump, b.fun(), &graph);\n trace!(\"analysis = {:#?}\", analysis);\n trace!(\"analysis done\");\n\n for block in block_order.iter() {\n if let Some(_blocks) = analysis.trees.get(block) {\n let target = block;\n\n // Synthesize CFG for chain\n let graph = b.fun().live_block_graph();\n let chain_graph =\n analyze::analyze_chain(&bump, *target, &b.fun(), &graph, &live, &analysis);\n\n let synthesis_impl = chain_graph::synthesis::compound::CompoundStrategy;\n let mut synthesis = synthesis_impl\n .try_run(&chain_graph, b.fun(), &live)\n .unwrap();\n synthesis.postprocess(&chain_graph);\n\n trace!(\"{:#?}\", synthesis);\n\n //// .. and apply it to the CFG.\n rewrite::rewrite(b, &mut self.map, *target, &chain_graph, &synthesis);\n\n trace!(\"{}\", b.fun().to_text_standard());\n }\n }\n\n trace!(\"rewrite done\");\n\n self.mangler.start(MangleTo(entry));\n for (from, to) in self.map.iter() {\n self.mangler.add_rename(MangleTo(*from), MangleTo(*to));\n }\n\n let new_entry = self.mangler.run(b);\n b.block_set_entry(new_entry);\n\n trace!(\"{}\", b.fun().to_text_standard());\n }\n\n self.map.clear();\n bump.reset();\n self.bump = Some(bump);\n }\n}\n" }, { "path": "libeir_passes/src/simplify_cfg/rewrite.rs", "content": "use log::trace;\n\nuse std::collections::BTreeMap;\n\nuse libeir_ir::{Block, FunctionBuilder, Value};\nuse libeir_ir::{MangleTo, Mangler};\n\nuse libeir_util_datastructures::aux_traits::AuxImpl;\n\nuse super::chain_graph::{\n synthesis::{Instance, InstanceKind, SegmentBodyKind, SegmentHeadKind, Synthesis},\n Chain, ChainGraph, Node, NodeKind,\n};\n\npub fn rewrite(\n b: &mut FunctionBuilder,\n map: &mut BTreeMap,\n target: Block,\n graph: &ChainGraph,\n synthesis: &Synthesis,\n) {\n //let segment_set_pool = synthesis.segment_set_pool.as_ref().unwrap();\n //let segments_back = synthesis.segments_back.as_ref().unwrap();\n\n trace!(\"REWRITE {}\", target);\n //println!(\"{:#?}\", synthesis);\n\n //assert!(synthesis.segments[synthesis.order[0]].kind.is_out());\n //assert!(\n // synthesis\n // .order\n // .iter()\n // .map(|s| &synthesis.segments[*s])\n // .filter(|s| s.kind.is_out())\n // .count() == 1\n //);\n\n let mut segment_map = BTreeMap::new();\n\n let mut global_map: BTreeMap = BTreeMap::new();\n let mut local_map: BTreeMap = BTreeMap::new();\n\n let mut entry_map: BTreeMap<(Chain, usize), Value> = BTreeMap::new();\n\n let mut arg_buf = Vec::new();\n\n let mut walker = crate::util::Walker::new();\n\n let mut mangler = Mangler::new();\n\n for (chain, to_value) in synthesis.substitutions.iter() {\n let chain_entry = graph.get_chain_entry_block(*chain);\n let from_value = b.value(chain_entry);\n map.insert(from_value, *to_value);\n }\n\n let loc = b.fun().block_location(target);\n\n for segment_id in synthesis.order.iter() {\n let segment = &synthesis.segments[*segment_id];\n\n let block = b.block_insert();\n b.block_set_location(block, loc);\n segment_map.insert(*segment_id, block);\n\n match segment.head {\n SegmentHeadKind::Entry { chain } => {\n let in_args = segment.in_args.as_slice(&synthesis.instance_pool);\n for (idx, in_arg) in in_args.iter().enumerate() {\n let instance = &synthesis.instances[*in_arg];\n\n let key = (chain, idx);\n\n let arg = b.block_arg_insert(block);\n assert!(!entry_map.contains_key(&key));\n entry_map.insert(key, arg);\n\n global_map.insert(*in_arg, arg);\n\n if instance.is_relevant() {\n let node = instance.node();\n let node_kind = graph.node(node);\n\n match node_kind {\n NodeKind::EntryArg(entry_arg) => {\n assert!(entry_arg.chain == chain);\n assert!(entry_arg.arg_index == idx);\n }\n _ => unreachable!(),\n }\n }\n }\n }\n SegmentHeadKind::Intermediate => {}\n }\n }\n\n trace!(\"ENTRY MAP {:?}\", entry_map);\n\n for (from, to) in graph.iter_uniform_mappings() {\n let to_kind = graph.node(to);\n match to_kind {\n NodeKind::Scope(value) => {\n trace!(\"Uniform mapping: {} -> {} ({})\", from, to, value);\n map.insert(from, *value);\n }\n NodeKind::EntryArg(entry_arg) => {\n if synthesis.substitutions.contains_key(&entry_arg.chain) {\n continue;\n }\n\n let key = (entry_arg.chain, entry_arg.arg_index);\n trace!(\"Entry {:?}\", key);\n let to_value = entry_map[&key];\n trace!(\"Uniform mapping: {} -> {} ({})\", from, to, to_value);\n map.insert(from, to_value);\n }\n _ => unreachable!(),\n }\n }\n\n for segment_id in synthesis.order.iter() {\n local_map.clear();\n\n let segment = &synthesis.segments[*segment_id];\n let segment_chains = segment.chains.bind(&synthesis.chain_set_pool);\n let all_chains = segment_chains.size() == graph.chain_count();\n trace!(\"SEGMENT {} {:?}\", segment_id, AuxImpl(segment, synthesis));\n\n let block = segment_map[segment_id];\n let block_val = b.value(block);\n\n let in_args = segment.in_args.as_slice(&synthesis.instance_pool);\n trace!(\"IN ARGS {:?}\", in_args);\n\n match segment.head {\n SegmentHeadKind::Entry { chain } => {\n let old_block = graph.get_chain_entry_block(chain);\n let old_block_val = b.value(old_block);\n\n assert!(!map.contains_key(&old_block_val));\n map.insert(old_block_val, block_val);\n\n for (idx, in_arg) in in_args.iter().enumerate() {\n let key = (chain, idx);\n let instance = &synthesis.instances[*in_arg];\n\n match instance {\n InstanceKind::NotRelevant => (), // TODO\n InstanceKind::Arg { node, .. } => {\n let node = instance.node();\n let arg = entry_map[&key];\n\n global_map.insert(*in_arg, arg);\n local_map.insert(node, arg);\n }\n _ => unreachable!(),\n }\n }\n }\n SegmentHeadKind::Intermediate => {\n for (idx, in_arg) in in_args.iter().enumerate() {\n let instance = &synthesis.instances[*in_arg];\n\n let arg = b.block_arg_insert(block);\n\n match instance {\n InstanceKind::NotRelevant => (), // TODO\n InstanceKind::Arg { node, .. } => {\n let node = instance.node();\n\n global_map.insert(*in_arg, arg);\n local_map.insert(node, arg);\n }\n _ => unreachable!(),\n }\n }\n }\n }\n\n for external in segment.externals.as_slice(&synthesis.instance_pool) {\n let val = global_map[external];\n let instance = &synthesis.instances[*external];\n local_map.insert(instance.node(), val);\n }\n\n walker.clear();\n for instance_id in segment.instances.as_slice(&synthesis.instance_pool) {\n let instance = &synthesis.instances[*instance_id];\n walker.put(instance.node());\n }\n\n let mut order: Vec = Vec::new();\n while let Some(node_id) = walker.next() {\n if local_map.contains_key(&node_id) {\n continue;\n }\n order.push(node_id);\n\n let node = graph.node(node_id);\n\n match node {\n NodeKind::Phi(phi) => {\n let mut pred_node = None;\n for (chain, n_pred_node) in phi.entries.iter() {\n if segment_chains.contains(*chain) {\n if let Some(old_pred_node) = pred_node {\n assert!(*n_pred_node == old_pred_node);\n }\n pred_node = Some(*n_pred_node);\n }\n }\n if let Some(pred_node) = pred_node {\n walker.put(pred_node);\n }\n }\n _ => {\n for pred_node in graph.node(node_id).dependencies() {\n walker.put(pred_node);\n }\n }\n }\n }\n\n trace!(\"ORDER {:?}\", order);\n\n for node_id in order.iter().rev() {\n match graph.node(*node_id) {\n NodeKind::Scope(value) => {\n local_map.insert(*node_id, *value);\n }\n NodeKind::EntryArg(entry_arg) => {\n assert!(local_map.contains_key(node_id));\n //let key = (entry_arg.chain, entry_arg.arg_index);\n //if !local_map.contains_key(node_id) {\n // let new_entry_arg = entry_map[&key];\n // local_map.insert(*node_id, new_entry_arg);\n //}\n }\n NodeKind::Phi(phi) => {\n trace!(\"PHI {:#?}, {:?}\", phi, segment_chains);\n\n if let Some(select_node) = phi\n .entries\n .iter()\n .find(|(chain, _node)| segment_chains.contains(**chain))\n .map(|(_chain, node)| *node)\n {\n let from_value = local_map[&select_node];\n local_map.insert(*node_id, from_value);\n } else {\n unreachable!()\n //let from_value = phi.value.unwrap();\n //local_map.insert(*node_id, from_value);\n }\n }\n NodeKind::Prim(prim) => {\n let mut map_value = |val| -> Option {\n let node = prim.dependencies.get(&val);\n node.map(|node| local_map[node])\n };\n let new_prim = b.value_map(prim.prim, &mut map_value);\n local_map.insert(*node_id, new_prim);\n }\n NodeKind::BlockCapture(bc) => {\n let capture;\n if all_chains || bc.dependencies.len() == 0 {\n for (from_val, to_node) in bc.dependencies.iter() {\n let to_val = local_map[to_node];\n map.insert(*from_val, to_val);\n }\n capture = bc.capture;\n } else {\n mangler.start(MangleTo(bc.capture));\n for (from_val, to_node) in bc.dependencies.iter() {\n let to_val = local_map[to_node];\n mangler.add_rename(MangleTo(*from_val), MangleTo(to_val));\n }\n trace!(\"blockcapturemangle!\");\n capture = mangler.run(b);\n }\n let capture_val = b.value(capture);\n local_map.insert(*node_id, capture_val);\n }\n }\n }\n\n for instance_id in segment.instances.as_slice(&synthesis.instance_pool) {\n let instance = &synthesis.instances[*instance_id];\n global_map.insert(*instance_id, local_map[&instance.node()]);\n }\n\n match &segment.body {\n SegmentBodyKind::None => unreachable!(),\n SegmentBodyKind::Terminal { single: true } => {\n let mut map_value = |val| -> Option {\n let node = graph.get_root(val);\n node.map(|node| local_map[&node])\n };\n b.block_copy_body_map(target, block, &mut map_value);\n\n for (root_val, root_node) in graph.iter_roots() {\n let to_val = local_map[&root_node];\n map.insert(root_val, to_val);\n }\n }\n SegmentBodyKind::Terminal { single: false } => {\n let mut map_value = |val| -> Option {\n let node = graph.get_root(val);\n node.map(|node| local_map[&node])\n };\n b.block_copy_body_map(target, block, &mut map_value);\n }\n SegmentBodyKind::ToIntermediate { to, out_args } => {\n let to_block = segment_map[to];\n\n arg_buf.clear();\n for instance_id in out_args.as_slice(&synthesis.instance_pool) {\n arg_buf.push(global_map[instance_id]);\n }\n\n b.op_call_flow(block, to_block, &arg_buf);\n }\n }\n }\n}\n" }, { "path": "libeir_passes/src/simplify_cfg/tests.rs", "content": "use super::SimplifyCfgPass;\nuse crate::FunctionPass;\n\nuse libeir_ir::{parse_function_map_unwrap, parse_function_unwrap, StandardFormatConfig};\n\n#[test]\nfn primop_in_chain() {\n let _ = env_logger::try_init();\n\n let mut fun = parse_function_unwrap(\n \"\na'foo':a'bar'/1 {\n entry(%ret, %thr, %a):\n b2(%a);\n b2(%b):\n %prim = {%b};\n b3(%prim);\n b3(%c):\n %ret(%c);\n}\n\",\n );\n let mut b = fun.builder();\n\n let mut simplify_cfg_pass = SimplifyCfgPass::new();\n simplify_cfg_pass.run_function_pass(&mut b);\n\n let after = parse_function_unwrap(\n \"\na'foo':a'bar'/1 {\n entry(%ret, %thr, %a):\n %ret({%a});\n}\n\",\n );\n\n assert!(b\n .fun()\n .graph_eq(b.fun().block_entry(), &after, after.block_entry())\n .is_ok());\n}\n\n#[test]\nfn double_primop_in_chain() {\n let _ = env_logger::try_init();\n\n let mut fun = parse_function_unwrap(\n \"\na'foo':a'bar'/1 {\n entry(%ret, %thr, %a):\n b2(%a);\n b2(%b):\n b3({%b});\n b3(%c):\n b4({%c});\n b4(%d):\n %ret(%d);\n}\n\",\n );\n let mut b = fun.builder();\n\n let mut simplify_cfg_pass = SimplifyCfgPass::new();\n simplify_cfg_pass.run_function_pass(&mut b);\n\n let after = parse_function_unwrap(\n \"\na'foo':a'bar'/1 {\n entry(%ret, %thr, %a):\n %ret({{%a}});\n}\n\",\n );\n\n assert!(b\n .fun()\n .graph_eq(b.fun().block_entry(), &after, after.block_entry())\n .is_ok());\n}\n\n#[test]\nfn split_primop_in_chain() {\n let _ = env_logger::try_init();\n\n let mut fun = parse_function_unwrap(\n \"\na'foo':a'bar'/3 {\n entry(%ret, %thr, %a, %b, %c):\n if_bool %a b_true b_false;\n\n b_true():\n b_true1(%b);\n b_true1(%bb):\n b_join({%bb});\n\n b_false():\n b_false1(%c);\n b_false1(%cc):\n b_join({%cc});\n\n b_join(%d):\n b_join1({%d});\n b_join1(%dd):\n %ret(%dd);\n}\n\",\n );\n let mut b = fun.builder();\n\n let mut simplify_cfg_pass = SimplifyCfgPass::new();\n simplify_cfg_pass.run_function_pass(&mut b);\n\n let after = parse_function_unwrap(\n \"\na'foo':a'bar'/3 {\n entry(%ret, %thr, %a, %b, %c):\n if_bool %a b_true b_false;\n b_true():\n %ret({{%b}});\n b_false():\n %ret({{%c}});\n}\n\",\n );\n\n assert!(b\n .fun()\n .graph_eq(b.fun().block_entry(), &after, after.block_entry())\n .is_ok());\n}\n\n#[test]\nfn two_split_primop_in_chain() {\n let _ = env_logger::try_init();\n\n let mut fun = parse_function_unwrap(\n \"\na'foo':a'bar'/5 {\n entry(%ret, %thr, %a, %b, %c, %B, %C):\n if_bool %a b_true b_false;\n\n b_true():\n b_true1(%b, %B);\n b_true1(%bb, %BB):\n b_join({{%bb}, %BB}, {%BB});\n\n b_false():\n b_false1(%c, %C);\n b_false1(%cc, %CC):\n b_join({%cc}, {%CC});\n\n b_join(%d, %e):\n b_join1({%d}, {%e});\n b_join1(%dd, %ee):\n %ret({%dd, %ee});\n}\n\",\n );\n let mut b = fun.builder();\n\n let mut simplify_cfg_pass = SimplifyCfgPass::new();\n simplify_cfg_pass.run_function_pass(&mut b);\n\n let after = parse_function_unwrap(\n \"\na'foo':a'bar'/5 {\n entry(%ret, %thr, %a, %b, %c, %B, %C):\n if_bool %a b_true b_false;\n b_true():\n %ret({{{{%b}, %B}}, {{%B}}});\n b_false():\n %ret({{{%c}}, {{%C}}});\n}\n\",\n );\n\n assert!(b\n .fun()\n .graph_eq(b.fun().block_entry(), &after, after.block_entry())\n .is_ok());\n}\n\n#[test]\nfn simple_tail_call_elimination() {\n let _ = env_logger::try_init();\n\n let mut fun = parse_function_unwrap(\n \"\na'foo':a'bar'/0 {\n entry(%ret, %thr):\n a'foo':a'foo'/0(b2, b3);\n b2(%ret_arg):\n %ret(%ret_arg);\n b3(%thr_a, %thr_b, %thr_c):\n %thr(%thr_a, %thr_b, %thr_c);\n}\n\",\n );\n let mut b = fun.builder();\n\n let mut simplify_cfg_pass = SimplifyCfgPass::new();\n simplify_cfg_pass.run_function_pass(&mut b);\n\n let after = parse_function_unwrap(\n \"\na'foo':a'bar'/0 {\n entry(%ret, %thr):\n a'foo':a'foo'/0(%ret, %thr);\n}\n\",\n );\n\n assert!(b\n .fun()\n .graph_eq(b.fun().block_entry(), &after, after.block_entry())\n .is_ok());\n}\n\n#[test]\nfn tail_call_elimination() {\n let _ = env_logger::try_init();\n\n let mut fun = parse_function_unwrap(\n \"\na'foo':a'bar'/0 {\n entry(%ret, %thr):\n b1(a'foo':a'foo'/0);\n b1(%fun):\n %fun(b2, b3);\n b2(%ret_arg):\n %ret(%ret_arg);\n b3(%thr_a, %thr_b, %thr_c):\n %thr(%thr_a, %thr_b, %thr_c);\n}\n\",\n );\n let mut b = fun.builder();\n\n let mut simplify_cfg_pass = SimplifyCfgPass::new();\n simplify_cfg_pass.run_function_pass(&mut b);\n\n let after = parse_function_unwrap(\n \"\na'foo':a'bar'/0 {\n entry(%ret, %thr):\n a'foo':a'foo'/0(%ret, %thr);\n}\n\",\n );\n\n assert!(b\n .fun()\n .graph_eq(b.fun().block_entry(), &after, after.block_entry())\n .is_ok());\n}\n\n#[test]\nfn recursive_simplification() {\n let _ = env_logger::try_init();\n\n let mut fun = parse_function_unwrap(\n \"\na'foo':a'bar'/0 {\n entry(%ret, %thr):\n b(a'true');\n b(%sec):\n if_bool %sec b_true b_false;\n b_false():\n unreachable;\n b_true():\n %ret(a'yay');\n}\n\",\n );\n let mut b = fun.builder();\n\n let mut simplify_cfg_pass = SimplifyCfgPass::new();\n simplify_cfg_pass.run_function_pass(&mut b);\n\n let after = parse_function_unwrap(\n \"\na'foo':a'bar'/0 {\n entry(%ret, %thr):\n %ret(a'yay');\n}\n\",\n );\n\n assert!(b\n .fun()\n .graph_eq(b.fun().block_entry(), &after, after.block_entry())\n .is_ok());\n}\n\n#[test]\nfn value_list_removal() {\n let _ = env_logger::try_init();\n\n let mut fun = parse_function_unwrap(\n \"\na'foo':a'bar'/2 {\n entry(%ret, %thr, %a, %b):\n unpack <%a, %b> arity 2 => cont;\n cont(%aa, %bb):\n %ret(%aa);\n}\n\",\n );\n let mut b = fun.builder();\n\n let mut simplify_cfg_pass = SimplifyCfgPass::new();\n simplify_cfg_pass.run_function_pass(&mut b);\n\n let after = parse_function_unwrap(\n \"\na'foo':a'bar'/2 {\n entry(%ret, %thr, %a, %b):\n %ret(%a);\n}\n\",\n );\n\n assert!(b\n .fun()\n .graph_eq(b.fun().block_entry(), &after, after.block_entry())\n .is_ok());\n}\n\n#[test]\nfn partial_loop() {\n let _ = env_logger::try_init();\n\n let mut fun = parse_function_unwrap(\n \"\na'foo':a'bar'/1 {\n block1(%3, %4, %5):\n block8(%5, []);\n block8(%30, %31):\n match %30 {\n [] => block11;\n };\n block11(%36, %37):\n block28(%36);\n block28(%81):\n block17(%81);\n block17(%53):\n %54 = [%53 | %31];\n block8(%37, %54);\n}\n\",\n );\n let mut b = fun.builder();\n\n let mut simplify_cfg_pass = SimplifyCfgPass::new();\n simplify_cfg_pass.run_function_pass(&mut b);\n\n let after = parse_function_unwrap(\n \"\na'foo':a'bar'/1 {\n block1(%3, %4, %5):\n block8(%5, []);\n block8(%30, %31):\n match %30 {\n [] => block11;\n };\n block11(%36, %37):\n %54 = [%36 | %31];\n block8(%37, %54);\n}\n\",\n );\n assert!(b\n .fun()\n .graph_eq(b.fun().block_entry(), &after, after.block_entry())\n .is_ok());\n}\n\n#[test]\nfn tight_partial_loop() {\n let _ = env_logger::try_init();\n\n let mut fun = parse_function_unwrap(\n \"\na'foo':a'perms'/1 {\n block0(%1, %2, %3):\n block1(%3, []);\n block1(%5, %6):\n block2();\n block2():\n match %5 {\n [] => block3;\n };\n block3(%9, %10):\n %14 = [%9 | %6];\n block1(%10, %14);\n}\n\",\n );\n let mut b = fun.builder();\n\n let mut simplify_cfg_pass = SimplifyCfgPass::new();\n simplify_cfg_pass.run_function_pass(&mut b);\n\n // let after = parse_function_unwrap(\"\n //a'foo':a'perms'/1 {\n // block0(%1, %2, %3):\n // block1(%3, []);\n // block1(%5, %6):\n // match %5 {\n // [] => block3;\n // };\n // block3(%9, %10):\n // %14 = [%9 | %6];\n // block1(%10, %14);\n //}\n //\");\n let after = parse_function_unwrap(\n \"\na'foo':a'perms'/1 {\n block0(%1, %2, %3):\n block1(%3, []);\n block1(%5, %6):\n match %5 {\n [] => block3;\n };\n block3(%9, %10):\n %14 = [%9 | %6];\n block1(%10, %14);\n}\n\",\n );\n assert!(b\n .fun()\n .graph_eq(b.fun().block_entry(), &after, after.block_entry())\n .is_ok());\n}\n\n#[test]\nfn deep_primop_rename_single_branch() {\n let _ = env_logger::try_init();\n\n let mut fun = parse_function_unwrap(\n \"\na'foo':a'do_map_vars_used'/1 {\n block0(%1, %2, %3):\n block1(%3);\n block1(%5):\n block2(%5);\n block2(%7):\n %12 = {%7};\n block3(%12);\n block3(%9):\n block4(%9);\n block4(%11):\n %13 = <>;\n match %11 {};\n}\n\",\n );\n let mut b = fun.builder();\n\n let mut simplify_cfg_pass = SimplifyCfgPass::new();\n simplify_cfg_pass.run_function_pass(&mut b);\n\n let after = parse_function_unwrap(\n \"\na'foo':a'do_map_vars_used'/1 {\n entry(%1, %2, %3):\n %4 = {%3};\n match %4 {};\n}\n\",\n );\n assert!(b\n .fun()\n .graph_eq(b.fun().block_entry(), &after, after.block_entry())\n .is_ok());\n}\n\n#[test]\nfn deep_primop_rename_after_entry_single_branch() {\n let _ = env_logger::try_init();\n\n let mut fun = parse_function_unwrap(\n \"\na'foo':a'do_map_vars_used'/1 {\n block0(%1, %2, %3):\n block1(%3);\n block1(%5):\n block2(%5);\n block2(%7):\n %15 = {%7};\n block3(%15);\n block3(%9):\n block4(%9);\n block4(%11):\n %18 = ;\n %16 = <>;\n match [] {\n type %{} => block5;\n };\n block5():\n %19 = ;\n match [] {\n %{ %11} => block6;\n };\n block6(%14):\n unreachable;\n}\n\",\n );\n let mut b = fun.builder();\n\n let mut simplify_cfg_pass = SimplifyCfgPass::new();\n simplify_cfg_pass.run_function_pass(&mut b);\n\n let after = parse_function_unwrap(\n \"\na'foo':a'do_map_vars_used'/1 {\n entry(%1, %2, %3):\n match [] {\n type %{} => block1;\n };\n block1():\n %4 = {%3};\n match [] {\n %{%4} => block2;\n };\n block2(%5):\n unreachable;\n}\n\",\n );\n assert!(b\n .fun()\n .graph_eq(b.fun().block_entry(), &after, after.block_entry())\n .is_ok());\n}\n\n#[test]\nfn converging_from_single() {\n let _ = env_logger::try_init();\n\n let mut fun = parse_function_unwrap(\n \"\na'fib':a'fib'/1 {\n block21(%77, %78, %114):\n %64 = a'erlang':a'<'/2;\n %64(%114, 2) => block36 except block50;\n block50(%144, %145, %146):\n block36(a'false');\n block36(%116):\n if_bool %116 block38 block39;\n block38():\n unreachable;\n block39():\n unreachable;\n}\n\",\n );\n let mut b = fun.builder();\n\n let mut simplify_cfg_pass = SimplifyCfgPass::new();\n simplify_cfg_pass.run_function_pass(&mut b);\n\n let after = parse_function_unwrap(\n \"\na'fib':a'fib'/1 {\n block8(%26, %27, %28):\n %15 = a'erlang':a'<'/2;\n %15(%28, 2) => block13 except block12;\n block13(%38):\n if_bool %38 block9 block10;\n block12(%34, %35, %36):\n if_bool a'false' block9 block10;\n block9():\n unreachable;\n block10():\n unreachable;\n}\n\",\n );\n assert!(b\n .fun()\n .graph_eq(b.fun().block_entry(), &after, after.block_entry())\n .is_ok());\n}\n\n#[test]\nfn basic_locations() {\n let _ = env_logger::try_init();\n\n let opts = libeir_ir::GraphEqOptions {\n check_block_locations: true,\n };\n\n // !location [\\\"foo\\\":\\\"foo\\\"@\\\"foo.erl\\\":1];\n\n let mut fun = parse_function_unwrap(\n \"\na'foo':a'bar'/1 {\n !location [\\\"foo\\\":\\\"foo\\\"@\\\"foo.erl\\\":1];\n entry(%ret, %thr, %a):\n b2(%a);\n !location [\\\"foo\\\":\\\"foo\\\"@\\\"foo.erl\\\":2];\n b2(%b):\n b3({%b});\n !location [\\\"foo\\\":\\\"foo\\\"@\\\"foo.erl\\\":3];\n b3(%c):\n b4({%c});\n !location [\\\"foo\\\":\\\"foo\\\"@\\\"foo.erl\\\":4];\n b4(%d):\n %ret(%d);\n}\n\",\n );\n let mut b = fun.builder();\n\n let mut simplify_cfg_pass = SimplifyCfgPass::new();\n simplify_cfg_pass.run_function_pass(&mut b);\n\n let after = parse_function_unwrap(\n \"\na'foo':a'bar'/1 {\n !location [\\\"foo\\\":\\\"foo\\\"@\\\"foo.erl\\\":4];\n entry(%ret, %thr, %a):\n %ret({{%a}});\n}\n\",\n );\n let res = b\n .fun()\n .graph_eq_opts(b.fun().block_entry(), &after, after.block_entry(), &opts);\n assert!(res.is_ok());\n}\n\n//#[test]\n//fn basic_locations() {\n// let _ = env_logger::try_init();\n//\n// let opts = libeir_ir::GraphEqOptions {\n// check_block_locations: true,\n// };\n//\n// // !location [\\\"foo\\\":\\\"foo\\\"@\\\"foo.erl\\\":1];\n//\n// let mut fun = parse_function_unwrap(\n// \"\n//a'foo':a'bar'/1 {\n// !location [\\\"foo\\\":\\\"foo\\\"@\\\"foo.erl\\\":1];\n// entry(%ret, %thr, %a):\n// b2(%a);\n// !location [\\\"foo\\\":\\\"foo\\\"@\\\"foo.erl\\\":2];\n// b2(%b):\n// b3({%b});\n// !location [\\\"foo\\\":\\\"foo\\\"@\\\"foo.erl\\\":3];\n// b3(%c):\n// b4({%c});\n// !location [\\\"foo\\\":\\\"foo\\\"@\\\"foo.erl\\\":4];\n// b4(%d):\n// %ret(%d);\n//}\n//\",\n// );\n// println!(\n// \"before: \\n {}========\",\n// fun.to_text(&mut StandardFormatConfig::default())\n// );\n// let mut b = fun.builder();\n//\n// let mut simplify_cfg_pass = SimplifyCfgPass::new();\n// simplify_cfg_pass.run_function_pass(&mut b);\n//\n// let after = parse_function_unwrap(\n// \"\n//a'foo':a'bar'/1 {\n// !location [\\\"foo\\\":\\\"foo\\\"@\\\"foo.erl\\\":4];\n// entry(%ret, %thr, %a):\n// %ret({{%a}});\n//}\n//\",\n// );\n// let res = b\n// .fun()\n// .graph_eq_opts(b.fun().block_entry(), &after, after.block_entry(), &opts);\n//\n// println!(\"{}\", b.fun().to_text(&mut StandardFormatConfig::default()));\n// println!(\"============\");\n// println!(\"{}\", after.to_text(&mut StandardFormatConfig::default()));\n//\n// println!(\"{:?}\", res);\n// assert!(res.is_ok());\n//}\n\n// Fails because of https://github.com/eirproject/eir/issues/24\n#[test]\nfn block_capture_with_scope_in_chain() {\n let _ = env_logger::try_init();\n\n let mut fun = parse_function_unwrap(\n \"\na'a':a'get_values'/1 {\n block1(%3, %4, %5):\n bn(%5);\n bn(%6):\n block7(%6);\n block7(%27):\n block58(block49);\n block58(%136):\n %3(%136);\n\n block49(%116, %117, %118):\n %47 = a'erlang':a'=:='/2;\n %47({%27, 1}, %118) => %116 except %117;\n}\n\",\n );\n let mut b = fun.builder();\n\n let mut simplify_cfg_pass = SimplifyCfgPass::new();\n simplify_cfg_pass.run_function_pass(&mut b);\n\n b.fun().live_values();\n}\n\n#[test]\nfn dynamic_ops() {\n use libeir_intern::Symbol;\n use libeir_ir::operation::binary_construct::{BinaryConstructFinish, BinaryConstructStart};\n use libeir_ir::AtomTerm;\n use libeir_ir::{Function, FunctionBuilder, FunctionIdent, StandardFormatConfig};\n\n let (mut fun, map) = parse_function_map_unwrap(\n \"\na'a':a'a'/1 {\n block1(%1, %2, %3):\n match %3 {\n value a'yay' => block2;\n };\n block2():\n block3();\n block3():\n block4(a'true');\n block4(%4):\n if_bool %4 bt bf be;\n bf():\n unreachable;\n be():\n unreachable;\n bt():\n block5();\n block5():\n unreachable;\n block6(%binref):\n unreachable;\n block7(%bin):\n unreachable;\n}\n\",\n );\n\n let mut b = FunctionBuilder::new(&mut fun);\n\n let block5 = map.get_block(\"block5\");\n let block6 = map.get_block(\"block6\");\n let block7 = map.get_block(\"block7\");\n\n b.block_clear(block5);\n BinaryConstructStart::build_target(&mut b, block5, block6);\n let bin_ref = b.block_args(block6)[0];\n\n b.block_clear(block6);\n BinaryConstructFinish::build_target(&mut b, block6, bin_ref, block7);\n\n println!(\"{}\", b.fun().to_text(&mut StandardFormatConfig::default()));\n\n let mut simplify_cfg_pass = SimplifyCfgPass::new();\n simplify_cfg_pass.run_function_pass(&mut b);\n\n println!(\"{}\", b.fun().to_text(&mut StandardFormatConfig::default()));\n\n //@binary_construct_start(block6);\n //@binary_construct_finish(block7, %binref);\n}\n\n#[test]\nfn bbbb() {\n let _ = env_logger::try_init();\n\n let mut fun = parse_function_unwrap(\n \"\na'a':a'a'/1 {\n block1(%3, %4, %5):\n block33(%5);\n block33(%101):\n unpack %101 arity 1 => block34;\n block34(%103):\n %47 = <>;\n %133 = ;\n match %103 {\n [] => block35;\n _ => block46;\n };\n block46():\n block71();\n block71():\n block47(a'true');\n block47(%125):\n if_bool %125 block49 block50 block51;\n block51():\n unreachable;\n block50():\n block3();\n block3():\n trace_capture_raw block4;\n block4(%12):\n %4(a'error', a'function_clause', %12);\n block49():\n block10(%103);\n block10(%37):\n block11(%37, []);\n block11(%39, %40):\n %41 = [] == %39;\n if_bool %41 block12 block13;\n block13():\n %47 = <>;\n %49 = ;\n match %39 {\n [] => block14;\n _ => block15;\n };\n block15():\n trace_capture_raw block16;\n block16(%51):\n %4(a'error', a'function_clause', %51);\n block14(%45, %46):\n block52(%45);\n block52(%135):\n unpack %135 arity 1 => block53;\n block53(%137):\n block69();\n block69():\n block54(a'true');\n block54(%139):\n if_bool %139 block56 block57 block58;\n block58():\n unreachable;\n block57():\n block17();\n block17():\n block11(%46, []);\n block56():\n block20(%137);\n block20(%62):\n block21(%37, %40);\n block21(%64, %65):\n %66 = [] == %64;\n if_bool %66 block22 block23;\n block23():\n %47 = <>;\n %73 = ;\n match %64 {\n [] => block24;\n _ => block25;\n };\n block25():\n trace_capture_raw block26;\n block26(%75):\n %4(a'error', a'function_clause', %75);\n block24(%70, %71):\n block59(%70);\n block59(%148):\n unpack %148 arity 1 => block60;\n block60(%150):\n block67();\n block67():\n block61(a'true');\n block61(%152):\n if_bool %152 block63 block64 block65;\n block65():\n unreachable;\n block64():\n block27();\n block27():\n block21(%71, %40);\n block63():\n block30(%150);\n block30(%86):\n %87 = [%86 | []];\n %88 = [%62 | %87];\n %89 = [%88 | %65];\n block21(%71, %89);\n block22():\n block11(%46, %65);\n block12():\n %93 = a'lists':a'reverse'/1;\n %93(%40) => block31 except block32;\n block32(%97, %98, %99):\n %4(%97, %98, %99);\n block31(%95):\n block2(%95);\n block2(%7):\n %3(%7);\n block35():\n block75();\n block75():\n block36(a'true');\n block36(%106):\n if_bool %106 block38 block39 block40;\n block40():\n unreachable;\n block39():\n block73();\n block73():\n block41(a'true');\n block41(%115):\n if_bool %115 block43 block44 block45;\n block45():\n unreachable;\n block44():\n block3();\n block43():\n block10(%103);\n block38():\n block7();\n block7():\n block2([[] | []]);\n}\n\",\n );\n\n let mut b = fun.builder();\n\n let dot = libeir_ir::text::function_to_dot(b.fun());\n println!(\"{}\", dot);\n\n let mut simplify_cfg_pass = SimplifyCfgPass::new();\n simplify_cfg_pass.run_function_pass(&mut b);\n}\n\n#[test]\nfn cccc() {\n let _ = env_logger::try_init();\n\n let mut fun = parse_function_unwrap(\n \"\na'a':a'underscore'/1 {\n block55(%154, %155, %156):\n block83(%156);\n block83(%214):\n unpack %214 arity 1 => block84;\n block84(%216):\n block138();\n block138():\n %27 = a'erlang':a'is_list'/1;\n %27(%216) => block85 except block137;\n block137(%307, %308, %309):\n block85(a'false');\n block85(%218):\n if_bool %218 block87 block88 block89;\n block89():\n unreachable;\n block88():\n block56();\n block56():\n trace_capture_raw block82;\n block82(%208):\n %155(a'error', a'function_clause', %208);\n block87():\n block58(%216);\n block58(%163):\n block90(%163);\n block90(%227):\n unpack %227 arity 1 => block91;\n block91(%229):\n %233 = <>;\n %255 = ;\n match %229 {\n [] => block92;\n value [] => block98;\n _ => block104;\n };\n block104():\n block59();\n block59():\n trace_capture_raw block80;\n block80(%202):\n %209 = {a'case_clause', %163};\n %155(a'error', %209, %202);\n block98():\n block131();\n block131():\n block99(a'true');\n block99(%246):\n if_bool %246 block101 block102 block103;\n block103():\n unreachable;\n block102():\n block59();\n block101():\n block60();\n block60():\n %51 = a'erlang':a'length'/1;\n %51(%163) => block61 except %155;\n block61(%167):\n block119(%167);\n block119(%283):\n unpack %283 arity 1 => block120;\n block120(%285):\n block129();\n block129():\n block121(a'true');\n block121(%287):\n if_bool %287 block123 block124 block125;\n block125():\n unreachable;\n block124():\n block62();\n block62():\n trace_capture_raw block78;\n block78(%197):\n %210 = {a'badmatch', %167};\n %155(a'error', %210, %197);\n block123():\n block72();\n block72():\n block71();\n block71():\n %27 = a'erlang':a'is_list'/1;\n %27(%163) => block66 except %155;\n block66(%174):\n block112(%174);\n block112(%270):\n unpack %270 arity 1 => block113;\n block113(%272):\n block127();\n block127():\n block114(a'true');\n block114(%274):\n if_bool %274 block116 block117 block118;\n block118():\n unreachable;\n block117():\n block67();\n block67():\n trace_capture_raw block70;\n block70(%181):\n %212 = {a'badmatch', %174};\n %155(a'error', %212, %181);\n block116():\n block68();\n block68():\n %154(a'ok');\n block92(%231, %232):\n block135();\n block135():\n block93(a'true');\n block93(%235):\n if_bool %235 block95 block96 block97;\n block97():\n unreachable;\n block96():\n block59();\n block95():\n block63();\n block63():\n %80 = a'erlang':a'list_to_tuple'/1;\n %80(%163) => block64 except %155;\n block64(%171):\n block105(%171);\n block105(%257):\n unpack %257 arity 1 => block106;\n block106(%259):\n block133();\n block133():\n block107(a'true');\n block107(%261):\n if_bool %261 block109 block110 block111;\n block111():\n unreachable;\n block110():\n block65();\n block65():\n trace_capture_raw block75;\n block75(%189):\n %211 = {a'badmatch', %171};\n %155(a'error', %211, %189);\n block109():\n block73();\n block73():\n block71();\n}\n\",\n );\n\n let mut b = fun.builder();\n\n let mut simplify_cfg_pass = SimplifyCfgPass::new();\n simplify_cfg_pass.run_function_pass(&mut b);\n\n let mut errs = Vec::new();\n b.fun().validate(&mut errs);\n println!(\"{:?}\", errs);\n assert!(errs.len() == 0)\n}\n\n#[test]\nfn terminating_strategy_checks_live_in_outgoing() {\n let _ = env_logger::try_init();\n\n let mut fun = parse_function_unwrap(\n r#\"\na'a':a'a'/2 {\n block1(%3, %4, %5, %6):\n if_bool %5 block16 block17;\n\n block16():\n block10(1);\n\n block17():\n block10(2);\n\n block10(%41):\n %6() => block11 except unr3;\n block11(%44):\n %3(%41);\n\n unr3(%a, %b, %c):\n unreachable;\n}\n\"#,\n );\n\n let mut b = fun.builder();\n\n let mut errs = Vec::new();\n b.fun().validate(&mut errs);\n println!(\"{:?}\", errs);\n assert!(errs.len() == 0);\n\n let mut simplify_cfg_pass = SimplifyCfgPass::new();\n simplify_cfg_pass.run_function_pass(&mut b);\n\n let mut errs = Vec::new();\n b.fun().validate(&mut errs);\n println!(\"{:?}\", errs);\n assert!(errs.len() == 0);\n}\n" }, { "path": "libeir_passes/src/util.rs", "content": "use std::collections::{BTreeMap, BTreeSet};\n\n#[derive(Debug)]\npub struct EdgeSet(pub BTreeMap);\nimpl EdgeSet {\n pub fn new() -> Self {\n Self(BTreeMap::new())\n }\n pub fn insert(&mut self, key: T, val: T) {\n self.0.insert(key, val);\n }\n pub fn propagate_edges(&mut self) {\n let froms: Vec<_> = self.0.keys().cloned().collect();\n loop {\n let mut change = false;\n\n for from in froms.iter() {\n let first = *self.0.get(from).unwrap();\n if let Some(second) = self.0.get(&first).cloned() {\n self.0.insert(*from, second);\n change = true;\n }\n }\n\n if !change {\n break;\n }\n }\n }\n}\n\npub struct Walker {\n pub walked: BTreeSet,\n pub to_walk: Vec,\n}\nimpl Walker\nwhere\n T: Ord,\n{\n pub fn new() -> Self {\n Walker::with(Vec::new())\n }\n pub fn with(to_walk: Vec) -> Self {\n Self {\n walked: BTreeSet::new(),\n to_walk,\n }\n }\n pub fn clear(&mut self) {\n self.walked.clear();\n self.to_walk.clear();\n }\n pub fn put(&mut self, t: T) {\n if !self.walked.contains(&t) {\n self.to_walk.push(t);\n }\n }\n pub fn next(&mut self) -> Option {\n while let Some(t) = self.to_walk.pop() {\n if self.walked.contains(&t) {\n continue;\n }\n return Some(t);\n }\n None\n }\n}\n" }, { "path": "libeir_passes/src/validate.rs", "content": "use super::FunctionPass;\n\nuse libeir_ir::{FunctionBuilder, ValidationError};\n\nuse log::error;\n\npub struct ValidatePass {\n err_buf: Vec,\n}\n\nimpl ValidatePass {\n pub fn new() -> Self {\n ValidatePass {\n err_buf: Vec::new(),\n }\n }\n}\n\nimpl FunctionPass for ValidatePass {\n fn name(&self) -> &str {\n \"validate\"\n }\n fn run_function_pass(&mut self, b: &mut FunctionBuilder) {\n self.err_buf.clear();\n b.fun().validate(&mut self.err_buf);\n\n for err in self.err_buf.iter() {\n error!(\"Validation pass error: {:?}\", err);\n }\n\n assert!(self.err_buf.len() == 0);\n }\n}\n" }, { "path": "libeir_syntax_core/Cargo.toml", "content": "[package]\nname = \"libeir_syntax_core\"\nversion = \"0.1.0\"\nauthors = [\"Hans Elias B. Josephsen \"]\nedition = \"2018\"\nbuild = \"build.rs\"\n\n[build-dependencies]\nlalrpop = \"0.16.3\"\n\n[dependencies]\nlibeir_ir = { path = \"../libeir_ir\" }\nlalrpop-util = \"0.16.3\"\nlazy_static = \"1.1.0\"\nregex = \"0.2.0\"\n\nnum = \"0.2\"\nnum-traits = \"0.2\"\nnum-bigint = \"0.2\"\n" }, { "path": "libeir_syntax_core/build.rs", "content": "//extern crate peg; \nextern crate lalrpop;\n\nfn main() {\n lalrpop::Configuration::new()\n .force_build(true)\n .generate_in_source_tree()\n .process_file(\"src/parser/grammar.lalrpop\")\n .unwrap();\n\n //lalrpop::process_root().unwrap();\n //peg::cargo_build(\"src/parser/grammar.rustpeg\", true);\n\n println!(\"cargo:rerun-if-changed=src/parser/grammar.lalrpop\");\n}\n" }, { "path": "libeir_syntax_core/src/ast.rs", "content": "use eir::{ Atom, Variable };\n\n#[derive(Debug, Copy, Clone)]\npub enum MapExactAssoc {\n Exact,\n Assoc,\n}\n\n#[derive(Debug, Clone)]\npub struct Annotated(pub I, pub Vec<()>);\nimpl Annotated {\n pub fn empty(inner: I) -> Self {\n Annotated(inner, Vec::new())\n }\n}\n\n#[derive(Debug, Clone)]\npub struct Module {\n pub name: Atom,\n pub declarations: Vec,\n pub attributes: Vec<(Atom, Constant)>,\n pub definitions: Vec,\n}\n\n#[derive(Debug, Clone, Hash, PartialEq, Eq)]\npub struct FunctionName {\n pub name: Atom,\n pub arity: usize,\n}\n//impl FunctionName {\n// pub fn to_eir(&self, module: Atom) -> FunctionIdent {\n// FunctionIdent {\n// module: module,\n// name: self.name.clone(),\n// arity: self.arity,\n// lambda: None,\n// }\n// }\n//}\n\n#[derive(Debug, Clone, PartialEq, Eq, Hash)]\npub struct Integer {\n pub sign: bool,\n pub digits: String,\n}\nimpl Integer {\n pub fn as_u32(&self) -> u32 {\n assert!(self.sign);\n self.digits.parse().unwrap()\n }\n pub fn as_usize(&self) -> usize {\n assert!(self.sign);\n self.digits.parse().unwrap()\n }\n}\n\nuse eir::{ AtomicTerm, ConstantTerm };\ntype AtomicLiteral = AtomicTerm;\n\n//#[derive(Debug, Clone, PartialEq, Eq, Hash)]\n//pub enum AtomicLiteral {\n// Integer(Integer),\n// Float,\n// Atom(Atom),\n// Nil,\n// Char(char),\n// String(String),\n//}\n//impl Display for AtomicLiteral {\n// fn fmt(&self, f: &mut Formatter) -> Result<(), ::std::fmt::Error> {\n// match self {\n// &AtomicLiteral::Integer(ref int) => write!(f, \"{}{}\", int.sign, int.digits),\n// _ => write!(f, \"unimpl\"),\n// }\n// }\n//}\n\n#[derive(Debug, Clone)]\npub enum Constant {\n Atomic(AtomicLiteral),\n Tuple(Vec),\n List(Vec, Box),\n}\n//impl Constant {\n// pub fn to_eir(&self) -> ConstantTerm {\n// match self {\n// Constant::Atomic(atomic) => ConstantTerm::Atomic(atomic.clone()),\n// Constant::List(head, tail) =>\n// ConstantTerm::List(\n// head.iter().map(|c| c.to_eir()).collect(),\n// Box::new(tail.to_eir()),\n// ),\n// _ => unimplemented!(),\n// }\n// }\n//}\n//impl Display for Constant {\n// fn fmt(&self, f: &mut Formatter) -> Result<(), ::std::fmt::Error> {\n// match self {\n// &Constant::Atomic(ref lit) => write!(f, \"{}\", lit),\n// _ => write!(f, \"unimpl\"),\n// }\n// }\n//}\n\n#[derive(Debug, Clone)]\npub struct FunctionDefinition {\n pub name: Annotated,\n pub fun: Annotated,\n}\n\n#[derive(Debug, Clone)]\npub enum SingleExpression {\n // Env reading\n FunctionName(FunctionName),\n ExternalFunctionName { module: Atom, name: FunctionName },\n Variable(Variable),\n\n // Control flow\n Let { vars: Vec>, val: Box, body: Box },\n Catch(Box),\n Case { val: Box, clauses: Vec> },\n Do(Box, Box),\n Try { body: Box, then_vars: Vec>, then: Box,\n catch_vars: Vec>, catch: Box },\n Receive { clauses: Vec>, timeout_time: Box,\n timeout_body: Box },\n\n // Calling\n PrimOpCall(PrimOpCall),\n ApplyCall { fun: Box, args: Vec },\n InterModuleCall { module: Box, name: Box, args: Vec },\n\n // Lambda creation\n Fun(Box),\n LetRec { funs: Vec<(FunctionName, Function)>, body: Box },\n\n // Term constructors\n AtomicLiteral(AtomicLiteral),\n Tuple(Vec),\n List { head: Vec, tail: Box },\n Map(Vec>, Option),\n Binary(Vec<(Expression, Vec)>),\n}\n\n#[derive(Debug, Clone)]\npub struct CaseClause {\n pub patterns: Vec>,\n pub guard: Expression,\n pub body: Expression,\n}\n\n#[derive(Debug, Clone)]\npub enum Pattern {\n Wildcard,\n BindVar(Annotated, Box>),\n Atomic(AtomicLiteral),\n Binary(Vec<(Annotated, Vec>)>),\n Tuple(Vec>),\n List(Vec>, Box>),\n Map(Vec, Annotated)>>),\n}\nimpl Pattern {\n pub fn nil() -> Annotated {\n Annotated::empty(Pattern::Atomic(AtomicTerm::Nil))\n }\n}\n\npub type Expression = Annotated>>;\nimpl Expression {\n pub fn nil() -> Self {\n Annotated::empty(vec![Annotated::empty(SingleExpression::AtomicLiteral(\n AtomicTerm::Nil))])\n }\n}\n\n#[derive(Debug, Clone)]\npub struct Function {\n pub vars: Vec>,\n pub body: Expression,\n}\n\n#[derive(Debug, Clone)]\npub struct PrimOpCall {\n pub name: Annotated,\n pub args: Vec,\n}\n" }, { "path": "libeir_syntax_core/src/lexer.rs", "content": "use regex::Regex;\nuse std::str::CharIndices;\nuse lazy_static::lazy_static;\n\nlazy_static! {\n static ref TEST: Regex = Regex::new(\"...\").unwrap();\n}\n\n#[derive(Clone, PartialEq, Eq, Debug)]\npub enum Tok<'input> {\n\n // Keywords\n Module,\n Attributes,\n Fun,\n Case,\n Call,\n Apply,\n When,\n End,\n Catch,\n Do,\n Let,\n In,\n Of,\n Primop,\n Try,\n Receive,\n After,\n Letrec,\n\n // Identifiers/atomics\n Atom(&'input str),\n Variable(&'input str),\n Integer((bool, &'input str)),\n Float(&'input str),\n Char(char),\n String(&'input str),\n\n // Symbols\n ParenOpen,\n ParenClose,\n CurlyOpen,\n CurlyClose,\n SquareOpen,\n SquareClose,\n TriOpen,\n TriClose,\n MapOpen,\n MapMatch,\n MapClose,\n BitstringOpen,\n BitstringClose,\n BitstringPatternOpen,\n BitstringPatternSep,\n\n Annotation,\n\n Colon,\n Comma,\n ForwardSlash,\n Equals,\n Pipe,\n Arrow,\n HashRocket,\n}\n\nconst KEYWORDS: &'static [(&'static str, Tok<'static>)] = &[\n (\"module\", Tok::Module),\n (\"attributes\", Tok::Attributes),\n (\"fun\", Tok::Fun),\n (\"case\", Tok::Case),\n (\"call\", Tok::Call),\n (\"apply\", Tok::Apply),\n (\"when\", Tok::When),\n (\"end\", Tok::End),\n (\"catch\", Tok::Catch),\n (\"do\", Tok::Do),\n (\"let\", Tok::Let),\n (\"in\", Tok::In),\n (\"of\", Tok::Of),\n (\"primop\", Tok::Primop),\n (\"try\", Tok::Try),\n (\"receive\", Tok::Receive),\n (\"after\", Tok::After),\n (\"letrec\", Tok::Letrec),\n];\n\nfn is_escapechar(c: char) -> bool {\n c == 'b' || c == 'd' || c == 'e'\n || c == 'f' || c == 'n' || c == 'r'\n || c == 's' || c == 't' || c == 'v'\n || c == '\"' || c == '\\'' || c == '\\\\'\n}\nfn is_control(c: char) -> bool {\n c >= '\\u{0000}' && c <= '\\u{001f}'\n}\nfn is_inputchar(c: char) -> bool {\n c != '\\n' && c != '\\r'\n}\nfn is_digit(c: char) -> bool {\n c >= '0' && c <= '9'\n}\nfn is_octal(c: char) -> bool {\n c >= '0' && c <= '7'\n}\nfn is_uppercase(c: char) -> bool {\n (c >= 'A' && c <= 'Z')\n || (c >= '\\u{00c0}' && c <= '\\u{00d6}')\n || (c >= '\\u{00d8}' && c <= '\\u{00de}')\n}\nfn is_lowercase(c: char) -> bool {\n (c >= 'a' && c <= 'z')\n || (c >= '\\u{00df}' && c <= '\\u{00f6}')\n || (c >= '\\u{00f8}' && c <= '\\u{00ff}')\n}\nfn is_namechar(c: char) -> bool {\n is_uppercase(c) || is_lowercase(c) || is_digit(c)\n || (c == '@') || (c == '_')\n}\n\npub struct Tokenizer<'input> {\n text: &'input str,\n chars: CharIndices<'input>,\n next: Option<(usize, char)>,\n}\n\nimpl<'input> Tokenizer<'input> {\n\n pub fn new(text: &'input str) -> Self {\n let mut t = Tokenizer {\n text: text,\n chars: text.char_indices(),\n next: None,\n };\n t.bump();\n t\n }\n\n fn bump(&mut self) -> Option<(usize, char)> {\n self.next = self.chars.next();\n self.next\n }\n\n fn bump_escape(&mut self) -> Result<(), ()> {\n match self.bump() {\n Some((_idx0, '^')) => {\n match self.bump() {\n Some((_idx1, c)) if c >= '\\u{0040}' && c <= '\\u{005f}' => {\n self.bump();\n Ok(())\n }\n _ => Err(()),\n }\n }\n Some((_idx0, c)) if is_octal(c) => {\n match self.bump() {\n Some((_idx1, c)) if is_octal(c) => {\n match self.bump() {\n Some((_idx1, c)) if is_octal(c) => {\n self.bump();\n Ok(())\n }\n _ => Ok(()),\n }\n }\n _ => Ok(()),\n }\n },\n Some((_idx0, c)) if is_escapechar(c) => {\n self.bump();\n Ok(())\n }\n _ => Err(()),\n }\n }\n\n fn take_while(&mut self, fun: F) -> &'input str where F: Fn(char) -> bool {\n let start = self.next.unwrap().0;\n let mut end = self.next.unwrap().0;\n loop {\n match self.next {\n Some((idx0, c)) if fun(c) => {\n end = idx0;\n self.bump();\n }\n Some((idx0, _c)) => {\n end = idx0;\n break;\n }\n None => {\n end += 1; // TODO: Very wrong for unicode\n break;\n }\n }\n }\n\n return &self.text[start..end];\n }\n\n fn next_token(&mut self) -> Option, usize), ()>> {\n 'outer: loop {\n return match self.next {\n\n // Keywords and variables\n Some((idx0, c)) if is_namechar(c) && !is_digit(c) => {\n let mut end = idx0;\n 'inner: loop {\n match self.bump() {\n Some((idx1, c)) if is_namechar(c) => {\n end = idx1;\n }\n Some((idx1, _)) => {\n end = idx1;\n break 'inner;\n }\n None => {\n end += 1;\n break 'inner;\n }\n }\n }\n\n let word = &self.text[idx0..end];\n\n // Check for keywords\n let kw = KEYWORDS.iter()\n .filter(|&&(w, _)| w == word)\n .next();\n if let Some((_, kw)) = kw {\n return Some(Ok((idx0, kw.clone(), end)));\n }\n\n // Variable\n if is_uppercase(c) || c == '_' {\n return Some(Ok((idx0, Tok::Variable(word), end)));\n }\n\n Some(Err(()))\n }\n\n // Atoms\n Some((idx0, '\\'')) => {\n self.bump();\n let end;\n loop {\n match self.next {\n Some((_idx1, '\\\\')) => {\n match self.bump_escape() {\n Ok(()) => (),\n Err(()) => return Some(Err(())),\n }\n }\n Some((idx1, '\\'')) => {\n self.bump();\n end = idx1 + 1; // TODO: Very very wrong for unicode\n break;\n }\n Some((_idx1, c)) if is_control(c) => return Some(Err(())),\n Some((_idx1, c)) if is_inputchar(c) => {\n self.bump();\n }\n _ => return Some(Err(())),\n }\n }\n\n let atom = &self.text[idx0+1..end-1];\n Some(Ok((idx0, Tok::Atom(atom), end)))\n }\n\n // Numbers\n Some((idx0, c)) if is_digit(c) => {\n let string = self.take_while(is_digit);\n Some(Ok((idx0, Tok::Integer((true, string)), idx0+1)))\n }\n Some((idx0, '+')) => {\n match self.bump() {\n Some((idx1, c)) if is_digit(c) => {\n let string = self.take_while(is_digit);\n Some(Ok((idx0, Tok::Integer((true, string)), idx1+1)))\n }\n _ => return Some(Err(())),\n }\n }\n\n // Symbols\n Some((idx0, '(')) => {\n self.bump();\n Some(Ok((idx0, Tok::ParenOpen, idx0+1)))\n }\n Some((idx0, ')')) => {\n self.bump();\n Some(Ok((idx0, Tok::ParenClose, idx0+1)))\n }\n Some((idx0, '{')) => {\n self.bump();\n Some(Ok((idx0, Tok::CurlyOpen, idx0+1)))\n }\n Some((idx0, '~')) => {\n match self.bump() {\n Some((idx1, '{')) => {\n self.bump();\n Some(Ok((idx0, Tok::MapOpen, idx1+1)))\n }\n _ => return Some(Err(())),\n }\n }\n Some((idx0, '}')) => {\n match self.bump() {\n Some((idx1, '#')) => {\n self.bump();\n Some(Ok((idx0, Tok::BitstringClose, idx1+1)))\n }\n Some((idx1, '~')) => {\n self.bump();\n Some(Ok((idx0, Tok::MapClose, idx1+1)))\n }\n _ => {\n Some(Ok((idx0, Tok::CurlyClose, idx0+1)))\n }\n }\n }\n Some((idx0, '[')) => {\n self.bump();\n Some(Ok((idx0, Tok::SquareOpen, idx0+1)))\n }\n Some((idx0, ']')) => {\n self.bump();\n Some(Ok((idx0, Tok::SquareClose, idx0+1)))\n }\n Some((idx0, '#')) => {\n match self.bump() {\n Some((idx1, '{')) => {\n self.bump();\n Some(Ok((idx0, Tok::BitstringOpen, idx1+1)))\n }\n Some((idx1, '<')) => {\n self.bump();\n Some(Ok((idx0, Tok::BitstringPatternOpen, idx1+1)))\n }\n _ => Some(Err(())),\n }\n }\n Some((idx0, '>')) => {\n match self.bump() {\n Some((idx1, '(')) => {\n self.bump();\n Some(Ok((idx0, Tok::BitstringPatternSep, idx1+1)))\n }\n _ => Some(Ok((idx0, Tok::TriClose, idx0+1))),\n }\n }\n Some((idx0, '<')) => {\n self.bump();\n Some(Ok((idx0, Tok::TriOpen, idx0+1)))\n }\n Some((idx0, ':')) => {\n match self.bump() {\n Some((idx1, '=')) => {\n self.bump();\n Some(Ok((idx0, Tok::MapMatch, idx1+1)))\n }\n _ => Some(Ok((idx0, Tok::Colon, idx0+1)))\n }\n }\n Some((idx0, '-')) => {\n match self.bump() {\n Some((idx1, '|')) => {\n self.bump();\n Some(Ok((idx0, Tok::Annotation, idx1+1)))\n }\n Some((idx1, '>')) => {\n self.bump();\n Some(Ok((idx0, Tok::Arrow, idx1+1)))\n }\n Some((idx1, c)) if is_digit(c) => {\n let string = self.take_while(is_digit);\n Some(Ok((idx0, Tok::Integer((false, string)), idx1+1)))\n }\n _ => Some(Err(())),\n }\n }\n Some((idx0, ',')) => {\n self.bump();\n Some(Ok((idx0, Tok::Comma, idx0+1)))\n }\n Some((idx0, '/')) => {\n self.bump();\n Some(Ok((idx0, Tok::ForwardSlash, idx0+1)))\n }\n Some((idx0, '=')) => {\n match self.bump() {\n Some((idx1, '>')) => {\n self.bump();\n Some(Ok((idx0, Tok::HashRocket, idx1+1)))\n }\n _ => Some(Ok((idx0, Tok::Equals, idx0+1))),\n }\n }\n Some((idx0, '|')) => {\n self.bump();\n Some(Ok((idx0, Tok::Pipe, idx0+1)))\n }\n\n // Supressed\n Some((_idx0, '%')) => {\n loop {\n match self.bump() {\n Some((_idx1, '\\n')) => {\n continue 'outer;\n }\n Some((_idx1, '\\r')) => {\n continue 'outer;\n }\n _ => (),\n }\n }\n }\n Some((_idx0, c)) if c == ' ' || c == '\\t' => {\n loop {\n match self.bump() {\n Some((_idx1, ' ')) => (),\n Some((_idx1, '\\t')) => (),\n _ => continue 'outer,\n }\n }\n }\n\n Some((_idx1, '\\n')) => {\n self.bump();\n continue 'outer;\n }\n Some((_idx1, '\\r')) => {\n match self.bump() {\n Some((_idx2, '\\n')) => {\n self.bump();\n continue 'outer;\n }\n _ => continue 'outer,\n }\n }\n\n None => None,\n\n c => unimplemented!(\"{:?}\", c),\n }\n }\n }\n\n}\n\nimpl<'input> Iterator for Tokenizer<'input> {\n type Item = Result<(usize, Tok<'input>, usize), ()>;\n\n fn next(&mut self) -> Option, usize), ()>> {\n self.next_token()\n }\n}\n\n#[test]\nfn test_symbols() {\n let text = \"( ) { } [ ] #{ }# #< >( -| , / =\";\n let mut tok = Tokenizer::new(&text);\n\n assert!(tok.next_token().unwrap().unwrap().1 == Tok::ParenOpen);\n assert!(tok.next_token().unwrap().unwrap().1 == Tok::ParenClose);\n assert!(tok.next_token().unwrap().unwrap().1 == Tok::CurlyOpen);\n assert!(tok.next_token().unwrap().unwrap().1 == Tok::CurlyClose);\n assert!(tok.next_token().unwrap().unwrap().1 == Tok::SquareOpen);\n assert!(tok.next_token().unwrap().unwrap().1 == Tok::SquareClose);\n assert!(tok.next_token().unwrap().unwrap().1 == Tok::BitstringOpen);\n assert!(tok.next_token().unwrap().unwrap().1 == Tok::BitstringClose);\n assert!(tok.next_token().unwrap().unwrap().1 == Tok::BitstringPatternOpen);\n assert!(tok.next_token().unwrap().unwrap().1 == Tok::BitstringPatternSep);\n\n assert!(tok.next_token().unwrap().unwrap().1 == Tok::Annotation);\n\n assert!(tok.next_token().unwrap().unwrap().1 == Tok::Comma);\n assert!(tok.next_token().unwrap().unwrap().1 == Tok::ForwardSlash);\n assert!(tok.next_token().unwrap().unwrap().1 == Tok::Equals);\n\n assert!(tok.next_token() == None);\n}\n\n#[test]\nfn test_keywords() {\n // Common path, don't bother testing all\n let text = \"module attributes fun case call of primop\";\n let mut tok = Tokenizer::new(&text);\n\n assert!(tok.next_token().unwrap().unwrap().1 == Tok::Module);\n assert!(tok.next_token().unwrap().unwrap().1 == Tok::Attributes);\n assert!(tok.next_token().unwrap().unwrap().1 == Tok::Fun);\n assert!(tok.next_token().unwrap().unwrap().1 == Tok::Case);\n assert!(tok.next_token().unwrap().unwrap().1 == Tok::Call);\n assert!(tok.next_token().unwrap().unwrap().1 == Tok::Of);\n assert!(tok.next_token().unwrap().unwrap().1 == Tok::Primop);\n\n assert!(tok.next_token() == None);\n}\n\n#[test]\nfn test_atoms() {\n let text = \"'something' '\\\\'' '\\\\5' '\\\\55' '\\\\555' '\\\\n' '\\\\^@' '\\\\^H' '\\\\^_'\";\n let mut tok = Tokenizer::new(&text);\n\n assert!(tok.next_token().unwrap().unwrap().1 == Tok::Atom(\"something\"));\n assert!(tok.next_token().unwrap().unwrap().1 == Tok::Atom(\"\\\\'\"));\n assert!(tok.next_token().unwrap().unwrap().1 == Tok::Atom(\"\\\\5\"));\n assert!(tok.next_token().unwrap().unwrap().1 == Tok::Atom(\"\\\\55\"));\n assert!(tok.next_token().unwrap().unwrap().1 == Tok::Atom(\"\\\\555\"));\n assert!(tok.next_token().unwrap().unwrap().1 == Tok::Atom(\"\\\\n\"));\n assert!(tok.next_token().unwrap().unwrap().1 == Tok::Atom(\"\\\\^@\"));\n assert!(tok.next_token().unwrap().unwrap().1 == Tok::Atom(\"\\\\^H\"));\n assert!(tok.next_token().unwrap().unwrap().1 == Tok::Atom(\"\\\\^_\"));\n\n assert!(tok.next_token() == None);\n}\n\n#[test]\nfn test_variables() {\n let text = \"Abc ABC _abcd A@_cD\";\n let mut tok = Tokenizer::new(&text);\n\n assert!(tok.next_token().unwrap().unwrap().1 == Tok::Variable(\"Abc\"));\n assert!(tok.next_token().unwrap().unwrap().1 == Tok::Variable(\"ABC\"));\n assert!(tok.next_token().unwrap().unwrap().1 == Tok::Variable(\"_abcd\"));\n assert!(tok.next_token().unwrap().unwrap().1 == Tok::Variable(\"A@_cD\"));\n\n assert!(tok.next_token() == None);\n}\n\n#[test]\nfn test_lex_compile_core_file() {\n use ::std::io::Read;\n\n let mut f = ::std::fs::File::open(\"../test_data/compile.core\").unwrap();\n let mut s = String::new();\n f.read_to_string(&mut s);\n\n let mut tok = Tokenizer::new(&s);\n\n loop {\n let res = tok.next_token();\n println!(\"{:?}\", res);\n assert!(res != Some(Err(())));\n if (res == None) {\n break;\n }\n }\n}\n\n\n\n\n\n\n\n\n\n\n\n" }, { "path": "libeir_syntax_core/src/lib.rs", "content": "pub use eir::Atom;\nuse eir::FunctionIdent;\n\nmod lexer;\nmod parser;\nmod ast;\nmod lower_hir;\n\n" }, { "path": "libeir_syntax_core/src/lower_hir.rs", "content": "use ::std::collections::HashSet;\n\nuse ::{ Atom };\nuse ::ir::{ Module, AVariable, AFunctionName, FunctionDefinition,\n FunctionVisibility, FunctionIdent };\nuse ::ir::hir::{ SingleExpression, SingleExpressionKind,\n Function, Pattern, PatternNode, Closure };\n\nuse ::ssa::INVALID_SSA;\n\nimpl Module {\n fn from_parsed(module: &::parser::Module) -> Self {\n let exported: HashSet<(Atom, usize)> = module.declarations.iter()\n .map(|f| (f.name.clone(), f.arity)).collect();\n Module {\n name: module.name.clone(),\n attributes: module.attributes.clone(),\n functions: module.definitions.iter()\n .map(|f| {\n let name = f.name.0.name.clone();\n let arity = f.name.0.arity;\n let is_visible = exported.contains(&(name.clone(), arity));\n let fun_ident = FunctionIdent {\n module: module.name.clone(),\n name: name,\n arity: arity,\n lambda: None,\n };\n FunctionDefinition {\n visibility: if is_visible {\n FunctionVisibility::Public\n } else {\n FunctionVisibility::Private\n },\n hir_fun: ::ir::hir::Function::from_parsed(&f.fun.0, &fun_ident),\n ident: fun_ident,\n lambda_env_idx: None,\n eir_fun: None,\n }\n }).collect(),\n envs: None,\n }\n }\n}\n\nimpl Function {\n fn from_parsed(fun: &::parser::Function, fun_ident: &FunctionIdent) -> Self {\n Function {\n args: fun.vars.iter().map(|a| AVariable::new(a.0.clone())).collect(),\n body: SingleExpression::from_parsed(&fun.body, fun_ident),\n }\n }\n}\n\nfn pat_node_from_parsed(node: &::parser::Pattern,\n values: &mut Vec,\n fun_ident: &FunctionIdent) -> PatternNode {\n\n let wildcard: ::parser::Variable = Atom::from(\"_\");\n\n use ::parser::Pattern as PP;\n match *node {\n PP::Atomic(ref a) => PatternNode::Atomic(a.clone()),\n PP::Wildcard => PatternNode::Wildcard,\n PP::BindVar(ref var, ref pat) if var.0 == wildcard =>\n pat_node_from_parsed(&pat.0, values, fun_ident),\n PP::BindVar(ref var, ref pat) =>\n PatternNode::BindVar(var.0.clone(), Box::new(\n pat_node_from_parsed(&pat.0, values, fun_ident))),\n PP::Binary(ref elems) => {\n PatternNode::Binary(\n elems.iter().map(|(pat, opts)| {\n let opts_n = opts.iter().map(|o| {\n let curr_val_num = values.len();\n values.push(SingleExpression::from_parsed_single(&o.0, fun_ident));\n curr_val_num\n }).collect();\n (pat_node_from_parsed(&pat.0, values, fun_ident), opts_n)\n }).collect(),\n )\n },\n PP::Tuple(ref pats) =>\n PatternNode::Tuple(\n pats.iter().map(|p| pat_node_from_parsed(&p.0, values, fun_ident)).collect()\n ),\n PP::List(ref pats, ref tail) =>\n PatternNode::List(\n pats.iter().map(|p| pat_node_from_parsed(&p.0, values, fun_ident)).collect(),\n Box::new(pat_node_from_parsed(&tail.0, values, fun_ident))\n ),\n PP::Map(ref kvs) => {\n PatternNode::Map(\n kvs.iter().map(|kv| {\n let curr_val_num = values.len();\n values.push(SingleExpression::from_parsed_single(&((kv.0).0).0, fun_ident));\n (\n curr_val_num,\n Box::new(pat_node_from_parsed(&((kv.0).1).0, values, fun_ident))\n )\n }).collect(),\n )\n },\n }\n}\n\nimpl Pattern {\n fn from_parsed(pat: &::parser::Pattern,\n values: &mut Vec,\n fun_ident: &FunctionIdent) -> Self {\n let node = pat_node_from_parsed(pat, values, fun_ident);\n\n let binds = node.get_bind_vars();\n\n Pattern {\n binds: binds.iter().map(|v| (v.clone(), INVALID_SSA)).collect(),\n node: node,\n }\n }\n}\n\nuse ::parser::SingleExpression as PSE;\nimpl SingleExpression {\n fn from_parsed_single(expr: &PSE, fun_ident: &FunctionIdent) -> SingleExpression {\n let kind = match *expr {\n PSE::Variable(ref v) =>\n SingleExpressionKind::Variable(AVariable::new(v.clone())),\n PSE::FunctionName(ref f) => {\n let ident = FunctionIdent {\n module: fun_ident.module.clone(),\n name: f.name.clone(),\n arity: f.arity,\n lambda: None,\n };\n SingleExpressionKind::NamedFunction {\n name: AFunctionName::new(ident),\n is_lambda: false,\n }\n },\n PSE::ExternalFunctionName { ref module, ref name } => {\n SingleExpressionKind::ExternalNamedFunction {\n name: AFunctionName::new(name.to_eir(module.clone())),\n }\n }\n\n PSE::AtomicLiteral(ref a) => SingleExpressionKind::Atomic(a.clone()),\n PSE::InterModuleCall { ref module, ref name, ref args } =>\n SingleExpressionKind::InterModuleCall {\n module: Box::new(SingleExpression::from_parsed(&module, fun_ident)),\n name: Box::new(SingleExpression::from_parsed(&name, fun_ident)),\n args: args.iter()\n .map(|a| SingleExpression::from_parsed(a, fun_ident))\n .collect(),\n },\n PSE::Let { ref vars, ref val, ref body } =>\n SingleExpressionKind::Let {\n vars: vars.iter().map(|v| AVariable::new(v.0.clone())).collect(),\n val: Box::new(SingleExpression::from_parsed(val, fun_ident)),\n body: Box::new(SingleExpression::from_parsed(body, fun_ident)),\n },\n PSE::ApplyCall { ref fun, ref args } =>\n SingleExpressionKind::ApplyCall {\n fun: Box::new(SingleExpression::from_parsed(fun, fun_ident)),\n args: args.iter()\n .map(|v| SingleExpression::from_parsed(v, fun_ident))\n .collect(),\n },\n PSE::Catch(ref body) => {\n SingleExpressionKind::Catch {\n body: Box::new(SingleExpression::from_parsed(body, fun_ident)),\n }\n },\n PSE::Case { ref val, ref clauses } => {\n //let cfg = pattern::match_from_parsed(val.0.len(), clauses.as_slice());\n let mut values = Vec::new();\n\n SingleExpressionKind::Case {\n val: Box::new(SingleExpression::from_parsed(val, fun_ident)),\n clauses: clauses.iter()\n .map(|c| {\n ::ir::hir::Clause {\n patterns: c.0.patterns.iter()\n .map(|p| {\n Pattern::from_parsed(&p.0, &mut values, fun_ident)\n }).collect(),\n guard: SingleExpression::from_parsed(&c.0.guard, fun_ident),\n body: SingleExpression::from_parsed(&c.0.body, fun_ident),\n }\n }).collect(),\n values: values,\n //cfg: cfg,\n }\n },\n PSE::Tuple(ref items) => {\n SingleExpressionKind::Tuple(\n items.iter()\n .map(|i| SingleExpression::from_parsed(i, fun_ident))\n .collect())\n },\n PSE::List { ref head, ref tail } => {\n SingleExpressionKind::List {\n head: head.iter()\n .map(|i| SingleExpression::from_parsed(i, fun_ident))\n .collect(),\n tail: Box::new(SingleExpression::from_parsed(tail, fun_ident)),\n }\n },\n PSE::PrimOpCall(ref op) => {\n SingleExpressionKind::PrimOp {\n name: op.name.0.clone(),\n args: op.args.iter()\n .map(|a| SingleExpression::from_parsed(a, fun_ident))\n .collect(),\n }\n },\n PSE::Do(ref d1, ref d2) => {\n SingleExpressionKind::Do(\n Box::new(SingleExpression::from_parsed(d1, fun_ident)),\n Box::new(SingleExpression::from_parsed(d2, fun_ident))\n )\n },\n PSE::Try { ref body, ref catch_vars, ref catch,\n ref then_vars, ref then } => {\n SingleExpressionKind::Try {\n body: Box::new(SingleExpression::from_parsed(body, fun_ident)),\n then_vars: then_vars.iter().map(|v| {\n AVariable {\n ssa: INVALID_SSA,\n var: v.0.clone(),\n }\n }).collect(),\n then: Box::new(SingleExpression::from_parsed(then, fun_ident)),\n catch_vars: catch_vars.iter().map(|v| {\n AVariable {\n ssa: INVALID_SSA,\n var: v.0.clone(),\n }\n }).collect(),\n catch: Box::new(SingleExpression::from_parsed(catch, fun_ident)),\n }\n },\n PSE::Receive { ref clauses, ref timeout_time, ref timeout_body } => {\n let mut values = Vec::new();\n SingleExpressionKind::Receive {\n clauses: clauses.iter().map(|c| {\n ::ir::hir::Clause {\n patterns: c.0.patterns.iter()\n .map(|p| {\n Pattern::from_parsed(&p.0, &mut values, fun_ident)\n }).collect(),\n guard: SingleExpression::from_parsed(&c.0.guard, fun_ident),\n body: SingleExpression::from_parsed(&c.0.body, fun_ident),\n }\n }).collect(),\n pattern_values: values,\n timeout_time: Box::new(SingleExpression::from_parsed(\n timeout_time, fun_ident)),\n timeout_body: Box::new(SingleExpression::from_parsed(\n timeout_body, fun_ident)),\n }\n },\n PSE::Fun(ref fun) => {\n SingleExpressionKind::BindClosure {\n closure: Closure {\n alias: None,\n ident: None,\n parent_ident: fun_ident.clone(),\n fun: Some(Box::new(Function::from_parsed(fun, fun_ident))),\n env: None,\n },\n lambda_env: None,\n env_ssa: INVALID_SSA,\n }\n },\n PSE::LetRec { ref funs, ref body } => {\n SingleExpressionKind::BindClosures {\n closures: funs.iter().map(|f| {\n Closure {\n alias: Some(AFunctionName::new(\n f.0.to_eir(fun_ident.module.clone()))),\n ident: None,\n parent_ident: fun_ident.clone(),\n fun: Some(Box::new(Function::from_parsed(&f.1, fun_ident))),\n env: None,\n }\n }).collect(),\n body: Box::new(SingleExpression::from_parsed(body, fun_ident)),\n lambda_env: None,\n env_ssa: INVALID_SSA,\n }\n },\n PSE::Map(ref kv, ref merge) => {\n let kv_h = kv.iter()\n .map(|ref ann| {\n let (ref k, assoc, ref v) = ann.0;\n (SingleExpression::from_parsed(k, fun_ident),\n SingleExpression::from_parsed(v, fun_ident),\n assoc)\n }).collect();\n let merge = merge.as_ref().map(\n |v| Box::new(SingleExpression::from_parsed(&v, fun_ident)));\n SingleExpressionKind::Map {\n values: kv_h,\n merge: merge,\n }\n },\n PSE::Binary(ref elems) => {\n SingleExpressionKind::Binary(\n elems.iter().map(|(ref value, ref opts)| {\n (SingleExpression::from_parsed(value, fun_ident),\n opts.iter().map(|o| SingleExpression::from_parsed(o, fun_ident)).collect())\n }).collect()\n )\n },\n //ref e => panic!(\"Unhandled: {:?}\", e),\n };\n SingleExpression {\n ssa: INVALID_SSA,\n kind,\n }\n }\n fn from_parsed(fun: &::parser::Expression, fun_ident: &FunctionIdent) -> SingleExpression {\n let values: Vec<_> = fun.0.iter()\n .map(|val| SingleExpression::from_parsed_single(&val.0, fun_ident))\n .collect();\n SingleExpression {\n ssa: INVALID_SSA,\n kind: SingleExpressionKind::ValueList(values),\n }\n }\n}\n\npub fn from_parsed(parsed: &::parser::Module) -> Module {\n Module::from_parsed(parsed)\n}\n" }, { "path": "libeir_syntax_core/src/parser/grammar.lalrpop", "content": "//-*- mode: rust -*-\n\nuse crate::ast::{ Module, Annotated, FunctionName, Constant,\nFunction, FunctionDefinition, Expression, SingleExpression, Pattern,\nCaseClause, PrimOpCall, MapExactAssoc };\nuse crate::lexer::Tok;\nuse eir::Atom;\nuse eir::AtomicTerm;\n\nuse ::num_bigint::BigInt;\nuse ::num_traits::ToPrimitive;\n\ngrammar<'input>(text: &'input str);\n\nInteger: BigInt = => {\n let mut num = BigInt::parse_bytes(i.1.as_bytes(), 10).unwrap();\n if !i.0 {\n num = -num;\n }\n num\n};\nAtom: Atom = <\"Atom\"> => Atom::from_str(<>);\nVariable: Atom = <\"Variable\"> => Atom::from_str(<>);\n\n// =========================\n// ======== Modules ========\n// =========================\n\npub AnnotatedModule: Annotated = {\n > => <>,\n};\nModule: Module = {\n \"module\" \n \"attributes\" \n \n \"end\" => Module {\n name: module_name,\n declarations: functions,\n attributes: attributes,\n definitions: definitions,\n }\n};\nModuleFunctions: Vec = \"[\" > \"]\" => n;\nModuleAttributes: Vec<(Atom, Constant)> = \"[\" \"=\" )>> \"]\";\n\n// ===========================\n// ======== Functions ========\n// ===========================\n\nFunctionName: FunctionName = {\n \"/\" => FunctionName { name: a, arity: i.to_usize().unwrap() },\n};\nFunctionDefinition: FunctionDefinition = {\n > \"=\" > =>\n FunctionDefinition { name: n, fun: f },\n};\nFun: Function = {\n \"fun\" \"(\" >> \")\" \"->\" =>\n Function { vars: a, body: e },\n};\n\n// =============================\n// ======== Expressions ========\n// =============================\n\nExactAssoc: MapExactAssoc = {\n \":=\" => MapExactAssoc::Exact,\n \"=>\" => MapExactAssoc::Assoc,\n};\n\nExpression: Expression = {\n > => a,\n > => Annotated::empty(vec![s]),\n};\nValueList: Vec> = {\n \"<\" >> \">\" => <>,\n};\nSingleExpression: SingleExpression = {\n\n \"[\" > )?> \"]\" => \n SingleExpression::List { head: e, tail: Box::new(t.unwrap_or(Expression::nil())) },\n\n => SingleExpression::FunctionName(<>),\n\n \"fun\" \":\" => \n SingleExpression::ExternalFunctionName { module: m, name:f },\n\n => SingleExpression::AtomicLiteral(a),\n => SingleExpression::Variable(v),\n => SingleExpression::Binary(b),\n\n \"{\" > \"}\" => SingleExpression::Tuple(t),\n\n \"~{\" )>>> )?> \"}~\" => \n SingleExpression::Map(v, m),\n\n \"let\" \"=\" \"in\" =>\n SingleExpression::Let { vars: v, val: Box::new(e), body: Box::new(i) },\n\n \"call\" \":\" \"(\" > \")\" =>\n SingleExpression::InterModuleCall {\n module: Box::new(a), name: Box::new(b), args: c },\n \n \"catch\" => SingleExpression::Catch(Box::new(e)),\n\n \"case\" \"of\" *> \"end\" =>\n SingleExpression::Case { val: Box::new(e), clauses: a },\n\n \"primop\" > \"(\" > \")\" =>\n SingleExpression::PrimOpCall(PrimOpCall { name: n, args: a }),\n\n \"do\" =>\n SingleExpression::Do(Box::new(e1), Box::new(e2)),\n\n \"apply\" \"(\" > \")\" =>\n SingleExpression::ApplyCall { fun: Box::new(f), args: a },\n\n \"try\" \"of\" \"->\" \n \"catch\" \"->\" =>\n SingleExpression::Try { body: Box::new(t), then_vars: av, then: Box::new(a), \n catch_vars: cv, catch: Box::new(c) },\n\n \"receive\" *> \"after\" \"->\" =>\n SingleExpression::Receive { clauses: c, timeout_time: Box::new(t),\n timeout_body: Box::new(b) },\n\n => SingleExpression::Fun(Box::new(f)),\n\n \"letrec\" \"=\" )+> \"in\" =>\n SingleExpression::LetRec { funs: f, body: Box::new(e) },\n};\n\nClause: CaseClause = {\n \"->\" => CaseClause { patterns: p, guard: g, body: b },\n};\nGuard: Expression = {\n \"when\" => <>,\n};\n\nVariables: Vec> = {\n > => vec![a],\n \"<\" >> \">\" => a,\n};\n\n// ==========================\n// ======== Patterns ========\n// ==========================\n\nPatterns: Vec> = {\n => vec![p],\n \"<\" > \">\" => p,\n};\n\nAnnotatedPattern: Annotated = > => p;\n\nPatternMapEntry: (Annotated, Annotated) = {\n > \":=\" => (k, v),\n};\nAnnotatedPatternMapEntry: Annotated<(Annotated, Annotated)> = {\n > => <>,\n};\n\n#[inline]\nPattern: Pattern = {\n > \"=\" =>\n Pattern::BindVar(v, Box::new(p)),\n =>\n Pattern::BindVar(Annotated::empty(v), Box::new(Annotated::empty(Pattern::Wildcard))),\n => Pattern::Atomic(a),\n => Pattern::Binary(b),\n\n \"{\" > \"}\" => Pattern::Tuple(t),\n\n \"~{\" > \"}~\" => Pattern::Map(m),\n\n \"[\" > )?> \"]\" => \n Pattern::List(l, Box::new(t.unwrap_or(Pattern::nil()))),\n\n// => Pattern::List(l.0, Box::new(l.1)),\n// => Pattern::Map(m),\n};\n\n//PatternMap: Vec<(SingleExpression, Annotated)> = {\n//};\n\n// ==========================\n// ======== Binaries ========\n// ==========================\n\n//ConstantOrVariable: ConstantOrVariable = {\n// => ConstantOrVariable::Constant(c),\n// => ConstantOrVariable::Variable(v),\n//};\nPatternBinary: Vec<(Annotated, Vec>)> = {\n \"#{\" > \"}#\" => b,\n};\nPatternBinaryElem: (Annotated, Vec>) = {\n \"#<\" \">(\" >> \")\" => (p, a),\n};\n\nBinary: Vec<(Expression, Vec)> = {\n \"#{\" > \"}#\" => b,\n};\nBinaryElem: (Expression, Vec) = {\n \"#<\" \">(\" > \")\" => (b, a),\n};\n\n// ===========================\n// ======== Constants ========\n// ===========================\n\nConstant: Constant = {\n \"{\" Comma \"}\" => Constant::Tuple(vec![]),\n \"[\" Comma (\"|\" Constant)? \"]\" =>\n Constant::List(vec![], Box::new(Constant::Atomic(AtomicTerm::Nil))),\n => Constant::Atomic(<>),\n};\n\nAtomicTerm: AtomicTerm = {\n => AtomicTerm::Integer(i),\n // => AtomicTerm::Float(f),\n => AtomicTerm::Atom(a),\n //\"[\" \"]\" => AtomicTerm::Nil,\n => AtomicTerm::Char(c),\n => AtomicTerm::String(s.to_string()),\n};\n\nConstantTuple: () = \"{\" Comma \"}\" => ();\nConstantList: () = \"[\" Comma (\"|\" Constant)? \"]\" => ();\n\n// =======================\n// ======== Utils ========\n// =======================\n\nAnnotated: Annotated = {\n => Annotated(i, vec![]),\n \"(\" Annotations \")\" => Annotated(i, vec![]),\n};\nAnnotations: () = {\n \"-|\" \"[\" > \"]\" => (),\n};\n\nComma: Vec = \n \",\")*> => {\n let mut rules = rules;\n rules.extend(last);\n rules\n };\n\n\nextern {\n type Location = usize;\n type Error = ();\n enum Tok<'input> {\n \"module\" => Tok::Module,\n \"attributes\" => Tok::Attributes,\n \"fun\" => Tok::Fun,\n \"case\" => Tok::Case,\n \"call\" => Tok::Call,\n \"apply\" => Tok::Apply,\n \"when\" => Tok::When,\n \"end\" => Tok::End,\n \"catch\" => Tok::Catch,\n \"do\" => Tok::Do,\n \"let\" => Tok::Let,\n \"in\" => Tok::In,\n \"of\" => Tok::Of,\n \"primop\" => Tok::Primop,\n \"try\" => Tok::Try,\n \"receive\" => Tok::Receive,\n \"after\" => Tok::After,\n \"letrec\" => Tok::Letrec,\n\n \"Atom\" => Tok::Atom(<&'input str>),\n \"Variable\" => Tok::Variable(<&'input str>),\n \"Integer\" => Tok::Integer(<(bool, &'input str)>),\n \"Float\" => Tok::Float(<&'input str>),\n \"Char\" => Tok::Char(),\n \"String\" => Tok::String(<&'input str>),\n\n \"(\" => Tok::ParenOpen,\n \")\" => Tok::ParenClose,\n \"{\" => Tok::CurlyOpen,\n \"}\" => Tok::CurlyClose,\n \"[\" => Tok::SquareOpen,\n \"]\" => Tok::SquareClose,\n \"<\" => Tok::TriOpen,\n \">\" => Tok::TriClose,\n \"~{\" => Tok::MapOpen,\n \":=\" => Tok::MapMatch,\n \"}~\" => Tok::MapClose,\n \"#{\" => Tok::BitstringOpen,\n \"}#\" => Tok::BitstringClose,\n \"#<\" => Tok::BitstringPatternOpen,\n \">(\" => Tok::BitstringPatternSep,\n \"-|\" => Tok::Annotation,\n \":\" => Tok::Colon,\n \",\" => Tok::Comma,\n \"/\" => Tok::ForwardSlash,\n \"=\" => Tok::Equals,\n \"|\" => Tok::Pipe,\n \"->\" => Tok::Arrow,\n \"=>\" => Tok::HashRocket,\n }\n}\n" }, { "path": "libeir_syntax_core/src/parser/grammar.rs", "content": "// auto-generated: \"lalrpop 0.16.3\"\n// sha256: dc56de9177595febc2b12f8c47a9639b9cb9f823fc7527e3133dcd8cafc3efb\nuse crate::ast::{ Module, Annotated, FunctionName, Constant, \nFunction, FunctionDefinition, Expression, SingleExpression, Pattern,\nCaseClause, PrimOpCall, MapExactAssoc };\nuse crate::lexer::Tok;\nuse eir::Atom;\nuse eir::AtomicTerm;\nuse ::num_bigint::BigInt;\nuse ::num_traits::ToPrimitive;\n#[allow(unused_extern_crates)]\nextern crate lalrpop_util as __lalrpop_util;\n#[allow(unused_imports)]\nuse self::__lalrpop_util::state_machine as __state_machine;\n\n#[cfg_attr(rustfmt, rustfmt_skip)]\nmod __parse__AnnotatedModule {\n #![allow(non_snake_case, non_camel_case_types, unused_mut, unused_variables, unused_imports, unused_parens)]\n\n use crate::ast::{ Module, Annotated, FunctionName, Constant, \nFunction, FunctionDefinition, Expression, SingleExpression, Pattern,\nCaseClause, PrimOpCall, MapExactAssoc };\n use crate::lexer::Tok;\n use eir::Atom;\n use eir::AtomicTerm;\n use ::num_bigint::BigInt;\n use ::num_traits::ToPrimitive;\n #[allow(unused_extern_crates)]\n extern crate lalrpop_util as __lalrpop_util;\n #[allow(unused_imports)]\n use self::__lalrpop_util::state_machine as __state_machine;\n use super::__ToTriple;\n #[allow(dead_code)]\n pub enum __Symbol<'input>\n {\n Variant0(Tok<'input>),\n Variant1(&'input str),\n Variant2(char),\n Variant3((bool, &'input str)),\n Variant4(Annotated),\n Variant5(::std::option::Option>),\n Variant6(Expression),\n Variant7(::std::option::Option),\n Variant8((Tok<'input>, Constant)),\n Variant9(::std::option::Option<(Tok<'input>, Constant)>),\n Variant10((Atom, Constant)),\n Variant11(::std::vec::Vec<(Atom, Constant)>),\n Variant12(Annotated<(Expression, MapExactAssoc, Expression)>),\n Variant13(::std::vec::Vec>),\n Variant14(Annotated),\n Variant15(::std::vec::Vec>),\n Variant16(Annotated),\n Variant17(::std::vec::Vec>),\n Variant18(::std::vec::Vec>),\n Variant19(Annotated<(Annotated, Annotated)>),\n Variant20(::std::vec::Vec, Annotated)>>),\n Variant21(::std::option::Option<(Atom, Constant)>),\n Variant22((Expression, Vec)),\n Variant23(::std::vec::Vec<(Expression, Vec)>),\n Variant24(Constant),\n Variant25(::std::vec::Vec),\n Variant26(::std::vec::Vec),\n Variant27((Expression, MapExactAssoc, Expression)),\n Variant28(FunctionName),\n Variant29(::std::vec::Vec),\n Variant30((FunctionName, Function)),\n Variant31(::std::vec::Vec<(FunctionName, Function)>),\n Variant32((Annotated, Vec>)),\n Variant33(::std::vec::Vec<(Annotated, Vec>)>),\n Variant34(::std::option::Option>),\n Variant35(Annotated),\n Variant36(::std::vec::Vec>),\n Variant37(Annotated),\n Variant38(Annotated),\n Variant39(Annotated),\n Variant40(::std::option::Option>),\n Variant41(Annotated>>),\n Variant42(::std::option::Option>),\n Variant43(::std::option::Option, Annotated)>>),\n Variant44(()),\n Variant45(Atom),\n Variant46(AtomicTerm),\n Variant47(Vec<(Expression, Vec)>),\n Variant48(::std::option::Option<(Expression, Vec)>),\n Variant49(CaseClause),\n Variant50(Vec<(Atom, Constant)>),\n Variant51(Vec>),\n Variant52(Vec>),\n Variant53(Vec>),\n Variant54(Vec>),\n Variant55(Vec, Annotated)>>),\n Variant56(Vec),\n Variant57(Vec),\n Variant58(Vec),\n Variant59(Vec<(Annotated, Vec>)>),\n Variant60(::std::option::Option),\n Variant61(MapExactAssoc),\n Variant62(Function),\n Variant63(FunctionDefinition),\n Variant64(::std::vec::Vec),\n Variant65(::std::option::Option),\n Variant66(BigInt),\n Variant67(Module),\n Variant68(Pattern),\n Variant69(::std::option::Option<(Annotated, Vec>)>),\n Variant70((Annotated, Annotated)),\n Variant71(SingleExpression),\n }\n const __ACTION: &'static [i16] = &[\n // State 0\n 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 1\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 2\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 3\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 4\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 5\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 6\n 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 7\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 13, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 8\n 0, -126, -126, -126, -126, -126, -126, -126, -126, -126, -126, -126, -126, -126, -126, -126, -126, 0, -126, -126, -126, -126, -126, -126, -126, 0, -126, -126, -126, -126, -126, -126, -126, -126, -126, 0, -126, -126, -126, -126, -126, -126, -126, -126, 0, -126, -126,\n // State 9\n 0, 0, 0, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 10\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 11\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 12\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, -173, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 13\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 14\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 27, 0, 28, 29, 0, 30, -165, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 31, 0, 0, 0, 0, 0,\n // State 15\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 33, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 16\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, -175, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 17\n 0, 0, 0, 0, 0, 0, 0, 35, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 18\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 36, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 19\n 0, 0, 0, 0, 37, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -172, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 20\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 27, 0, 28, 29, 0, 30, -167, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 31, -167, -167, 0, 0, 0,\n // State 21\n 0, 0, 0, 0, -128, 0, -128, 0, 0, 0, 0, 0, 0, -128, -128, 0, 0, 0, 0, 0, 0, 0, -128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -128, 0, -128, -128, 0, -128, 0,\n // State 22\n 0, 0, 0, 0, -183, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -183, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -183, -183, 0, 0, 0,\n // State 23\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 39, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 24\n 0, 0, 0, 0, 40, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -164, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -164, -164, 0, 0, 0,\n // State 25\n 0, -127, -127, -127, -127, -127, -127, 0, -127, -127, -127, 0, -127, -127, -127, -127, -127, 0, -127, -127, -127, -127, -127, -127, -127, 0, -127, -127, -127, -127, -127, -127, -127, -127, -127, 0, -127, -127, -127, -127, -127, -127, -127, -127, 0, -127, -127,\n // State 26\n 0, -129, -129, -129, -129, -129, -129, 0, -129, -129, -129, 0, -129, -129, -129, -129, -129, 0, -129, -129, -129, -129, -129, -129, -129, 0, -129, -129, -129, -129, -129, -129, -129, -129, -129, 0, -129, -129, -129, -129, -129, -129, -129, -129, 0, -129, -129,\n // State 27\n 0, -205, -205, -205, -205, -205, -205, 0, -205, -205, -205, -205, -205, -205, -205, -205, -205, 0, -205, -205, -205, -205, -205, -205, -205, 0, -205, -205, -205, -205, -205, -205, -205, -205, -205, 0, -205, -205, -205, -205, -205, -205, -205, -205, 0, -205, -205,\n // State 28\n 0, -130, -130, -130, -130, -130, -130, 0, -130, -130, -130, 0, -130, -130, -130, -130, -130, 0, -130, -130, -130, -130, -130, -130, -130, 0, -130, -130, -130, -130, -130, -130, -130, -130, -130, 0, -130, -130, -130, -130, -130, -130, -130, -130, 0, -130, -130,\n // State 29\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 27, 0, 28, 29, 0, 30, -165, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 31, -165, 0, 0, 0, 0,\n // State 30\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 27, 0, 28, 29, 0, 30, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 31, 0, -165, 0, 0, 0,\n // State 31\n 0, 0, 47, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 48, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 32\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, -137, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 33\n 0, 0, 0, 0, 52, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -174, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 34\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 28, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 35\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -209, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 36\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -62, 0, 0, 0, 0, 0, 0, -62, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 37\n 0, 0, 0, 0, 54, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -166, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -166, -166, 0, 0, 0,\n // State 38\n 0, 0, 0, -125, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 39\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -51, -51, 0, -51, -51, 0, -51, -51, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -51, -51, -51, 0, 0, 0,\n // State 40\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 55, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 56, 0, 0, 0, 0,\n // State 41\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 57, 0, 0, 0,\n // State 42\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 58, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 43\n 0, 0, -199, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -199, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -199, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 44\n 0, 0, 47, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 60, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 45\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -86, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 46\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 47\n 0, 0, 0, 0, 0, 0, -206, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 48\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, -139, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 49\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 63, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 50\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 51\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -63, 0, 0, 0, 0, 0, 0, -63, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 52\n 0, -201, -201, -201, -201, -201, -201, 0, -201, -201, -201, -201, -201, -201, -201, -201, -201, 0, -201, -201, -201, -201, -201, -201, -201, 0, -201, -201, -201, -201, -201, -201, -201, -201, -201, 0, -201, -201, -201, -201, 0, -201, -201, -201, 0, -201, -201,\n // State 53\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -52, -52, 0, -52, -52, 0, -52, -52, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -52, -52, -52, 0, 0, 0,\n // State 54\n 0, 0, 0, 0, -182, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -182, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -182, -182, 0, 0, 0,\n // State 55\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 27, 0, 28, 29, 0, 30, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 31, 0, 0, 0, 0, 0,\n // State 56\n 0, 0, 0, 0, -180, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -180, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -180, -180, 0, 0, 0,\n // State 57\n 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 69, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 58\n 0, 0, -200, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -200, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -200, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 59\n 0, 0, 0, 0, 0, 0, -207, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 60\n 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 61\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 71, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 62\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 27, 0, 28, 29, 0, 30, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 31, 0, 0, 0, 0, 0,\n // State 63\n 0, 0, -208, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -208, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -208, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 64\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 73, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 65\n 0, 0, -196, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -196, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -196, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 66\n 0, 0, -84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 67\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 69, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 68\n 0, 0, 75, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 69\n 0, 0, 0, 76, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 70\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 27, 0, 28, 29, 0, 30, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 31, 0, 0, 0, 0, 0,\n // State 71\n 0, 0, 0, 0, 78, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -136, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 72\n 0, 0, 0, 0, -181, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -181, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -181, -181, 0, 0, 0,\n // State 73\n 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 74\n 0, 0, 84, -149, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 85, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 75\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -87, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 76\n 0, 0, 0, 0, 86, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -138, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 77\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -13, 0, 0, 0, 0, 0, 0, -13, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 78\n 0, 0, 0, 87, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 79\n 0, 0, 84, -151, 0, 0, 0, 0, 0, 0, 0, 0, 0, -151, 0, 0, 0, 0, 0, 0, 85, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 80\n 0, 0, 0, -148, 89, 0, 0, 0, 0, 0, 0, 0, 0, -148, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 81\n 0, 0, 0, 90, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 82\n 0, 0, 0, -114, -114, -114, 0, 0, 0, 0, 0, -114, 0, -114, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 83\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 85, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 84\n 0, -249, -249, -249, -249, -249, -249, 0, -249, -249, -249, -249, -249, -249, -249, -249, -249, 0, -249, -249, -249, -249, -249, -249, -249, 0, -249, -249, -249, -249, -249, -249, -249, -249, -249, 0, -249, -249, -249, -249, -249, -249, -249, -249, 0, -249, -249,\n // State 85\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -14, 0, 0, 0, 0, 0, 0, -14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 86\n 0, 0, -85, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -85, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -85, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 87\n 0, 0, 0, -150, 92, 0, 0, 0, 0, 0, 0, 0, 0, -150, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 88\n 0, 0, -28, -28, 0, 0, 0, 0, 0, 0, 0, 0, 0, -28, 0, 0, 0, 0, 0, 0, -28, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 89\n 0, 0, 0, 0, 0, 93, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 90\n 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 91\n 0, 0, -29, -29, 0, 0, 0, 0, 0, 0, 0, 0, 0, -29, 0, 0, 0, 0, 0, 0, -29, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 92\n 0, 106, 107, 0, 0, 0, 0, 0, 0, 0, 108, 0, 0, 0, 0, 9, 27, 0, 28, 29, 85, 109, 0, 0, 110, 0, 111, 112, 113, 114, 0, 115, 0, 116, 117, 0, 0, 118, 119, 120, 0, 121, 0, 0, 0, 0, 122,\n // State 93\n 0, 0, 0, 123, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 94\n 0, -192, -192, -192, -192, -192, -192, 0, -192, -192, -192, 0, -192, -192, -192, -192, -192, 0, -192, -192, -192, -192, -192, -192, -192, 0, -192, -192, -192, -192, -192, -192, -192, -192, -192, 0, -192, -192, -192, -192, 0, -192, -192, -192, 0, -192, -192,\n // State 95\n 0, -191, -191, -191, -191, -191, -191, 0, -191, -191, -191, 0, -191, -191, -191, -191, -191, 0, -191, -191, -191, -191, -191, -191, -191, 0, -191, -191, -191, -191, -191, -191, -191, -191, -191, 0, -191, -191, -191, -191, 0, -191, -191, -191, 0, -191, -191,\n // State 96\n 0, -128, -128, -128, -128, -128, -128, 35, -128, -128, -128, 0, -128, -128, -128, -128, -128, 0, -128, -128, -128, -128, -128, -128, -128, 0, -128, -128, -128, -128, -128, -128, -128, -128, -128, 0, -128, -128, -128, -128, 0, -128, -128, -128, 0, -128, -128,\n // State 97\n 0, -229, -229, -229, -229, -229, -229, 0, -229, -229, -229, 0, -229, -229, -229, -229, -229, 0, -229, -229, -229, -229, -229, -229, -229, 0, -229, -229, -229, -229, -229, -229, -229, -229, -229, 0, -229, -229, -229, -229, 0, -229, -229, -229, 0, -229, -229,\n // State 98\n 0, -231, -231, -231, -231, -231, -231, 0, -231, -231, -231, 0, -231, -231, -231, -231, -231, 0, -231, -231, -231, -231, -231, -231, -231, 0, -231, -231, -231, -231, -231, -231, -231, -231, -231, 0, -231, -231, -231, -231, 0, -231, -231, -231, 0, -231, -231,\n // State 99\n 0, -195, -195, -195, -195, -195, -195, 0, -195, -195, -195, 0, -195, -195, -195, -195, -195, 0, -195, -195, -195, -195, -195, -195, -195, 0, -195, -195, -195, -195, -195, -195, -195, -195, -195, 0, -195, -195, -195, -195, 0, -195, -195, -195, 0, -195, -195,\n // State 100\n 0, -246, -246, -246, -246, -246, -246, 0, -246, -246, -246, 0, -246, -246, -246, -246, -246, 0, -246, -246, -246, -246, -246, -246, -246, 0, -246, -246, -246, -246, -246, -246, -246, -246, -246, 0, -246, -246, -246, -246, 0, -246, -246, -246, 0, -246, -246,\n // State 101\n 0, -227, -227, -227, -227, -227, -227, 0, -227, -227, -227, 0, -227, -227, -227, -227, -227, 0, -227, -227, -227, -227, -227, -227, -227, 0, -227, -227, -227, -227, -227, -227, -227, -227, -227, 0, -227, -227, -227, -227, 0, -227, -227, -227, 0, -227, -227,\n // State 102\n 0, -108, -108, -108, -108, -108, -108, 0, -108, -108, -108, 0, -108, -108, -108, -108, -108, 0, -108, -108, -108, -108, -108, -108, -108, 0, -108, -108, -108, -108, -108, -108, -108, -108, -108, 0, -108, -108, -108, -108, 0, -108, -108, -108, 0, -108, -108,\n // State 103\n 0, -112, -112, -112, -112, -112, -112, 0, -112, -112, -112, 0, -112, -112, -112, -112, -112, 0, -112, -112, -112, -112, -112, -112, -112, 0, -112, -112, -112, -112, -112, -112, -112, -112, -112, 0, -112, -112, -112, -112, 0, -112, -112, -112, 0, -112, -112,\n // State 104\n 0, -230, -230, -230, -230, -230, -230, 0, -230, -230, -230, 0, -230, -230, -230, -230, -230, 0, -230, -230, -230, -230, -230, -230, -230, 0, -230, -230, -230, -230, -230, -230, -230, -230, -230, 0, -230, -230, -230, -230, 0, -230, -230, -230, 0, -230, -230,\n // State 105\n 127, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -161, 0, 0,\n // State 106\n 0, 106, 0, 0, 0, 0, 0, 0, 0, 0, 108, 0, 0, 0, 0, 9, 27, 0, 28, 29, 85, 109, 0, 0, 110, 0, 111, 112, 113, 114, 0, 115, 0, 116, 117, 0, 0, 118, 119, 120, 0, 121, 0, 0, 0, 0, 122,\n // State 107\n 0, 106, 133, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -145, 0, 9, 27, 0, 28, 29, 85, 109, 0, 0, 110, 0, 111, 112, 113, 114, 0, 115, 0, 116, 117, 0, 0, 118, 119, 120, 0, 121, 0, 0, 0, 0, 122,\n // State 108\n 0, 106, 107, 0, 0, 0, 0, 0, 0, 0, 108, 0, 0, 0, 0, 9, 27, 0, 28, 29, 85, 109, -169, 0, 110, 0, 111, 112, 113, 114, 0, 115, 0, 116, 117, 0, 0, 118, 119, 120, 0, 121, -169, 0, 0, 0, 122,\n // State 109\n 0, 106, 107, 0, 0, 0, 0, 0, 0, 0, 108, 0, 0, 0, 0, 9, 27, 0, 28, 29, 85, 109, 0, 0, 110, 0, 111, 112, 113, 114, 0, 115, 0, 116, 117, 0, 0, 118, 119, 120, 0, 121, 0, 0, 0, 0, 122,\n // State 110\n 0, 106, 107, 0, 0, 0, 0, 0, 0, 0, 108, 0, 0, 0, 0, 9, 27, 0, 28, 29, 85, 109, 0, 0, 110, 0, 111, 112, 113, 114, 0, 115, 0, 116, 117, 0, 0, 118, 119, 120, 0, 121, 0, 0, 0, 0, 122,\n // State 111\n 0, 106, 107, 0, 0, 0, 0, 0, 0, 0, 108, 0, 0, 0, 0, 9, 27, 0, 28, 29, 85, 109, 0, 0, 110, 0, 111, 112, 113, 114, 0, 115, 0, 116, 117, 0, 0, 118, 119, 120, 0, 121, 0, 0, 0, 0, 122,\n // State 112\n 0, 106, 107, 0, 0, 0, 0, 0, 0, 0, 108, 0, 0, 0, 0, 9, 27, 0, 28, 29, 85, 109, 0, 0, 110, 0, 111, 112, 113, 114, 0, 115, 0, 116, 117, 0, 0, 118, 119, 120, 0, 121, 0, 0, 0, 0, 122,\n // State 113\n 0, 106, 107, 0, 0, 0, 0, 0, 0, 0, 108, 0, 0, 0, 0, 9, 27, 0, 28, 29, 85, 109, 0, 0, 110, 0, 111, 112, 113, 114, 0, 115, 0, 116, 117, 0, 0, 118, 119, 120, 0, 121, 0, 0, 0, 0, 122,\n // State 114\n 0, 0, 75, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 115\n 0, 0, 84, 0, 0, 0, 0, 0, 0, 0, 145, 0, 0, 0, 0, 0, 0, 0, 0, 0, 85, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 116\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 117\n 0, 0, 150, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 118\n 0, 161, 162, 0, 0, 0, 0, 0, 0, 0, 163, 0, 0, 0, 0, 9, 27, 0, 28, 29, 85, 164, 0, 165, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 166, 0, 0, 0, 0, 167,\n // State 119\n 0, 106, 107, 0, 0, 0, 0, 0, 0, 0, 108, 0, 0, 0, 0, 9, 27, 0, 28, 29, 85, 109, 0, 0, 110, 0, 111, 112, 113, 114, 0, 115, 0, 116, 117, 0, 0, 118, 119, 120, 0, 121, 0, 0, 0, 0, 122,\n // State 120\n 0, 106, 107, 0, 0, 0, 0, 0, 0, 0, 108, 0, 0, 0, 0, 9, 27, 0, 28, 29, 85, 109, 0, 0, 110, 0, 111, 112, 113, 114, 0, 115, 0, 116, 117, 0, 0, 118, 119, 120, 0, 121, 0, -169, 0, 0, 122,\n // State 121\n 0, 106, 174, 0, 0, 0, 0, 0, 0, 0, 108, 0, 0, 0, 0, 9, 27, 0, 28, 29, 85, 109, 0, 0, 110, 0, 111, 112, 113, 114, 0, 115, 0, 116, 117, 0, 0, 118, 119, 120, 0, 121, -141, 0, 0, -141, 122,\n // State 122\n 0, 0, 0, -115, -115, -115, 0, 0, 0, 0, 0, -115, 0, -115, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 123\n 127, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -163, 0, 0,\n // State 124\n 0, 0, 0, 0, 176, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -160, 0, 0,\n // State 125\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 177, 0, 0,\n // State 126\n 0, 106, 107, 0, 0, 0, 0, 0, 0, 0, 108, 0, 0, 0, 0, 9, 27, 0, 28, 29, 85, 109, 0, 0, 110, 0, 111, 112, 113, 114, 0, 115, 0, 116, 117, 0, 0, 118, 119, 120, 0, 121, 0, 0, 0, 0, 122,\n // State 127\n 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 128\n 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 129\n 0, 106, 133, -147, 0, 0, 0, 0, 0, 0, 0, 0, 0, -147, 0, 9, 27, 0, 28, 29, 85, 109, 0, 0, 110, 0, 111, 112, 113, 114, 0, 115, 0, 116, 117, 0, 0, 118, 119, 120, 0, 121, 0, 0, 0, 0, 122,\n // State 130\n 0, 0, 0, -144, 182, 0, 0, 0, 0, 0, 0, 0, 0, -144, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 131\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 183, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 132\n 0, 106, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 27, 0, 28, 29, 85, 109, 0, 0, 110, 0, 111, 112, 113, 114, 0, 115, 0, 116, 117, 0, 0, 118, 119, 120, 0, 121, 0, 0, 0, 0, 122,\n // State 133\n 0, 106, 107, -171, 0, 0, 0, 0, 0, 0, 108, 0, 0, 0, 0, 9, 27, 0, 28, 29, 85, 109, -171, 0, 110, 0, 111, 112, 113, 114, 0, 115, 0, 116, 117, 0, 0, 118, 119, 120, 0, 121, -171, -171, 0, 0, 122,\n // State 134\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 185, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 186, 0, 0, 0, 0,\n // State 135\n 0, 0, 0, -168, 187, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -168, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -168, -168, 0, 0, 0,\n // State 136\n 0, 0, 188, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 137\n 0, 0, 0, 0, 0, 0, 0, 0, 189, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 138\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 190, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 139\n 0, -237, -237, -237, -237, -237, -237, 0, -237, -237, -237, 0, -237, -237, -237, -237, -237, 0, -237, -237, -237, -237, -237, -237, -237, 0, -237, -237, -237, -237, -237, -237, -237, -237, -237, 0, -237, -237, -237, -237, 0, -237, -237, -237, 0, -237, -237,\n // State 140\n 0, 106, 107, 0, 0, 0, 0, 0, 0, 0, 108, 0, 0, 0, 0, 9, 27, 0, 28, 29, 85, 109, 0, 0, 110, 0, 111, 112, 113, 114, 0, 115, 0, 116, 117, 0, 0, 118, 119, 120, 0, 121, 0, 0, 0, 0, 122,\n // State 141\n 0, 0, 0, 0, 0, 0, 0, 0, 192, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 142\n 0, 0, 0, 0, 0, -250, 0, 0, 0, 0, 0, -250, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 143\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 193, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 144\n 0, 0, 84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -149, 0, 0, 0, 0, 0, 0, 85, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 145\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 196, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 146\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 197, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 147\n 0, 0, 198, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 148\n 0, 0, -76, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 149\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 150\n 0, -82, -82, 0, 0, 0, 0, 0, 0, 0, -82, 0, 0, 0, 0, -82, -82, 0, -82, -82, -82, -82, 0, -82, 0, 0, 0, 0, 0, 0, -82, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -82, 0, 0, 0, 0, -82,\n // State 151\n 0, 161, 162, 0, 0, 0, 0, 0, 0, 0, 163, 0, 0, 0, 0, 9, 27, 0, 28, 29, 85, 164, 0, 201, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 166, 0, 0, 0, 0, 167,\n // State 152\n 0, 0, 0, 0, -119, 0, -119, 0, 0, 0, 0, 0, 0, -119, -119, 0, 0, 0, 0, 0, 0, 0, -119, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -119, 0, -119, -119, 0, -119, 0,\n // State 153\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 202, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 154\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -223, 0, 0, 0, 0, 0, 0,\n // State 155\n 0, 0, 0, 0, -92, 0, -92, 0, 0, 0, 0, 0, 0, -92, -92, 0, 0, 0, 0, 0, 0, 0, -92, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -92, 0, -92, -92, 0, -92, 0,\n // State 156\n 0, -78, -78, 0, 0, 0, 0, 0, 0, 0, -78, 0, 0, 0, 0, -78, -78, 0, -78, -78, -78, -78, 0, -78, 0, 0, 0, 0, 0, 0, -78, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -78, 0, 0, 0, 0, -78,\n // State 157\n 0, 0, 0, 0, -93, 0, -93, 0, 0, 0, 0, 0, 0, -93, -93, 0, 0, 0, 0, 0, 0, 0, -93, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -93, 0, -93, -93, 0, -93, 0,\n // State 158\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 204, 0, 0, 0, 0, 0, 0,\n // State 159\n 0, 0, 0, 0, -91, 0, -91, 0, 0, 0, 0, -114, 0, -91, -91, 0, 0, 0, 0, 0, 0, 0, -91, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -91, 0, -91, -91, 0, -91, 0,\n // State 160\n 208, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -177, 0, 0,\n // State 161\n 0, 161, 214, 0, 0, 0, 0, 0, 0, 0, 163, 0, 0, 0, 0, 9, 27, 0, 28, 29, 85, 215, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 216, 0, 0, 0, 0, 217,\n // State 162\n 0, 161, 214, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -153, 0, 9, 27, 0, 28, 29, 85, 164, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 166, 0, 0, 0, 0, 167,\n // State 163\n 0, 161, 214, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 27, 0, 28, 29, 85, 164, -153, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 166, -153, 0, 0, 0, 167,\n // State 164\n 0, 106, 107, 0, 0, 0, 0, 0, 0, 0, 108, 0, 0, 0, 0, 9, 27, 0, 28, 29, 85, 109, 0, 0, 110, 0, 111, 112, 113, 114, 0, 115, 0, 116, 117, 0, 0, 118, 119, 120, 0, 121, 0, 0, 0, 0, 122,\n // State 165\n 0, 161, 214, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 27, 0, 28, 29, 85, 164, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 166, 0, -153, 0, 0, 167,\n // State 166\n 0, 106, 230, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 27, 0, 28, 29, 85, 109, 0, 0, 110, 0, 111, 112, 113, 114, 0, 115, 0, 116, 117, 0, 0, 118, 119, 120, 0, 121, 0, 0, 0, -157, 122,\n // State 167\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 231, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 168\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 232, 0, 0, 0,\n // State 169\n 0, 106, 174, 0, 0, 0, 0, 0, 0, 0, 108, 0, 0, 0, 0, 9, 27, 0, 28, 29, 85, 109, 0, 0, 110, 0, 111, 112, 113, 114, 0, 115, 0, 116, 117, 0, 0, 118, 119, 120, 0, 121, -143, 0, 0, -143, 122,\n // State 170\n 0, 0, 0, 0, 234, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -140, 0, 0, -140, 0,\n // State 171\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 235, 0, 0, 236, 0,\n // State 172\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 238, 0, 0, 239, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 173\n 0, 106, 107, 0, 0, 0, 0, 0, 0, 0, 108, 0, 0, 0, 0, 9, 27, 0, 28, 29, 85, 109, 0, 0, 110, 0, 111, 112, 113, 114, 0, 115, 0, 116, 117, 0, 0, 118, 119, 120, 0, 121, 0, 0, 0, 0, 122,\n // State 174\n 0, 0, 0, 0, 243, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -162, 0, 0,\n // State 175\n -46, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -46, 0, 0,\n // State 176\n 0, -131, -131, -131, -131, -131, -131, 0, -131, -131, -131, 0, -131, -131, -131, -131, -131, 0, -131, -131, -131, -131, -131, -131, -131, 0, -131, -131, -131, -131, -131, -131, -131, -131, -131, 0, -131, -131, -131, -131, 0, -131, -131, -131, 0, -131, -131,\n // State 177\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 244, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 178\n 0, 0, 0, 245, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 179\n 0, 0, 0, 246, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 180\n 0, 0, 0, -146, 247, 0, 0, 0, 0, 0, 0, 0, 0, -146, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 181\n 0, -23, -23, -23, 0, 0, 0, 0, 0, 0, 0, 0, 0, -23, 0, -23, -23, 0, -23, -23, -23, -23, 0, 0, -23, 0, -23, -23, -23, -23, 0, -23, 0, -23, -23, 0, 0, -23, -23, -23, 0, -23, 0, 0, 0, 0, -23,\n // State 182\n 0, -248, -248, -248, -248, -248, -248, 0, -248, -248, -248, 0, -248, -248, -248, -248, -248, 0, -248, -248, -248, -248, -248, -248, -248, 0, -248, -248, -248, -248, -248, -248, -248, -248, -248, 0, -248, -248, -248, -248, 0, -248, -248, -248, 0, -248, -248,\n // State 183\n 0, 0, 0, -170, 248, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -170, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -170, -170, 0, 0, 0,\n // State 184\n 0, -226, -226, -226, -226, -226, -226, 0, -226, -226, -226, 0, -226, -226, -226, -226, -226, 0, -226, -226, -226, -226, -226, -226, -226, 0, -226, -226, -226, -226, -226, -226, -226, -226, -226, 0, -226, -226, -226, -226, 0, -226, -226, -226, 0, -226, -226,\n // State 185\n 0, 106, 107, 0, 0, 0, 0, 0, 0, 0, 108, 0, 0, 0, 0, 9, 27, 0, 28, 29, 85, 109, 0, 0, 110, 0, 111, 112, 113, 114, 0, 115, 0, 116, 117, 0, 0, 118, 119, 120, 0, 121, 0, 0, 0, 0, 122,\n // State 186\n 0, -56, -56, -56, 0, 0, 0, 0, 0, 0, -56, 0, 0, 0, 0, -56, -56, 0, -56, -56, -56, -56, -56, 0, -56, 0, -56, -56, -56, -56, 0, -56, 0, -56, -56, 0, 0, -56, -56, -56, 0, -56, -56, -56, 0, 0, -56,\n // State 187\n 0, 106, 107, -169, 0, 0, 0, 0, 0, 0, 108, 0, 0, 0, 0, 9, 27, 0, 28, 29, 85, 109, 0, 0, 110, 0, 111, 112, 113, 114, 0, 115, 0, 116, 117, 0, 0, 118, 119, 120, 0, 121, 0, 0, 0, 0, 122,\n // State 188\n 0, 106, 107, 0, 0, 0, 0, 0, 0, 0, 108, 0, 0, 0, 0, 9, 27, 0, 28, 29, 85, 109, 0, 0, 110, 0, 111, 112, 113, 114, 0, 115, 0, 116, 117, 0, 0, 118, 119, 120, 0, 121, 0, 0, 0, 0, 122,\n // State 189\n 0, 161, 162, 0, 0, 0, 0, 0, 0, 0, 163, 0, 0, 0, 0, 9, 27, 0, 28, 29, 85, 164, 0, 0, 0, 0, 0, 0, 0, 0, 253, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 166, 0, 0, 0, 0, 167,\n // State 190\n 0, -241, -241, -241, -241, -241, -241, 0, -241, -241, -241, 0, -241, -241, -241, -241, -241, 0, -241, -241, -241, -241, -241, -241, -241, 0, -241, -241, -241, -241, -241, -241, -241, -241, -241, 0, -241, -241, -241, -241, 0, -241, -241, -241, 0, -241, -241,\n // State 191\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 192\n 0, 106, 107, 0, 0, 0, 0, 0, 0, 0, 108, 0, 0, 0, 0, 9, 27, 0, 28, 29, 85, 109, 0, 0, 110, 0, 111, 112, 113, 114, 0, 115, 0, 116, 117, 0, 0, 118, 119, 120, 0, 121, 0, 0, 0, 0, 122,\n // State 193\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 256, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 194\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 257, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 195\n 0, 106, 107, 0, 0, 0, 0, 0, 0, 0, 108, 0, 0, 0, 0, 9, 27, 0, 28, 29, 85, 109, 0, 0, 110, 0, 111, 112, 113, 114, 0, 115, 0, 116, 117, 0, 0, 118, 119, 120, 0, 121, 0, 0, 0, 0, 122,\n // State 196\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 69, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 197\n 0, 106, 107, -169, 0, 0, 0, 0, 0, 0, 108, 0, 0, 0, 0, 9, 27, 0, 28, 29, 85, 109, 0, 0, 110, 0, 111, 112, 113, 114, 0, 115, 0, 116, 117, 0, 0, 118, 119, 120, 0, 121, 0, 0, 0, 0, 122,\n // State 198\n 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 199\n 0, -83, -83, 0, 0, 0, 0, 0, 0, 0, -83, 0, 0, 0, 0, -83, -83, 0, -83, -83, -83, -83, 0, -83, 0, 0, 0, 0, 0, 0, -83, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -83, 0, 0, 0, 0, -83,\n // State 200\n 0, 106, 107, 0, 0, 0, 0, 0, 0, 0, 108, 0, 0, 0, 0, 9, 27, 0, 28, 29, 85, 109, 0, 0, 110, 0, 111, 112, 113, 114, 0, 115, 0, 116, 117, 0, 0, 118, 119, 120, 0, 121, 0, 0, 0, 0, 122,\n // State 201\n 0, 161, 214, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 27, 0, 28, 29, 85, 164, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 166, 0, 0, 0, 0, 167,\n // State 202\n 0, 0, 0, 0, 0, 264, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 203\n 0, 106, 107, 0, 0, 0, 0, 0, 0, 0, 108, 0, 0, 0, 0, 9, 27, 0, 28, 29, 85, 109, 0, 0, 110, 0, 111, 112, 113, 114, 0, 115, 0, 116, 117, 0, 0, 118, 119, 120, 0, 121, 0, 0, 0, 0, 122,\n // State 204\n 208, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -179, 0, 0,\n // State 205\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 267, 0, 0,\n // State 206\n 0, 0, 0, 0, 268, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -176, 0, 0,\n // State 207\n 0, 161, 214, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 27, 0, 28, 29, 85, 164, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 166, 0, 0, 0, 0, 167,\n // State 208\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 270, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 209\n 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -92, 0, 0, 0, 0, 0, 0,\n // State 210\n 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 211\n 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -93, 0, 0, 0, 0, 0, 0,\n // State 212\n 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 0, -114, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -91, 0, 0, 0, 0, 0, 0,\n // State 213\n 0, 161, 84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 27, 0, 28, 29, 85, 279, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 280, 0, 0, 0, 0, 281,\n // State 214\n 0, 161, 214, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 27, 0, 28, 29, 85, 164, -153, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 166, -153, 0, 0, 0, 167,\n // State 215\n 0, 161, 214, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 27, 0, 28, 29, 85, 164, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 166, 0, -153, 0, 0, 167,\n // State 216\n 0, 106, 230, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 27, 0, 28, 29, 85, 109, 0, 0, 110, 0, 111, 112, 113, 114, 0, 115, 0, 116, 117, 0, 0, 118, 119, 120, 0, 121, 0, 0, 0, -157, 122,\n // State 217\n 0, 161, 214, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -155, 0, 9, 27, 0, 28, 29, 85, 164, -155, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 166, -155, -155, 0, 0, 167,\n // State 218\n 0, 0, 0, 0, 286, 0, 0, 0, 0, 0, 0, 0, 0, -152, 0, 0, 0, 0, 0, 0, 0, 0, -152, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -152, -152, 0, 0, 0,\n // State 219\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 287, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 220\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 288, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 289, 0, 0, 0, 0,\n // State 221\n 0, 0, 0, 0, 0, 290, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 222\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 291, 0, 0, 0,\n // State 223\n 0, 106, 230, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 27, 0, 28, 29, 85, 109, 0, 0, 110, 0, 111, 112, 113, 114, 0, 115, 0, 116, 117, 0, 0, 118, 119, 120, 0, 121, 0, 0, 0, -159, 122,\n // State 224\n 0, 0, 0, 0, -122, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -122, 0,\n // State 225\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 293, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 226\n 0, 0, 0, 0, 294, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -156, 0,\n // State 227\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 295, 0,\n // State 228\n 0, 0, 0, 0, -106, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -106, 0,\n // State 229\n 0, 106, 133, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 27, 0, 28, 29, 85, 109, 0, 0, 110, 0, 111, 112, 113, 114, 0, 115, 0, 116, 117, 0, 0, 118, 119, 120, 0, 121, 0, 0, 0, 0, 122,\n // State 230\n 0, 0, 84, 0, 0, 0, 0, 0, 0, 0, 145, 0, 0, 0, 0, 0, 0, 0, 0, 0, 85, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 231\n 0, -232, -232, -232, -232, -232, -232, 0, -232, -232, -232, 0, -232, -232, -232, -232, -232, 0, -232, -232, -232, -232, -232, -232, -232, 0, -232, -232, -232, -232, -232, -232, -232, -232, -232, 0, -232, -232, -232, -232, 0, -232, -232, -232, 0, -232, -232,\n // State 232\n 0, 0, 0, 0, 298, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -142, 0, 0, -142, 0,\n // State 233\n 0, -18, -18, 0, 0, 0, 0, 0, 0, 0, -18, 0, 0, 0, 0, -18, -18, 0, -18, -18, -18, -18, 0, 0, -18, 0, -18, -18, -18, -18, 0, -18, 0, -18, -18, 0, 0, -18, -18, -18, 0, -18, -18, 0, 0, -18, -18,\n // State 234\n 0, 106, 107, 0, 0, 0, 0, 0, 0, 0, 108, 0, 0, 0, 0, 9, 27, 0, 28, 29, 85, 109, 0, 0, 110, 0, 111, 112, 113, 114, 0, 115, 0, 116, 117, 0, 0, 118, 119, 120, 0, 121, 0, 0, 0, 0, 122,\n // State 235\n 0, -234, -234, -234, -234, -234, -234, 0, -234, -234, -234, 0, -234, -234, -234, -234, -234, 0, -234, -234, -234, -234, -234, -234, -234, 0, -234, -234, -234, -234, -234, -234, -234, -234, -234, 0, -234, -234, -234, -234, 0, -234, -234, -234, 0, -234, -234,\n // State 236\n 0, 106, 107, 0, 0, 0, 0, 0, 0, 0, 108, 0, 0, 0, 0, 9, 27, 0, 28, 29, 85, 109, 0, 0, 110, 0, 111, 112, 113, 114, 0, 115, 0, 116, 117, 0, 0, 118, 119, 120, 0, 121, 0, 0, 0, 0, 122,\n // State 237\n 0, -189, -189, 0, 0, 0, 0, 0, 0, 0, -189, 0, 0, 0, 0, -189, -189, 0, -189, -189, -189, -189, 0, 0, -189, 0, -189, -189, -189, -189, 0, -189, 0, -189, -189, 0, 0, -189, -189, -189, 0, -189, 0, 0, 0, 0, -189,\n // State 238\n 0, -190, -190, 0, 0, 0, 0, 0, 0, 0, -190, 0, 0, 0, 0, -190, -190, 0, -190, -190, -190, -190, 0, 0, -190, 0, -190, -190, -190, -190, 0, -190, 0, -190, -190, 0, 0, -190, -190, -190, 0, -190, 0, 0, 0, 0, -190,\n // State 239\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 238, 0, 0, 239, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 240\n 0, 0, 0, 0, 0, 0, 11, 0, 0, -108, 0, 0, -108, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 241\n 0, 0, 0, 0, 0, 0, 11, 0, 0, -112, 0, 0, -112, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 242\n -47, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -47, 0, 0,\n // State 243\n 0, 106, 107, -169, 0, 0, 0, 0, 0, 0, 108, 0, 0, 0, 0, 9, 27, 0, 28, 29, 85, 109, 0, 0, 110, 0, 111, 112, 113, 114, 0, 115, 0, 116, 117, 0, 0, 118, 119, 120, 0, 121, 0, 0, 0, 0, 122,\n // State 244\n 0, -109, -109, -109, -109, -109, -109, 0, -109, -109, -109, 0, -109, -109, -109, -109, -109, 0, -109, -109, -109, -109, -109, -109, -109, 0, -109, -109, -109, -109, -109, -109, -109, -109, -109, 0, -109, -109, -109, -109, 0, -109, -109, -109, 0, -109, -109,\n // State 245\n 0, -113, -113, -113, -113, -113, -113, 0, -113, -113, -113, 0, -113, -113, -113, -113, -113, 0, -113, -113, -113, -113, -113, -113, -113, 0, -113, -113, -113, -113, -113, -113, -113, -113, -113, 0, -113, -113, -113, -113, 0, -113, -113, -113, 0, -113, -113,\n // State 246\n 0, -24, -24, -24, 0, 0, 0, 0, 0, 0, 0, 0, 0, -24, 0, -24, -24, 0, -24, -24, -24, -24, 0, 0, -24, 0, -24, -24, -24, -24, 0, -24, 0, -24, -24, 0, 0, -24, -24, -24, 0, -24, 0, 0, 0, 0, -24,\n // State 247\n 0, -57, -57, -57, 0, 0, 0, 0, 0, 0, -57, 0, 0, 0, 0, -57, -57, 0, -57, -57, -57, -57, -57, 0, -57, 0, -57, -57, -57, -57, 0, -57, 0, -57, -57, 0, 0, -57, -57, -57, 0, -57, -57, -57, 0, 0, -57,\n // State 248\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 303, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 249\n 0, 0, 0, 304, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 250\n 0, 0, 305, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 251\n 0, 161, 162, 0, 0, 0, 0, 0, 0, 0, 163, 0, 0, 0, 0, 9, 27, 0, 28, 29, 85, 164, 0, 0, 0, 0, 0, 0, 0, 0, 306, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 166, 0, 0, 0, 0, 167,\n // State 252\n 0, -238, -238, -238, -238, -238, -238, 0, -238, -238, -238, 0, -238, -238, -238, -238, -238, 0, -238, -238, -238, -238, -238, -238, -238, 0, -238, -238, -238, -238, -238, -238, -238, -238, -238, 0, -238, -238, -238, -238, 0, -238, -238, -238, 0, -238, -238,\n // State 253\n 0, -228, -228, -228, -228, -228, -228, 0, -228, -228, -228, 0, -228, -228, -228, -228, -228, 0, -228, -228, -228, -228, -228, -228, -228, 0, -228, -228, -228, -228, -228, -228, -228, -228, -228, 0, -228, -228, -228, -228, 0, -228, -228, -228, 0, -228, -228,\n // State 254\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 307, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 255\n 0, 0, 0, 0, 0, -251, 0, 0, 0, 0, 0, -251, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 256\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 69, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 257\n 0, -247, -247, -247, -247, -247, -247, 0, -247, -247, -247, 0, -247, -247, -247, -247, -247, 0, -247, -247, -247, -247, -247, -247, -247, 0, -247, -247, -247, -247, -247, -247, -247, -247, -247, 0, -247, -247, -247, -247, 0, -247, -247, -247, 0, -247, -247,\n // State 258\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -65, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -65, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 259\n 0, 0, 0, 309, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 260\n 0, 0, 0, 310, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 261\n 0, 0, 0, 0, 0, 311, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 262\n 0, 0, 0, 0, -90, 0, -90, 0, 0, 0, 0, 0, 0, -90, -90, 0, 0, 0, 0, 0, 0, 0, -90, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -90, 0, -90, -90, 0, -90, 0,\n // State 263\n 0, 106, 107, 0, 0, 0, 0, 0, 0, 0, 108, 0, 0, 0, 0, 9, 27, 0, 28, 29, 85, 109, 0, 0, 110, 0, 111, 112, 113, 114, 0, 115, 0, 116, 117, 0, 0, 118, 119, 120, 0, 121, 0, 0, 0, 0, 122,\n // State 264\n 0, 0, 0, 0, 0, -204, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 265\n 0, 0, 0, 0, 313, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -178, 0, 0,\n // State 266\n 0, 0, 0, 0, -218, 0, -218, 0, 0, 0, 0, 0, 0, -218, -218, 0, 0, 0, 0, 0, 0, 0, -218, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -218, 0, -218, -218, 0, -218, 0,\n // State 267\n -70, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -70, 0, 0,\n // State 268\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 314, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 269\n 0, 161, 214, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 27, 0, 28, 29, 85, 164, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 166, 0, 0, 0, 0, 167,\n // State 270\n 0, 0, 0, 316, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 271\n 0, 0, 0, 317, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 272\n 0, 0, 0, 318, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 273\n 0, 0, 0, 319, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 274\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 320, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 275\n 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 276\n 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 277\n 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 0, -114, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 278\n 0, 161, 214, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 27, 0, 28, 29, 85, 164, -153, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 166, -153, 0, 0, 0, 167,\n // State 279\n 0, 161, 214, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 27, 0, 28, 29, 85, 164, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 166, 0, -153, 0, 0, 167,\n // State 280\n 0, 106, 230, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 27, 0, 28, 29, 85, 109, 0, 0, 110, 0, 111, 112, 113, 114, 0, 115, 0, 116, 117, 0, 0, 118, 119, 120, 0, 121, 0, 0, 0, -157, 122,\n // State 281\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 324, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 325, 0, 0, 0, 0,\n // State 282\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 326, 0, 0, 0,\n // State 283\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 327, 0,\n // State 284\n 0, 0, 0, 0, 328, 0, 0, 0, 0, 0, 0, 0, 0, -154, 0, 0, 0, 0, 0, 0, 0, 0, -154, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -154, -154, 0, 0, 0,\n // State 285\n 0, -33, -33, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -33, 0, -33, -33, 0, -33, -33, -33, -33, -33, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -33, -33, -33, 0, 0, -33,\n // State 286\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -224, 0, 0, 0, 0, 0, 0,\n // State 287\n 0, 0, 0, 0, -97, 0, -97, 0, 0, 0, 0, 0, 0, -97, -97, 0, 0, 0, 0, 0, 0, 0, -97, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -97, 0, -97, -97, 0, -97, 0,\n // State 288\n 0, 161, 214, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 27, 0, 28, 29, 85, 164, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 166, 0, 0, 0, 0, 167,\n // State 289\n 0, 106, 107, 0, 0, 0, 0, 0, 0, 0, 108, 0, 0, 0, 0, 9, 27, 0, 28, 29, 85, 109, 0, 0, 110, 0, 111, 112, 113, 114, 0, 115, 0, 116, 117, 0, 0, 118, 119, 120, 0, 121, 0, 0, 0, 0, 122,\n // State 290\n 0, 0, 0, 0, -94, 0, -94, 0, 0, 0, 0, 0, 0, -94, -94, 0, 0, 0, 0, 0, 0, 0, -94, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -94, 0, -94, -94, 0, -94, 0,\n // State 291\n 0, 0, 0, 0, 331, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -158, 0,\n // State 292\n 0, 161, 214, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 27, 0, 28, 29, 85, 164, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 166, 0, 0, 0, 0, 167,\n // State 293\n 0, -38, -38, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -38, -38, 0, -38, -38, -38, -38, 0, 0, -38, 0, -38, -38, -38, -38, 0, -38, 0, -38, -38, 0, 0, -38, -38, -38, 0, -38, 0, 0, 0, -38, -38,\n // State 294\n 0, 0, 0, 0, -95, 0, -95, 0, 0, 0, 0, 0, 0, -95, -95, 0, 0, 0, 0, 0, 0, 0, -95, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -95, 0, -95, -95, 0, -95, 0,\n // State 295\n 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 296\n 0, 0, 0, 0, 0, 334, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 297\n 0, -19, -19, 0, 0, 0, 0, 0, 0, 0, -19, 0, 0, 0, 0, -19, -19, 0, -19, -19, -19, -19, 0, 0, -19, 0, -19, -19, -19, -19, 0, -19, 0, -19, -19, 0, 0, -19, -19, -19, 0, -19, -19, 0, 0, -19, -19,\n // State 298\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 335, 0,\n // State 299\n 0, 0, 0, 0, -72, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -72, 0, 0, -72, 0,\n // State 300\n 0, 106, 107, 0, 0, 0, 0, 0, 0, 0, 108, 0, 0, 0, 0, 9, 27, 0, 28, 29, 85, 109, 0, 0, 110, 0, 111, 112, 113, 114, 0, 115, 0, 116, 117, 0, 0, 118, 119, 120, 0, 121, 0, 0, 0, 0, 122,\n // State 301\n 0, 0, 0, 337, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 302\n 0, -225, -225, -225, -225, -225, -225, 0, -225, -225, -225, 0, -225, -225, -225, -225, -225, 0, -225, -225, -225, -225, -225, -225, -225, 0, -225, -225, -225, -225, -225, -225, -225, -225, -225, 0, -225, -225, -225, -225, 0, -225, -225, -225, 0, -225, -225,\n // State 303\n 0, -242, -242, -242, -242, -242, -242, 0, -242, -242, -242, 0, -242, -242, -242, -242, -242, 0, -242, -242, -242, -242, -242, -242, -242, 0, -242, -242, -242, -242, -242, -242, -242, -242, -242, 0, -242, -242, -242, -242, 0, -242, -242, -242, 0, -242, -242,\n // State 304\n 0, 106, 107, -169, 0, 0, 0, 0, 0, 0, 108, 0, 0, 0, 0, 9, 27, 0, 28, 29, 85, 109, 0, 0, 110, 0, 111, 112, 113, 114, 0, 115, 0, 116, 117, 0, 0, 118, 119, 120, 0, 121, 0, 0, 0, 0, 122,\n // State 305\n 0, -239, -239, -239, -239, -239, -239, 0, -239, -239, -239, 0, -239, -239, -239, -239, -239, 0, -239, -239, -239, -239, -239, -239, -239, 0, -239, -239, -239, -239, -239, -239, -239, -239, -239, 0, -239, -239, -239, -239, 0, -239, -239, -239, 0, -239, -239,\n // State 306\n 0, 106, 107, 0, 0, 0, 0, 0, 0, 0, 108, 0, 0, 0, 0, 9, 27, 0, 28, 29, 85, 109, 0, 0, 110, 0, 111, 112, 113, 114, 0, 115, 0, 116, 117, 0, 0, 118, 119, 120, 0, 121, 0, 0, 0, 0, 122,\n // State 307\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -66, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -66, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 308\n 0, -240, -240, -240, -240, -240, -240, 0, -240, -240, -240, 0, -240, -240, -240, -240, -240, 0, -240, -240, -240, -240, -240, -240, -240, 0, -240, -240, -240, -240, -240, -240, -240, -240, -240, 0, -240, -240, -240, -240, 0, -240, -240, -240, 0, -240, -240,\n // State 309\n 0, 0, -77, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 310\n 0, 106, 107, 0, 0, 0, 0, 0, 0, 0, 108, 0, 0, 0, 0, 9, 27, 0, 28, 29, 85, 109, 0, 0, 110, 0, 111, 112, 113, 114, 0, 115, 0, 116, 117, 0, 0, 118, 119, 120, 0, 121, 0, 0, 0, 0, 122,\n // State 311\n 0, -135, -135, 0, 0, 0, -135, 0, 0, 0, -135, 0, 0, 0, 0, -135, -135, 0, -135, -135, -135, -135, 0, -135, 0, 0, 0, 0, 0, 0, -135, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -135, 0, 0, 0, 0, -135,\n // State 312\n -71, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -71, 0, 0,\n // State 313\n 0, 106, 133, -145, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 27, 0, 28, 29, 85, 109, 0, 0, 110, 0, 111, 112, 113, 114, 0, 115, 0, 116, 117, 0, 0, 118, 119, 120, 0, 121, 0, 0, 0, 0, 122,\n // State 314\n 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -90, 0, 0, 0, 0, 0, 0,\n // State 315\n 0, 0, 0, 0, -100, 0, -100, 0, 0, 0, 0, 0, 0, -100, -100, 0, 0, 0, 0, 0, 0, 0, -100, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -100, 0, -100, -100, 0, -100, 0,\n // State 316\n 0, -79, -79, 0, 0, 0, 0, 0, 0, 0, -79, 0, 0, 0, 0, -79, -79, 0, -79, -79, -79, -79, 0, -79, 0, 0, 0, 0, 0, 0, -79, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -79, 0, 0, 0, 0, -79,\n // State 317\n 0, 0, 0, 0, -101, 0, -101, 0, 0, 0, 0, 0, 0, -101, -101, 0, 0, 0, 0, 0, 0, 0, -101, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -101, 0, -101, -101, 0, -101, 0,\n // State 318\n 0, 0, 0, 0, -99, 0, -99, 0, 0, 0, 0, -115, 0, -99, -99, 0, 0, 0, 0, 0, 0, 0, -99, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -99, 0, -99, -99, 0, -99, 0,\n // State 319\n 0, 161, 214, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 27, 0, 28, 29, 85, 164, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 166, 0, 0, 0, 0, 167,\n // State 320\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 344, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 345, 0, 0, 0, 0,\n // State 321\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 346, 0, 0, 0,\n // State 322\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 347, 0,\n // State 323\n 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -97, 0, 0, 0, 0, 0, 0,\n // State 324\n 0, 161, 214, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 27, 0, 28, 29, 85, 164, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 166, 0, 0, 0, 0, 167,\n // State 325\n 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -94, 0, 0, 0, 0, 0, 0,\n // State 326\n 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -95, 0, 0, 0, 0, 0, 0,\n // State 327\n 0, -34, -34, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -34, 0, -34, -34, 0, -34, -34, -34, -34, -34, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -34, -34, -34, 0, 0, -34,\n // State 328\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 352, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 329\n 0, -244, -244, -244, -244, -244, -244, 0, -244, -244, -244, 0, -244, -244, -244, -244, -244, 0, -244, -244, -244, -244, -244, -244, -244, 0, -244, -244, -244, -244, -244, -244, -244, -244, -244, 0, -244, -244, -244, -244, 0, -244, -244, -244, 0, -244, -244,\n // State 330\n 0, -39, -39, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -39, -39, 0, -39, -39, -39, -39, 0, 0, -39, 0, -39, -39, -39, -39, 0, -39, 0, -39, -39, 0, 0, -39, -39, -39, 0, -39, 0, 0, 0, -39, -39,\n // State 331\n 0, 0, 0, 0, -222, 0, -222, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -222, 0,\n // State 332\n 0, 0, 0, 353, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 333\n 0, 106, 107, 0, 0, 0, 0, 0, 0, 0, 108, 0, 0, 0, 0, 9, 27, 0, 28, 29, 85, 109, 0, 0, 110, 0, 111, 112, 113, 114, 0, 115, 0, 116, 117, 0, 0, 118, 119, 120, 0, 121, 0, 0, 0, 0, 122,\n // State 334\n 0, -233, -233, -233, -233, -233, -233, 0, -233, -233, -233, 0, -233, -233, -233, -233, -233, 0, -233, -233, -233, -233, -233, -233, -233, 0, -233, -233, -233, -233, -233, -233, -233, -233, -233, 0, -233, -233, -233, -233, 0, -233, -233, -233, 0, -233, -233,\n // State 335\n 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 336\n 0, 0, 0, 0, -132, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -132, 0, 0,\n // State 337\n 0, 0, 0, 356, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 338\n 0, -235, -235, -235, -235, -235, -235, 0, -235, -235, -235, 0, -235, -235, -235, -235, -235, 0, -235, -235, -235, -235, -235, -235, -235, 0, -235, -235, -235, -235, -235, -235, -235, -235, -235, 0, -235, -235, -235, -235, 0, -235, -235, -235, 0, -235, -235,\n // State 339\n 0, -245, -245, -245, -245, -245, -245, 0, -245, -245, -245, 0, -245, -245, -245, -245, -245, 0, -245, -245, -245, -245, -245, -245, -245, 0, -245, -245, -245, -245, -245, -245, -245, -245, -245, 0, -245, -245, -245, -245, 0, -245, -245, -245, 0, -245, -245,\n // State 340\n 0, 0, 0, 357, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 341\n 0, 0, 0, 358, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 342\n 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 343\n 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 344\n 0, 161, 214, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 27, 0, 28, 29, 85, 164, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 166, 0, 0, 0, 0, 167,\n // State 345\n 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 346\n 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 347\n 0, 0, 0, 360, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 348\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 361, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 349\n 0, 0, 0, 362, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 350\n 0, 0, 0, 363, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 351\n 0, 0, 0, 0, -96, 0, -96, 0, 0, 0, 0, 0, 0, -96, -96, 0, 0, 0, 0, 0, 0, 0, -96, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -96, 0, -96, -96, 0, -96, 0,\n // State 352\n 0, 0, 0, 0, -107, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -107, 0,\n // State 353\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 364, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 354\n 0, 0, 0, 365, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 355\n 0, -236, -236, -236, -236, -236, -236, 0, -236, -236, -236, 0, -236, -236, -236, -236, -236, 0, -236, -236, -236, -236, -236, -236, -236, 0, -236, -236, -236, -236, -236, -236, -236, -236, -236, 0, -236, -236, -236, -236, 0, -236, -236, -236, 0, -236, -236,\n // State 356\n 0, 0, 0, 0, -219, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -219, 0, 0,\n // State 357\n 0, 0, 0, 0, -98, 0, -98, 0, 0, 0, 0, 0, 0, -98, -98, 0, 0, 0, 0, 0, 0, 0, -98, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -98, 0, -98, -98, 0, -98, 0,\n // State 358\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 366, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 359\n 0, 0, 0, 0, -105, 0, -105, 0, 0, 0, 0, 0, 0, -105, -105, 0, 0, 0, 0, 0, 0, 0, -105, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -105, 0, -105, -105, 0, -105, 0,\n // State 360\n 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -96, 0, 0, 0, 0, 0, 0,\n // State 361\n 0, 0, 0, 0, -102, 0, -102, 0, 0, 0, 0, 0, 0, -102, -102, 0, 0, 0, 0, 0, 0, 0, -102, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -102, 0, -102, -102, 0, -102, 0,\n // State 362\n 0, 0, 0, 0, -103, 0, -103, 0, 0, 0, 0, 0, 0, -103, -103, 0, 0, 0, 0, 0, 0, 0, -103, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -103, 0, -103, -103, 0, -103, 0,\n // State 363\n 0, 0, 84, 0, 0, 0, 0, 0, 0, 0, 145, 0, 0, 0, 0, 0, 0, 0, 0, 0, 85, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 364\n 0, 0, 0, 0, -73, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -73, 0, 0, -73, 0,\n // State 365\n 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 366\n 0, 0, 0, 369, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 367\n 0, 0, 0, 0, 0, 370, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 368\n 0, 0, 0, 0, -104, 0, -104, 0, 0, 0, 0, 0, 0, -104, -104, 0, 0, 0, 0, 0, 0, 0, -104, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -104, 0, -104, -104, 0, -104, 0,\n // State 369\n 0, 106, 107, 0, 0, 0, 0, 0, 0, 0, 108, 0, 0, 0, 0, 9, 27, 0, 28, 29, 85, 109, 0, 0, 110, 0, 111, 112, 113, 114, 0, 115, 0, 116, 117, 0, 0, 118, 119, 120, 0, 121, 0, 0, 0, 0, 122,\n // State 370\n 0, -243, -243, -243, -243, -243, -243, 0, -243, -243, -243, 0, -243, -243, -243, -243, -243, 0, -243, -243, -243, -243, -243, -243, -243, 0, -243, -243, -243, -243, -243, -243, -243, -243, -243, 0, -243, -243, -243, -243, 0, -243, -243, -243, 0, -243, -243,\n ];\n const __EOF_ACTION: &'static [i16] = &[\n // State 0\n 0,\n // State 1\n -118,\n // State 2\n -252,\n // State 3\n -88,\n // State 4\n 0,\n // State 5\n 0,\n // State 6\n 0,\n // State 7\n 0,\n // State 8\n 0,\n // State 9\n 0,\n // State 10\n 0,\n // State 11\n 0,\n // State 12\n 0,\n // State 13\n -89,\n // State 14\n 0,\n // State 15\n 0,\n // State 16\n 0,\n // State 17\n 0,\n // State 18\n 0,\n // State 19\n 0,\n // State 20\n 0,\n // State 21\n 0,\n // State 22\n 0,\n // State 23\n 0,\n // State 24\n 0,\n // State 25\n 0,\n // State 26\n 0,\n // State 27\n 0,\n // State 28\n 0,\n // State 29\n 0,\n // State 30\n 0,\n // State 31\n 0,\n // State 32\n 0,\n // State 33\n 0,\n // State 34\n 0,\n // State 35\n 0,\n // State 36\n 0,\n // State 37\n 0,\n // State 38\n 0,\n // State 39\n 0,\n // State 40\n 0,\n // State 41\n 0,\n // State 42\n 0,\n // State 43\n 0,\n // State 44\n 0,\n // State 45\n 0,\n // State 46\n 0,\n // State 47\n -206,\n // State 48\n 0,\n // State 49\n 0,\n // State 50\n 0,\n // State 51\n 0,\n // State 52\n 0,\n // State 53\n 0,\n // State 54\n 0,\n // State 55\n 0,\n // State 56\n 0,\n // State 57\n 0,\n // State 58\n 0,\n // State 59\n -207,\n // State 60\n 0,\n // State 61\n 0,\n // State 62\n 0,\n // State 63\n 0,\n // State 64\n 0,\n // State 65\n 0,\n // State 66\n 0,\n // State 67\n 0,\n // State 68\n 0,\n // State 69\n 0,\n // State 70\n 0,\n // State 71\n 0,\n // State 72\n 0,\n // State 73\n 0,\n // State 74\n 0,\n // State 75\n 0,\n // State 76\n 0,\n // State 77\n 0,\n // State 78\n 0,\n // State 79\n 0,\n // State 80\n 0,\n // State 81\n 0,\n // State 82\n 0,\n // State 83\n 0,\n // State 84\n 0,\n // State 85\n 0,\n // State 86\n 0,\n // State 87\n 0,\n // State 88\n 0,\n // State 89\n 0,\n // State 90\n 0,\n // State 91\n 0,\n // State 92\n 0,\n // State 93\n 0,\n // State 94\n 0,\n // State 95\n 0,\n // State 96\n 0,\n // State 97\n 0,\n // State 98\n 0,\n // State 99\n 0,\n // State 100\n 0,\n // State 101\n 0,\n // State 102\n 0,\n // State 103\n 0,\n // State 104\n 0,\n // State 105\n 0,\n // State 106\n 0,\n // State 107\n 0,\n // State 108\n 0,\n // State 109\n 0,\n // State 110\n 0,\n // State 111\n 0,\n // State 112\n 0,\n // State 113\n 0,\n // State 114\n 0,\n // State 115\n 0,\n // State 116\n 0,\n // State 117\n 0,\n // State 118\n 0,\n // State 119\n 0,\n // State 120\n 0,\n // State 121\n 0,\n // State 122\n 0,\n // State 123\n 0,\n // State 124\n 0,\n // State 125\n 0,\n // State 126\n 0,\n // State 127\n 0,\n // State 128\n 0,\n // State 129\n 0,\n // State 130\n 0,\n // State 131\n 0,\n // State 132\n 0,\n // State 133\n 0,\n // State 134\n 0,\n // State 135\n 0,\n // State 136\n 0,\n // State 137\n 0,\n // State 138\n 0,\n // State 139\n 0,\n // State 140\n 0,\n // State 141\n 0,\n // State 142\n 0,\n // State 143\n 0,\n // State 144\n 0,\n // State 145\n 0,\n // State 146\n 0,\n // State 147\n 0,\n // State 148\n 0,\n // State 149\n 0,\n // State 150\n 0,\n // State 151\n 0,\n // State 152\n 0,\n // State 153\n 0,\n // State 154\n 0,\n // State 155\n 0,\n // State 156\n 0,\n // State 157\n 0,\n // State 158\n 0,\n // State 159\n 0,\n // State 160\n 0,\n // State 161\n 0,\n // State 162\n 0,\n // State 163\n 0,\n // State 164\n 0,\n // State 165\n 0,\n // State 166\n 0,\n // State 167\n 0,\n // State 168\n 0,\n // State 169\n 0,\n // State 170\n 0,\n // State 171\n 0,\n // State 172\n 0,\n // State 173\n 0,\n // State 174\n 0,\n // State 175\n 0,\n // State 176\n 0,\n // State 177\n 0,\n // State 178\n 0,\n // State 179\n 0,\n // State 180\n 0,\n // State 181\n 0,\n // State 182\n 0,\n // State 183\n 0,\n // State 184\n 0,\n // State 185\n 0,\n // State 186\n 0,\n // State 187\n 0,\n // State 188\n 0,\n // State 189\n 0,\n // State 190\n 0,\n // State 191\n 0,\n // State 192\n 0,\n // State 193\n 0,\n // State 194\n 0,\n // State 195\n 0,\n // State 196\n 0,\n // State 197\n 0,\n // State 198\n 0,\n // State 199\n 0,\n // State 200\n 0,\n // State 201\n 0,\n // State 202\n 0,\n // State 203\n 0,\n // State 204\n 0,\n // State 205\n 0,\n // State 206\n 0,\n // State 207\n 0,\n // State 208\n 0,\n // State 209\n 0,\n // State 210\n 0,\n // State 211\n 0,\n // State 212\n 0,\n // State 213\n 0,\n // State 214\n 0,\n // State 215\n 0,\n // State 216\n 0,\n // State 217\n 0,\n // State 218\n 0,\n // State 219\n 0,\n // State 220\n 0,\n // State 221\n 0,\n // State 222\n 0,\n // State 223\n 0,\n // State 224\n 0,\n // State 225\n 0,\n // State 226\n 0,\n // State 227\n 0,\n // State 228\n 0,\n // State 229\n 0,\n // State 230\n 0,\n // State 231\n 0,\n // State 232\n 0,\n // State 233\n 0,\n // State 234\n 0,\n // State 235\n 0,\n // State 236\n 0,\n // State 237\n 0,\n // State 238\n 0,\n // State 239\n 0,\n // State 240\n 0,\n // State 241\n 0,\n // State 242\n 0,\n // State 243\n 0,\n // State 244\n 0,\n // State 245\n 0,\n // State 246\n 0,\n // State 247\n 0,\n // State 248\n 0,\n // State 249\n 0,\n // State 250\n 0,\n // State 251\n 0,\n // State 252\n 0,\n // State 253\n 0,\n // State 254\n 0,\n // State 255\n 0,\n // State 256\n 0,\n // State 257\n 0,\n // State 258\n 0,\n // State 259\n 0,\n // State 260\n 0,\n // State 261\n 0,\n // State 262\n 0,\n // State 263\n 0,\n // State 264\n 0,\n // State 265\n 0,\n // State 266\n 0,\n // State 267\n 0,\n // State 268\n 0,\n // State 269\n 0,\n // State 270\n 0,\n // State 271\n 0,\n // State 272\n 0,\n // State 273\n 0,\n // State 274\n 0,\n // State 275\n 0,\n // State 276\n 0,\n // State 277\n 0,\n // State 278\n 0,\n // State 279\n 0,\n // State 280\n 0,\n // State 281\n 0,\n // State 282\n 0,\n // State 283\n 0,\n // State 284\n 0,\n // State 285\n 0,\n // State 286\n 0,\n // State 287\n 0,\n // State 288\n 0,\n // State 289\n 0,\n // State 290\n 0,\n // State 291\n 0,\n // State 292\n 0,\n // State 293\n 0,\n // State 294\n 0,\n // State 295\n 0,\n // State 296\n 0,\n // State 297\n 0,\n // State 298\n 0,\n // State 299\n 0,\n // State 300\n 0,\n // State 301\n 0,\n // State 302\n 0,\n // State 303\n 0,\n // State 304\n 0,\n // State 305\n 0,\n // State 306\n 0,\n // State 307\n 0,\n // State 308\n 0,\n // State 309\n 0,\n // State 310\n 0,\n // State 311\n 0,\n // State 312\n 0,\n // State 313\n 0,\n // State 314\n 0,\n // State 315\n 0,\n // State 316\n 0,\n // State 317\n 0,\n // State 318\n 0,\n // State 319\n 0,\n // State 320\n 0,\n // State 321\n 0,\n // State 322\n 0,\n // State 323\n 0,\n // State 324\n 0,\n // State 325\n 0,\n // State 326\n 0,\n // State 327\n 0,\n // State 328\n 0,\n // State 329\n 0,\n // State 330\n 0,\n // State 331\n 0,\n // State 332\n 0,\n // State 333\n 0,\n // State 334\n 0,\n // State 335\n 0,\n // State 336\n 0,\n // State 337\n 0,\n // State 338\n 0,\n // State 339\n 0,\n // State 340\n 0,\n // State 341\n 0,\n // State 342\n 0,\n // State 343\n 0,\n // State 344\n 0,\n // State 345\n 0,\n // State 346\n 0,\n // State 347\n 0,\n // State 348\n 0,\n // State 349\n 0,\n // State 350\n 0,\n // State 351\n 0,\n // State 352\n 0,\n // State 353\n 0,\n // State 354\n 0,\n // State 355\n 0,\n // State 356\n 0,\n // State 357\n 0,\n // State 358\n 0,\n // State 359\n 0,\n // State 360\n 0,\n // State 361\n 0,\n // State 362\n 0,\n // State 363\n 0,\n // State 364\n 0,\n // State 365\n 0,\n // State 366\n 0,\n // State 367\n 0,\n // State 368\n 0,\n // State 369\n 0,\n // State 370\n 0,\n ];\n const __GOTO: &'static [i16] = &[\n // State 0\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 1\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 2\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 3\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 4\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 5\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 6\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 7\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 8\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 9\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 10\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 11\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 12\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 17, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 18, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 19, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 20, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 13\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 14\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 21, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 22, 23, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 24, 0, 0, 0, 25, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 26, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 15\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 16\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 18, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 34, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 17\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 18\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 19\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 20\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 22, 23, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 38, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 26, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 21\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 22\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 23\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 24\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 25\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 26\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 27\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 28\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 29\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 21, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 22, 23, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 41, 0, 0, 0, 25, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 26, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 30\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 21, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 22, 23, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 42, 0, 0, 0, 25, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 26, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 31\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 43, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 18, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 44, 0, 45, 46, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 32\n 0, 0, 0, 0, 0, 0, 0, 0, 49, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 50, 0, 0, 0, 0, 0, 51, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 33\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 34\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 53, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 35\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 36\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 37\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 38\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 39\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 40\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 41\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 42\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 43\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 44\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 43, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 18, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 59, 0, 0, 46, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 45\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 46\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 18, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 61, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 47\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 48\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 62, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 49\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 50\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 51\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 52\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 53\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 54\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 55\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 22, 23, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 65, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 26, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 56\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 57\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 66, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 67, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 58\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 59\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 60\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 70, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 61\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 62\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 22, 23, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 72, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 26, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 63\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 64\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 65\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 66\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 67\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 74, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 68\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 69\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 70\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 22, 23, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 77, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 26, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 71\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 72\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 73\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 79, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 74\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 81, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 82, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 83, 0, 0,\n // State 75\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 76\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 77\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 78\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 79\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 88, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 83, 0, 0,\n // State 80\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 81\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 82\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 83\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 91, 0, 0,\n // State 84\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 85\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 86\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 87\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 88\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 89\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 90\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 94, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 91\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 92\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 95, 0, 96, 0, 0, 0, 0, 0, 0, 0, 0, 97, 98, 99, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 100, 0, 101, 0, 0, 0, 102, 0, 0, 26, 0, 0, 0, 0, 0, 0, 0, 0, 0, 103, 104, 105, 0, 0,\n // State 93\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 94\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 95\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 96\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 97\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 98\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 99\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 100\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 101\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 102\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 103\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 104\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 105\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 124, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 125, 0, 0, 0, 0, 0, 0, 0, 0, 126, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 106\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 97, 98, 99, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 101, 0, 0, 0, 102, 0, 0, 26, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 129, 105, 0, 0,\n // State 107\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 130, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 131, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 97, 98, 99, 0, 0, 0, 0, 0, 132, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 101, 0, 0, 0, 102, 0, 0, 26, 0, 0, 0, 0, 0, 0, 0, 0, 0, 103, 0, 105, 0, 0,\n // State 108\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 134, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 95, 0, 96, 0, 0, 0, 0, 0, 0, 0, 0, 97, 98, 99, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 135, 0, 0, 0, 0, 0, 0, 0, 136, 0, 101, 0, 0, 0, 102, 0, 0, 26, 0, 0, 0, 0, 0, 0, 0, 0, 0, 103, 104, 105, 0, 0,\n // State 109\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 95, 0, 96, 0, 0, 0, 0, 0, 0, 0, 0, 97, 98, 99, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 137, 0, 101, 0, 0, 0, 102, 0, 0, 26, 0, 0, 0, 0, 0, 0, 0, 0, 0, 103, 104, 105, 0, 0,\n // State 110\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 95, 0, 96, 0, 0, 0, 0, 0, 0, 0, 0, 97, 98, 99, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 138, 0, 101, 0, 0, 0, 102, 0, 0, 26, 0, 0, 0, 0, 0, 0, 0, 0, 0, 103, 104, 105, 0, 0,\n // State 111\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 95, 0, 96, 0, 0, 0, 0, 0, 0, 0, 0, 97, 98, 99, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 139, 0, 101, 0, 0, 0, 102, 0, 0, 26, 0, 0, 0, 0, 0, 0, 0, 0, 0, 103, 104, 105, 0, 0,\n // State 112\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 95, 0, 96, 0, 0, 0, 0, 0, 0, 0, 0, 97, 98, 99, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 140, 0, 101, 0, 0, 0, 102, 0, 0, 26, 0, 0, 0, 0, 0, 0, 0, 0, 0, 103, 104, 105, 0, 0,\n // State 113\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 95, 0, 96, 0, 0, 0, 0, 0, 0, 0, 0, 97, 98, 99, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 141, 0, 101, 0, 0, 0, 102, 0, 0, 26, 0, 0, 0, 0, 0, 0, 0, 0, 0, 103, 104, 105, 0, 0,\n // State 114\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 142, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 115\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 143, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 83, 144, 0,\n // State 116\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 146, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 18, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 147, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 117\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 148, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 149, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 118\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 151, 0, 152, 0, 0, 0, 153, 0, 0, 0, 0, 154, 0, 0, 155, 0, 0, 0, 0, 22, 156, 0, 0, 0, 157, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 26, 0, 0, 0, 0, 158, 0, 0, 0, 159, 0, 0, 160, 0, 0,\n // State 119\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 95, 0, 96, 0, 0, 0, 0, 0, 0, 0, 0, 97, 98, 99, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 168, 0, 101, 0, 0, 0, 102, 0, 0, 26, 0, 0, 0, 0, 0, 0, 0, 0, 0, 103, 104, 105, 0, 0,\n // State 120\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 134, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 95, 0, 96, 0, 0, 0, 0, 0, 0, 0, 0, 97, 98, 99, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 169, 0, 0, 0, 0, 0, 0, 0, 136, 0, 101, 0, 0, 0, 102, 0, 0, 26, 0, 0, 0, 0, 0, 0, 0, 0, 0, 103, 104, 105, 0, 0,\n // State 121\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 170, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 171, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 95, 0, 96, 0, 0, 0, 0, 0, 0, 0, 0, 97, 98, 99, 0, 0, 0, 0, 172, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 173, 0, 101, 0, 0, 0, 102, 0, 0, 26, 0, 0, 0, 0, 0, 0, 0, 0, 0, 103, 104, 105, 0, 0,\n // State 122\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 123\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 175, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 124\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 125\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 126\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 95, 0, 96, 0, 0, 0, 0, 0, 0, 0, 0, 97, 98, 99, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 178, 0, 101, 0, 0, 0, 102, 0, 0, 26, 0, 0, 0, 0, 0, 0, 0, 0, 0, 103, 104, 105, 0, 0,\n // State 127\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 179, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 128\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 180, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 129\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 181, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 97, 98, 99, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 101, 0, 0, 0, 102, 0, 0, 26, 0, 0, 0, 0, 0, 0, 0, 0, 0, 103, 0, 105, 0, 0,\n // State 130\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 131\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 132\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 97, 98, 99, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 101, 0, 0, 0, 102, 0, 0, 26, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 0, 105, 0, 0,\n // State 133\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 95, 0, 96, 0, 0, 0, 0, 0, 0, 0, 0, 97, 98, 99, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 184, 0, 101, 0, 0, 0, 102, 0, 0, 26, 0, 0, 0, 0, 0, 0, 0, 0, 0, 103, 104, 105, 0, 0,\n // State 134\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 135\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 136\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 137\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 138\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 139\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 140\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 95, 0, 96, 0, 0, 0, 0, 0, 0, 0, 0, 97, 98, 99, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 191, 0, 101, 0, 0, 0, 102, 0, 0, 26, 0, 0, 0, 0, 0, 0, 0, 0, 0, 103, 104, 105, 0, 0,\n // State 141\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 142\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 143\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 144\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 81, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 194, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 83, 0, 0,\n // State 145\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 18, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 195, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 146\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 147\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 148\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 149\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 199, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 150\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 151\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 200, 0, 0, 0, 0, 0, 153, 0, 0, 0, 0, 154, 0, 0, 155, 0, 0, 0, 0, 22, 156, 0, 0, 0, 157, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 26, 0, 0, 0, 0, 158, 0, 0, 0, 159, 0, 0, 160, 0, 0,\n // State 152\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 153\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 154\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 155\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 156\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 157\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 158\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 203, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 159\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 160\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 205, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 206, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 207, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 161\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 153, 0, 0, 0, 0, 209, 0, 0, 155, 0, 0, 0, 0, 22, 210, 0, 0, 0, 211, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 26, 0, 0, 0, 0, 212, 0, 0, 0, 159, 0, 0, 213, 0, 0,\n // State 162\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 218, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 153, 0, 0, 0, 0, 154, 0, 0, 219, 0, 0, 0, 0, 22, 156, 0, 0, 0, 0, 0, 0, 0, 0, 220, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 26, 0, 0, 0, 0, 158, 0, 0, 0, 0, 0, 0, 160, 0, 0,\n // State 163\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 218, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 153, 0, 0, 0, 0, 154, 0, 0, 219, 0, 0, 0, 0, 22, 156, 0, 0, 0, 0, 0, 0, 0, 0, 221, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 26, 0, 0, 0, 0, 158, 0, 0, 0, 0, 0, 0, 160, 0, 0,\n // State 164\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 95, 0, 96, 0, 0, 0, 0, 0, 0, 0, 0, 97, 98, 99, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 222, 0, 101, 0, 0, 0, 102, 0, 0, 26, 0, 0, 0, 0, 0, 0, 0, 0, 0, 103, 104, 105, 0, 0,\n // State 165\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 218, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 153, 0, 0, 0, 0, 154, 0, 0, 219, 0, 0, 0, 0, 22, 156, 0, 0, 0, 0, 0, 0, 0, 0, 223, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 26, 0, 0, 0, 0, 158, 0, 0, 0, 0, 0, 0, 160, 0, 0,\n // State 166\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 224, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 225, 226, 0, 0, 0, 0, 0, 0, 0, 227, 0, 0, 97, 98, 99, 0, 0, 0, 0, 0, 0, 0, 0, 228, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 101, 0, 0, 0, 102, 0, 0, 26, 0, 0, 0, 0, 0, 0, 0, 229, 0, 103, 0, 105, 0, 0,\n // State 167\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 168\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 169\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 233, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 95, 0, 96, 0, 0, 0, 0, 0, 0, 0, 0, 97, 98, 99, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 173, 0, 101, 0, 0, 0, 102, 0, 0, 26, 0, 0, 0, 0, 0, 0, 0, 0, 0, 103, 104, 105, 0, 0,\n // State 170\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 171\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 172\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 237, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 173\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 95, 0, 96, 0, 0, 0, 0, 0, 0, 0, 0, 97, 98, 99, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 240, 0, 101, 0, 0, 0, 102, 0, 0, 26, 0, 0, 0, 0, 0, 0, 0, 0, 0, 241, 242, 105, 0, 0,\n // State 174\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 175\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 176\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 177\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 178\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 179\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 180\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 181\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 182\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 183\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 184\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 185\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 95, 0, 96, 0, 0, 0, 0, 0, 0, 0, 0, 97, 98, 99, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 249, 0, 101, 0, 0, 0, 102, 0, 0, 26, 0, 0, 0, 0, 0, 0, 0, 0, 0, 103, 104, 105, 0, 0,\n // State 186\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 187\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 134, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 95, 0, 96, 0, 0, 0, 0, 0, 0, 0, 0, 97, 98, 99, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 250, 0, 0, 0, 0, 0, 0, 0, 136, 0, 101, 0, 0, 0, 102, 0, 0, 26, 0, 0, 0, 0, 0, 0, 0, 0, 0, 103, 104, 105, 0, 0,\n // State 188\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 95, 0, 96, 0, 0, 0, 0, 0, 0, 0, 0, 97, 98, 99, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 251, 0, 101, 0, 0, 0, 102, 0, 0, 26, 0, 0, 0, 0, 0, 0, 0, 0, 0, 103, 104, 105, 0, 0,\n // State 189\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 151, 0, 252, 0, 0, 0, 153, 0, 0, 0, 0, 154, 0, 0, 155, 0, 0, 0, 0, 22, 156, 0, 0, 0, 157, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 26, 0, 0, 0, 0, 158, 0, 0, 0, 159, 0, 0, 160, 0, 0,\n // State 190\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 191\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 18, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 254, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 192\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 95, 0, 96, 0, 0, 0, 0, 0, 0, 0, 0, 97, 98, 99, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 101, 0, 0, 0, 102, 0, 0, 26, 0, 0, 0, 0, 0, 0, 0, 0, 0, 103, 104, 105, 0, 0,\n // State 193\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 194\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 195\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 95, 0, 96, 0, 0, 0, 0, 0, 0, 0, 0, 97, 98, 99, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 258, 0, 101, 0, 0, 0, 102, 0, 0, 26, 0, 0, 0, 0, 0, 0, 0, 0, 0, 103, 104, 105, 0, 0,\n // State 196\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 259, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 197\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 134, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 95, 0, 96, 0, 0, 0, 0, 0, 0, 0, 0, 97, 98, 99, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 260, 0, 0, 0, 0, 0, 0, 0, 136, 0, 101, 0, 0, 0, 102, 0, 0, 26, 0, 0, 0, 0, 0, 0, 0, 0, 0, 103, 104, 105, 0, 0,\n // State 198\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 261, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 199\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 200\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 95, 0, 96, 0, 0, 0, 0, 0, 0, 0, 0, 97, 98, 99, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 262, 0, 101, 0, 0, 0, 102, 0, 0, 26, 0, 0, 0, 0, 0, 0, 0, 0, 0, 103, 104, 105, 0, 0,\n // State 201\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 153, 0, 0, 0, 0, 154, 0, 0, 263, 0, 0, 0, 0, 22, 156, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 26, 0, 0, 0, 0, 158, 0, 0, 0, 0, 0, 0, 160, 0, 0,\n // State 202\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 203\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 95, 0, 96, 0, 0, 0, 0, 0, 0, 0, 0, 97, 98, 99, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 265, 0, 101, 0, 0, 0, 102, 0, 0, 26, 0, 0, 0, 0, 0, 0, 0, 0, 0, 103, 104, 105, 0, 0,\n // State 204\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 266, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 205\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 206\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 207\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 153, 0, 0, 0, 0, 154, 0, 0, 269, 0, 0, 0, 0, 22, 156, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 26, 0, 0, 0, 0, 158, 0, 0, 0, 0, 0, 0, 160, 0, 0,\n // State 208\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 209\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 271, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 210\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 272, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 211\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 273, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 212\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 274, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 213\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 275, 0, 0, 0, 0, 0, 0, 0, 22, 276, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 26, 0, 0, 0, 0, 277, 0, 0, 0, 0, 0, 0, 278, 0, 0,\n // State 214\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 218, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 153, 0, 0, 0, 0, 154, 0, 0, 219, 0, 0, 0, 0, 22, 156, 0, 0, 0, 0, 0, 0, 0, 0, 282, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 26, 0, 0, 0, 0, 158, 0, 0, 0, 0, 0, 0, 160, 0, 0,\n // State 215\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 218, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 153, 0, 0, 0, 0, 154, 0, 0, 219, 0, 0, 0, 0, 22, 156, 0, 0, 0, 0, 0, 0, 0, 0, 283, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 26, 0, 0, 0, 0, 158, 0, 0, 0, 0, 0, 0, 160, 0, 0,\n // State 216\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 224, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 225, 226, 0, 0, 0, 0, 0, 0, 0, 227, 0, 0, 97, 98, 99, 0, 0, 0, 0, 0, 0, 0, 0, 284, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 101, 0, 0, 0, 102, 0, 0, 26, 0, 0, 0, 0, 0, 0, 0, 229, 0, 103, 0, 105, 0, 0,\n // State 217\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 153, 0, 0, 0, 0, 154, 0, 0, 285, 0, 0, 0, 0, 22, 156, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 26, 0, 0, 0, 0, 158, 0, 0, 0, 0, 0, 0, 160, 0, 0,\n // State 218\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 219\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 220\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 221\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 222\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 223\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 225, 226, 0, 0, 0, 0, 0, 0, 0, 292, 0, 0, 97, 98, 99, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 101, 0, 0, 0, 102, 0, 0, 26, 0, 0, 0, 0, 0, 0, 0, 229, 0, 103, 0, 105, 0, 0,\n // State 224\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 225\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 226\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 227\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 228\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 229\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 226, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 97, 98, 99, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 101, 0, 0, 0, 102, 0, 0, 26, 0, 0, 0, 0, 0, 0, 0, 296, 0, 241, 0, 105, 0, 0,\n // State 230\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 143, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 83, 297, 0,\n // State 231\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 232\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 233\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 234\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 95, 0, 96, 0, 0, 0, 0, 0, 0, 0, 0, 97, 98, 99, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 299, 0, 101, 0, 0, 0, 102, 0, 0, 26, 0, 0, 0, 0, 0, 0, 0, 0, 0, 103, 104, 105, 0, 0,\n // State 235\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 236\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 95, 0, 96, 0, 0, 0, 0, 0, 0, 0, 0, 97, 98, 99, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 300, 0, 101, 0, 0, 0, 102, 0, 0, 26, 0, 0, 0, 0, 0, 0, 0, 0, 0, 103, 104, 105, 0, 0,\n // State 237\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 238\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 239\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 301, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 240\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 179, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 241\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 180, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 242\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 243\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 134, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 95, 0, 96, 0, 0, 0, 0, 0, 0, 0, 0, 97, 98, 99, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 302, 0, 0, 0, 0, 0, 0, 0, 136, 0, 101, 0, 0, 0, 102, 0, 0, 26, 0, 0, 0, 0, 0, 0, 0, 0, 0, 103, 104, 105, 0, 0,\n // State 244\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 245\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 246\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 247\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 248\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 249\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 250\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 251\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 200, 0, 0, 0, 0, 0, 153, 0, 0, 0, 0, 154, 0, 0, 155, 0, 0, 0, 0, 22, 156, 0, 0, 0, 157, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 26, 0, 0, 0, 0, 158, 0, 0, 0, 159, 0, 0, 160, 0, 0,\n // State 252\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 253\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 254\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 255\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 256\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 308, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 257\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 258\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 259\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 260\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 261\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 262\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 263\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 95, 0, 96, 0, 0, 0, 0, 0, 0, 0, 0, 97, 98, 99, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 312, 0, 101, 0, 0, 0, 102, 0, 0, 26, 0, 0, 0, 0, 0, 0, 0, 0, 0, 103, 104, 105, 0, 0,\n // State 264\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 265\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 266\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 267\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 268\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 269\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 153, 0, 0, 0, 0, 154, 0, 0, 315, 0, 0, 0, 0, 22, 156, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 26, 0, 0, 0, 0, 158, 0, 0, 0, 0, 0, 0, 160, 0, 0,\n // State 270\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 271\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 272\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 273\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 274\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 275\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 271, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 276\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 273, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 277\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 274, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 278\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 218, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 153, 0, 0, 0, 0, 154, 0, 0, 219, 0, 0, 0, 0, 22, 156, 0, 0, 0, 0, 0, 0, 0, 0, 321, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 26, 0, 0, 0, 0, 158, 0, 0, 0, 0, 0, 0, 160, 0, 0,\n // State 279\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 218, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 153, 0, 0, 0, 0, 154, 0, 0, 219, 0, 0, 0, 0, 22, 156, 0, 0, 0, 0, 0, 0, 0, 0, 322, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 26, 0, 0, 0, 0, 158, 0, 0, 0, 0, 0, 0, 160, 0, 0,\n // State 280\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 224, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 225, 226, 0, 0, 0, 0, 0, 0, 0, 227, 0, 0, 97, 98, 99, 0, 0, 0, 0, 0, 0, 0, 0, 323, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 101, 0, 0, 0, 102, 0, 0, 26, 0, 0, 0, 0, 0, 0, 0, 229, 0, 103, 0, 105, 0, 0,\n // State 281\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 282\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 283\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 284\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 285\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 286\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 287\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 288\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 153, 0, 0, 0, 0, 154, 0, 0, 329, 0, 0, 0, 0, 22, 156, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 26, 0, 0, 0, 0, 158, 0, 0, 0, 0, 0, 0, 160, 0, 0,\n // State 289\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 95, 0, 96, 0, 0, 0, 0, 0, 0, 0, 0, 97, 98, 99, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 330, 0, 101, 0, 0, 0, 102, 0, 0, 26, 0, 0, 0, 0, 0, 0, 0, 0, 0, 103, 104, 105, 0, 0,\n // State 290\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 291\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 292\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 153, 0, 0, 0, 0, 154, 0, 0, 332, 0, 0, 0, 0, 22, 156, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 26, 0, 0, 0, 0, 158, 0, 0, 0, 0, 0, 0, 160, 0, 0,\n // State 293\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 294\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 295\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 333, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 296\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 297\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 298\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 299\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 300\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 95, 0, 96, 0, 0, 0, 0, 0, 0, 0, 0, 97, 98, 99, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 336, 0, 101, 0, 0, 0, 102, 0, 0, 26, 0, 0, 0, 0, 0, 0, 0, 0, 0, 103, 104, 105, 0, 0,\n // State 301\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 302\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 303\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 304\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 134, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 95, 0, 96, 0, 0, 0, 0, 0, 0, 0, 0, 97, 98, 99, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 338, 0, 0, 0, 0, 0, 0, 0, 136, 0, 101, 0, 0, 0, 102, 0, 0, 26, 0, 0, 0, 0, 0, 0, 0, 0, 0, 103, 104, 105, 0, 0,\n // State 305\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 306\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 95, 0, 96, 0, 0, 0, 0, 0, 0, 0, 0, 97, 98, 99, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 339, 0, 101, 0, 0, 0, 102, 0, 0, 26, 0, 0, 0, 0, 0, 0, 0, 0, 0, 103, 104, 105, 0, 0,\n // State 307\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 308\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 309\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 310\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 95, 0, 96, 0, 0, 0, 0, 0, 0, 0, 0, 97, 98, 99, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 340, 0, 101, 0, 0, 0, 102, 0, 0, 26, 0, 0, 0, 0, 0, 0, 0, 0, 0, 103, 104, 105, 0, 0,\n // State 311\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 312\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 313\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 130, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 131, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 97, 98, 99, 0, 0, 0, 0, 0, 341, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 101, 0, 0, 0, 102, 0, 0, 26, 0, 0, 0, 0, 0, 0, 0, 0, 0, 103, 0, 105, 0, 0,\n // State 314\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 342, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 315\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 316\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 317\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 318\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 319\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 153, 0, 0, 0, 0, 154, 0, 0, 343, 0, 0, 0, 0, 22, 156, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 26, 0, 0, 0, 0, 158, 0, 0, 0, 0, 0, 0, 160, 0, 0,\n // State 320\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 321\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 322\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 323\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 348, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 324\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 153, 0, 0, 0, 0, 154, 0, 0, 349, 0, 0, 0, 0, 22, 156, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 26, 0, 0, 0, 0, 158, 0, 0, 0, 0, 0, 0, 160, 0, 0,\n // State 325\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 350, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 326\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 351, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 327\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 328\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 329\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 330\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 331\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 332\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 333\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 95, 0, 96, 0, 0, 0, 0, 0, 0, 0, 0, 97, 98, 99, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 354, 0, 101, 0, 0, 0, 102, 0, 0, 26, 0, 0, 0, 0, 0, 0, 0, 0, 0, 103, 104, 105, 0, 0,\n // State 334\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 335\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 355, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 336\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 337\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 338\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 339\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 340\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 341\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 342\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 342, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 343\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 348, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 344\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 153, 0, 0, 0, 0, 154, 0, 0, 359, 0, 0, 0, 0, 22, 156, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 26, 0, 0, 0, 0, 158, 0, 0, 0, 0, 0, 0, 160, 0, 0,\n // State 345\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 350, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 346\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 351, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 347\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 348\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 349\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 350\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 351\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 352\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 353\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 354\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 355\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 356\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 357\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 358\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 359\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 360\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 367, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 361\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 362\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 363\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 143, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 83, 368, 0,\n // State 364\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 365\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 367, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 366\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 367\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 368\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n // State 369\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 95, 0, 96, 0, 0, 0, 0, 0, 0, 0, 0, 97, 98, 99, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 371, 0, 101, 0, 0, 0, 102, 0, 0, 26, 0, 0, 0, 0, 0, 0, 0, 0, 0, 103, 104, 105, 0, 0,\n // State 370\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n ];\n fn __expected_tokens(__state: usize) -> Vec<::std::string::String> {\n const __TERMINAL: &'static [&'static str] = &[\n r###\"\"#<\"\"###,\n r###\"\"#{\"\"###,\n r###\"\"(\"\"###,\n r###\"\")\"\"###,\n r###\"\",\"\"###,\n r###\"\"->\"\"###,\n r###\"\"-|\"\"###,\n r###\"\"/\"\"###,\n r###\"\":\"\"###,\n r###\"\":=\"\"###,\n r###\"\"<\"\"###,\n r###\"\"=\"\"###,\n r###\"\"=>\"\"###,\n r###\"\">\"\"###,\n r###\"\">(\"\"###,\n r###\"\"Atom\"\"###,\n r###\"\"Char\"\"###,\n r###\"\"Float\"\"###,\n r###\"\"Integer\"\"###,\n r###\"\"String\"\"###,\n r###\"\"Variable\"\"###,\n r###\"\"[\"\"###,\n r###\"\"]\"\"###,\n r###\"\"after\"\"###,\n r###\"\"apply\"\"###,\n r###\"\"attributes\"\"###,\n r###\"\"call\"\"###,\n r###\"\"case\"\"###,\n r###\"\"catch\"\"###,\n r###\"\"do\"\"###,\n r###\"\"end\"\"###,\n r###\"\"fun\"\"###,\n r###\"\"in\"\"###,\n r###\"\"let\"\"###,\n r###\"\"letrec\"\"###,\n r###\"\"module\"\"###,\n r###\"\"of\"\"###,\n r###\"\"primop\"\"###,\n r###\"\"receive\"\"###,\n r###\"\"try\"\"###,\n r###\"\"when\"\"###,\n r###\"\"{\"\"###,\n r###\"\"|\"\"###,\n r###\"\"}\"\"###,\n r###\"\"}#\"\"###,\n r###\"\"}~\"\"###,\n r###\"\"~{\"\"###,\n ];\n __ACTION[(__state * 47)..].iter().zip(__TERMINAL).filter_map(|(&state, terminal)| {\n if state == 0 {\n None\n } else {\n Some(terminal.to_string())\n }\n }).collect()\n }\n pub struct __StateMachine<'input>\n where \n {\n text: &'input str,\n __phantom: ::std::marker::PhantomData<(&'input ())>,\n }\n impl<'input> __state_machine::ParserDefinition for __StateMachine<'input>\n where \n {\n type Location = usize;\n type Error = ();\n type Token = Tok<'input>;\n type TokenIndex = usize;\n type Symbol = __Symbol<'input>;\n type Success = Annotated;\n type StateIndex = i16;\n type Action = i16;\n type ReduceIndex = i16;\n type NonterminalIndex = usize;\n\n #[inline]\n fn start_location(&self) -> Self::Location {\n Default::default()\n }\n\n #[inline]\n fn start_state(&self) -> Self::StateIndex {\n 0\n }\n\n #[inline]\n fn token_to_index(&self, token: &Self::Token) -> Option {\n __token_to_integer(token, ::std::marker::PhantomData::<(&())>)\n }\n\n #[inline]\n fn action(&self, state: i16, integer: usize) -> i16 {\n __ACTION[(state as usize) * 47 + integer]\n }\n\n #[inline]\n fn error_action(&self, state: i16) -> i16 {\n __ACTION[(state as usize) * 47 + (47 - 1)]\n }\n\n #[inline]\n fn eof_action(&self, state: i16) -> i16 {\n __EOF_ACTION[state as usize]\n }\n\n #[inline]\n fn goto(&self, state: i16, nt: usize) -> i16 {\n __GOTO[(state as usize) * 112 + nt] - 1\n }\n\n fn token_to_symbol(&self, token_index: usize, token: Self::Token) -> Self::Symbol {\n __token_to_symbol(token_index, token, ::std::marker::PhantomData::<(&())>)\n }\n\n fn expected_tokens(&self, state: i16) -> Vec {\n __expected_tokens(state as usize)\n }\n\n #[inline]\n fn uses_error_recovery(&self) -> bool {\n false\n }\n\n #[inline]\n fn error_recovery_symbol(\n &self,\n recovery: __state_machine::ErrorRecovery,\n ) -> Self::Symbol {\n panic!(\"error recovery not enabled for this grammar\")\n }\n\n fn reduce(\n &mut self,\n action: i16,\n start_location: Option<&Self::Location>,\n states: &mut Vec,\n symbols: &mut Vec<__state_machine::SymbolTriple>,\n ) -> Option<__state_machine::ParseResult> {\n __reduce(\n self.text,\n action,\n start_location,\n states,\n symbols,\n ::std::marker::PhantomData::<(&())>,\n )\n }\n\n fn simulate_reduce(&self, action: i16) -> __state_machine::SimulatedReduce {\n __simulate_reduce(action, ::std::marker::PhantomData::<(&())>)\n }\n }\n fn __token_to_integer<\n 'input,\n >(\n __token: &Tok<'input>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> Option\n {\n match *__token {\n Tok::BitstringPatternOpen if true => Some(0),\n Tok::BitstringOpen if true => Some(1),\n Tok::ParenOpen if true => Some(2),\n Tok::ParenClose if true => Some(3),\n Tok::Comma if true => Some(4),\n Tok::Arrow if true => Some(5),\n Tok::Annotation if true => Some(6),\n Tok::ForwardSlash if true => Some(7),\n Tok::Colon if true => Some(8),\n Tok::MapMatch if true => Some(9),\n Tok::TriOpen if true => Some(10),\n Tok::Equals if true => Some(11),\n Tok::HashRocket if true => Some(12),\n Tok::TriClose if true => Some(13),\n Tok::BitstringPatternSep if true => Some(14),\n Tok::Atom(_) if true => Some(15),\n Tok::Char(_) if true => Some(16),\n Tok::Float(_) if true => Some(17),\n Tok::Integer(_) if true => Some(18),\n Tok::String(_) if true => Some(19),\n Tok::Variable(_) if true => Some(20),\n Tok::SquareOpen if true => Some(21),\n Tok::SquareClose if true => Some(22),\n Tok::After if true => Some(23),\n Tok::Apply if true => Some(24),\n Tok::Attributes if true => Some(25),\n Tok::Call if true => Some(26),\n Tok::Case if true => Some(27),\n Tok::Catch if true => Some(28),\n Tok::Do if true => Some(29),\n Tok::End if true => Some(30),\n Tok::Fun if true => Some(31),\n Tok::In if true => Some(32),\n Tok::Let if true => Some(33),\n Tok::Letrec if true => Some(34),\n Tok::Module if true => Some(35),\n Tok::Of if true => Some(36),\n Tok::Primop if true => Some(37),\n Tok::Receive if true => Some(38),\n Tok::Try if true => Some(39),\n Tok::When if true => Some(40),\n Tok::CurlyOpen if true => Some(41),\n Tok::Pipe if true => Some(42),\n Tok::CurlyClose if true => Some(43),\n Tok::BitstringClose if true => Some(44),\n Tok::MapClose if true => Some(45),\n Tok::MapOpen if true => Some(46),\n _ => None,\n }\n }\n fn __token_to_symbol<\n 'input,\n >(\n __token_index: usize,\n __token: Tok<'input>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> __Symbol<'input>\n {\n match __token_index {\n 0 => match __token {\n __tok @ Tok::BitstringPatternOpen => __Symbol::Variant0((__tok)),\n _ => unreachable!(),\n },\n 1 => match __token {\n __tok @ Tok::BitstringOpen => __Symbol::Variant0((__tok)),\n _ => unreachable!(),\n },\n 2 => match __token {\n __tok @ Tok::ParenOpen => __Symbol::Variant0((__tok)),\n _ => unreachable!(),\n },\n 3 => match __token {\n __tok @ Tok::ParenClose => __Symbol::Variant0((__tok)),\n _ => unreachable!(),\n },\n 4 => match __token {\n __tok @ Tok::Comma => __Symbol::Variant0((__tok)),\n _ => unreachable!(),\n },\n 5 => match __token {\n __tok @ Tok::Arrow => __Symbol::Variant0((__tok)),\n _ => unreachable!(),\n },\n 6 => match __token {\n __tok @ Tok::Annotation => __Symbol::Variant0((__tok)),\n _ => unreachable!(),\n },\n 7 => match __token {\n __tok @ Tok::ForwardSlash => __Symbol::Variant0((__tok)),\n _ => unreachable!(),\n },\n 8 => match __token {\n __tok @ Tok::Colon => __Symbol::Variant0((__tok)),\n _ => unreachable!(),\n },\n 9 => match __token {\n __tok @ Tok::MapMatch => __Symbol::Variant0((__tok)),\n _ => unreachable!(),\n },\n 10 => match __token {\n __tok @ Tok::TriOpen => __Symbol::Variant0((__tok)),\n _ => unreachable!(),\n },\n 11 => match __token {\n __tok @ Tok::Equals => __Symbol::Variant0((__tok)),\n _ => unreachable!(),\n },\n 12 => match __token {\n __tok @ Tok::HashRocket => __Symbol::Variant0((__tok)),\n _ => unreachable!(),\n },\n 13 => match __token {\n __tok @ Tok::TriClose => __Symbol::Variant0((__tok)),\n _ => unreachable!(),\n },\n 14 => match __token {\n __tok @ Tok::BitstringPatternSep => __Symbol::Variant0((__tok)),\n _ => unreachable!(),\n },\n 15 => match __token {\n Tok::Atom(__tok0) => __Symbol::Variant1((__tok0)),\n _ => unreachable!(),\n },\n 16 => match __token {\n Tok::Char(__tok0) => __Symbol::Variant2((__tok0)),\n _ => unreachable!(),\n },\n 17 => match __token {\n Tok::Float(__tok0) => __Symbol::Variant1((__tok0)),\n _ => unreachable!(),\n },\n 18 => match __token {\n Tok::Integer(__tok0) => __Symbol::Variant3((__tok0)),\n _ => unreachable!(),\n },\n 19 => match __token {\n Tok::String(__tok0) => __Symbol::Variant1((__tok0)),\n _ => unreachable!(),\n },\n 20 => match __token {\n Tok::Variable(__tok0) => __Symbol::Variant1((__tok0)),\n _ => unreachable!(),\n },\n 21 => match __token {\n __tok @ Tok::SquareOpen => __Symbol::Variant0((__tok)),\n _ => unreachable!(),\n },\n 22 => match __token {\n __tok @ Tok::SquareClose => __Symbol::Variant0((__tok)),\n _ => unreachable!(),\n },\n 23 => match __token {\n __tok @ Tok::After => __Symbol::Variant0((__tok)),\n _ => unreachable!(),\n },\n 24 => match __token {\n __tok @ Tok::Apply => __Symbol::Variant0((__tok)),\n _ => unreachable!(),\n },\n 25 => match __token {\n __tok @ Tok::Attributes => __Symbol::Variant0((__tok)),\n _ => unreachable!(),\n },\n 26 => match __token {\n __tok @ Tok::Call => __Symbol::Variant0((__tok)),\n _ => unreachable!(),\n },\n 27 => match __token {\n __tok @ Tok::Case => __Symbol::Variant0((__tok)),\n _ => unreachable!(),\n },\n 28 => match __token {\n __tok @ Tok::Catch => __Symbol::Variant0((__tok)),\n _ => unreachable!(),\n },\n 29 => match __token {\n __tok @ Tok::Do => __Symbol::Variant0((__tok)),\n _ => unreachable!(),\n },\n 30 => match __token {\n __tok @ Tok::End => __Symbol::Variant0((__tok)),\n _ => unreachable!(),\n },\n 31 => match __token {\n __tok @ Tok::Fun => __Symbol::Variant0((__tok)),\n _ => unreachable!(),\n },\n 32 => match __token {\n __tok @ Tok::In => __Symbol::Variant0((__tok)),\n _ => unreachable!(),\n },\n 33 => match __token {\n __tok @ Tok::Let => __Symbol::Variant0((__tok)),\n _ => unreachable!(),\n },\n 34 => match __token {\n __tok @ Tok::Letrec => __Symbol::Variant0((__tok)),\n _ => unreachable!(),\n },\n 35 => match __token {\n __tok @ Tok::Module => __Symbol::Variant0((__tok)),\n _ => unreachable!(),\n },\n 36 => match __token {\n __tok @ Tok::Of => __Symbol::Variant0((__tok)),\n _ => unreachable!(),\n },\n 37 => match __token {\n __tok @ Tok::Primop => __Symbol::Variant0((__tok)),\n _ => unreachable!(),\n },\n 38 => match __token {\n __tok @ Tok::Receive => __Symbol::Variant0((__tok)),\n _ => unreachable!(),\n },\n 39 => match __token {\n __tok @ Tok::Try => __Symbol::Variant0((__tok)),\n _ => unreachable!(),\n },\n 40 => match __token {\n __tok @ Tok::When => __Symbol::Variant0((__tok)),\n _ => unreachable!(),\n },\n 41 => match __token {\n __tok @ Tok::CurlyOpen => __Symbol::Variant0((__tok)),\n _ => unreachable!(),\n },\n 42 => match __token {\n __tok @ Tok::Pipe => __Symbol::Variant0((__tok)),\n _ => unreachable!(),\n },\n 43 => match __token {\n __tok @ Tok::CurlyClose => __Symbol::Variant0((__tok)),\n _ => unreachable!(),\n },\n 44 => match __token {\n __tok @ Tok::BitstringClose => __Symbol::Variant0((__tok)),\n _ => unreachable!(),\n },\n 45 => match __token {\n __tok @ Tok::MapClose => __Symbol::Variant0((__tok)),\n _ => unreachable!(),\n },\n 46 => match __token {\n __tok @ Tok::MapOpen => __Symbol::Variant0((__tok)),\n _ => unreachable!(),\n },\n _ => unreachable!(),\n }\n }\n fn __simulate_reduce<\n 'input,\n >(\n __reduce_index: i16,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> __state_machine::SimulatedReduce<__StateMachine<'input>>\n {\n match __reduce_index {\n 0 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 2,\n nonterminal_produced: 0,\n }\n }\n 1 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 2,\n nonterminal_produced: 1,\n }\n }\n 2 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 0,\n nonterminal_produced: 1,\n }\n }\n 3 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 2,\n nonterminal_produced: 2,\n }\n }\n 4 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 2,\n nonterminal_produced: 3,\n }\n }\n 5 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 0,\n nonterminal_produced: 3,\n }\n }\n 6 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 2,\n nonterminal_produced: 4,\n }\n }\n 7 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 2,\n nonterminal_produced: 5,\n }\n }\n 8 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 0,\n nonterminal_produced: 5,\n }\n }\n 9 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 4,\n nonterminal_produced: 6,\n }\n }\n 10 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 0,\n nonterminal_produced: 7,\n }\n }\n 11 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 1,\n nonterminal_produced: 7,\n }\n }\n 12 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 4,\n nonterminal_produced: 8,\n }\n }\n 13 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 5,\n nonterminal_produced: 8,\n }\n }\n 14 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 2,\n nonterminal_produced: 9,\n }\n }\n 15 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 0,\n nonterminal_produced: 10,\n }\n }\n 16 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 1,\n nonterminal_produced: 10,\n }\n }\n 17 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 2,\n nonterminal_produced: 11,\n }\n }\n 18 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 3,\n nonterminal_produced: 11,\n }\n }\n 19 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 2,\n nonterminal_produced: 12,\n }\n }\n 20 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 0,\n nonterminal_produced: 13,\n }\n }\n 21 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 1,\n nonterminal_produced: 13,\n }\n }\n 22 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 2,\n nonterminal_produced: 14,\n }\n }\n 23 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 3,\n nonterminal_produced: 14,\n }\n }\n 24 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 2,\n nonterminal_produced: 15,\n }\n }\n 25 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 0,\n nonterminal_produced: 16,\n }\n }\n 26 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 1,\n nonterminal_produced: 16,\n }\n }\n 27 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 2,\n nonterminal_produced: 17,\n }\n }\n 28 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 3,\n nonterminal_produced: 17,\n }\n }\n 29 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 2,\n nonterminal_produced: 18,\n }\n }\n 30 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 0,\n nonterminal_produced: 19,\n }\n }\n 31 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 1,\n nonterminal_produced: 19,\n }\n }\n 32 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 2,\n nonterminal_produced: 20,\n }\n }\n 33 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 3,\n nonterminal_produced: 20,\n }\n }\n 34 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 2,\n nonterminal_produced: 21,\n }\n }\n 35 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 0,\n nonterminal_produced: 22,\n }\n }\n 36 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 1,\n nonterminal_produced: 22,\n }\n }\n 37 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 2,\n nonterminal_produced: 23,\n }\n }\n 38 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 3,\n nonterminal_produced: 23,\n }\n }\n 39 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 3,\n nonterminal_produced: 24,\n }\n }\n 40 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 3,\n nonterminal_produced: 25,\n }\n }\n 41 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 0,\n nonterminal_produced: 25,\n }\n }\n 42 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 2,\n nonterminal_produced: 26,\n }\n }\n 43 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 0,\n nonterminal_produced: 27,\n }\n }\n 44 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 1,\n nonterminal_produced: 27,\n }\n }\n 45 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 2,\n nonterminal_produced: 28,\n }\n }\n 46 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 3,\n nonterminal_produced: 28,\n }\n }\n 47 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 2,\n nonterminal_produced: 29,\n }\n }\n 48 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 0,\n nonterminal_produced: 30,\n }\n }\n 49 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 1,\n nonterminal_produced: 30,\n }\n }\n 50 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 2,\n nonterminal_produced: 31,\n }\n }\n 51 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 3,\n nonterminal_produced: 31,\n }\n }\n 52 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 2,\n nonterminal_produced: 32,\n }\n }\n 53 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 0,\n nonterminal_produced: 33,\n }\n }\n 54 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 1,\n nonterminal_produced: 33,\n }\n }\n 55 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 2,\n nonterminal_produced: 34,\n }\n }\n 56 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 3,\n nonterminal_produced: 34,\n }\n }\n 57 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 3,\n nonterminal_produced: 35,\n }\n }\n 58 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 2,\n nonterminal_produced: 36,\n }\n }\n 59 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 0,\n nonterminal_produced: 37,\n }\n }\n 60 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 1,\n nonterminal_produced: 37,\n }\n }\n 61 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 2,\n nonterminal_produced: 38,\n }\n }\n 62 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 3,\n nonterminal_produced: 38,\n }\n }\n 63 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 3,\n nonterminal_produced: 39,\n }\n }\n 64 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 3,\n nonterminal_produced: 40,\n }\n }\n 65 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 4,\n nonterminal_produced: 40,\n }\n }\n 66 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 2,\n nonterminal_produced: 41,\n }\n }\n 67 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 0,\n nonterminal_produced: 42,\n }\n }\n 68 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 1,\n nonterminal_produced: 42,\n }\n }\n 69 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 2,\n nonterminal_produced: 43,\n }\n }\n 70 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 3,\n nonterminal_produced: 43,\n }\n }\n 71 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 3,\n nonterminal_produced: 44,\n }\n }\n 72 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 6,\n nonterminal_produced: 44,\n }\n }\n 73 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 1,\n nonterminal_produced: 45,\n }\n }\n 74 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 0,\n nonterminal_produced: 45,\n }\n }\n 75 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 1,\n nonterminal_produced: 46,\n }\n }\n 76 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 4,\n nonterminal_produced: 46,\n }\n }\n 77 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 1,\n nonterminal_produced: 47,\n }\n }\n 78 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 4,\n nonterminal_produced: 47,\n }\n }\n 79 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 0,\n nonterminal_produced: 48,\n }\n }\n 80 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 1,\n nonterminal_produced: 48,\n }\n }\n 81 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 1,\n nonterminal_produced: 49,\n }\n }\n 82 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 2,\n nonterminal_produced: 49,\n }\n }\n 83 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 1,\n nonterminal_produced: 50,\n }\n }\n 84 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 4,\n nonterminal_produced: 50,\n }\n }\n 85 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 1,\n nonterminal_produced: 51,\n }\n }\n 86 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 4,\n nonterminal_produced: 51,\n }\n }\n 87 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 1,\n nonterminal_produced: 52,\n }\n }\n 88 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 4,\n nonterminal_produced: 52,\n }\n }\n 89 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 3,\n nonterminal_produced: 53,\n }\n }\n 90 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 1,\n nonterminal_produced: 53,\n }\n }\n 91 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 1,\n nonterminal_produced: 53,\n }\n }\n 92 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 1,\n nonterminal_produced: 53,\n }\n }\n 93 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 3,\n nonterminal_produced: 53,\n }\n }\n 94 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 3,\n nonterminal_produced: 53,\n }\n }\n 95 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 5,\n nonterminal_produced: 53,\n }\n }\n 96 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 3,\n nonterminal_produced: 53,\n }\n }\n 97 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 6,\n nonterminal_produced: 53,\n }\n }\n 98 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 4,\n nonterminal_produced: 53,\n }\n }\n 99 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 4,\n nonterminal_produced: 53,\n }\n }\n 100 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 4,\n nonterminal_produced: 53,\n }\n }\n 101 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 6,\n nonterminal_produced: 53,\n }\n }\n 102 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 6,\n nonterminal_produced: 53,\n }\n }\n 103 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 8,\n nonterminal_produced: 53,\n }\n }\n 104 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 6,\n nonterminal_produced: 53,\n }\n }\n 105 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 1,\n nonterminal_produced: 54,\n }\n }\n 106 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 4,\n nonterminal_produced: 54,\n }\n }\n 107 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 1,\n nonterminal_produced: 55,\n }\n }\n 108 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 4,\n nonterminal_produced: 55,\n }\n }\n 109 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 1,\n nonterminal_produced: 56,\n }\n }\n 110 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 0,\n nonterminal_produced: 56,\n }\n }\n 111 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 1,\n nonterminal_produced: 57,\n }\n }\n 112 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 4,\n nonterminal_produced: 57,\n }\n }\n 113 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 1,\n nonterminal_produced: 58,\n }\n }\n 114 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 4,\n nonterminal_produced: 58,\n }\n }\n 115 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 1,\n nonterminal_produced: 59,\n }\n }\n 116 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 0,\n nonterminal_produced: 59,\n }\n }\n 117 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 1,\n nonterminal_produced: 60,\n }\n }\n 118 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 1,\n nonterminal_produced: 61,\n }\n }\n 119 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 1,\n nonterminal_produced: 62,\n }\n }\n 120 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 0,\n nonterminal_produced: 62,\n }\n }\n 121 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 1,\n nonterminal_produced: 63,\n }\n }\n 122 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 1,\n nonterminal_produced: 64,\n }\n }\n 123 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 0,\n nonterminal_produced: 64,\n }\n }\n 124 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 4,\n nonterminal_produced: 65,\n }\n }\n 125 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 1,\n nonterminal_produced: 66,\n }\n }\n 126 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 1,\n nonterminal_produced: 67,\n }\n }\n 127 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 1,\n nonterminal_produced: 67,\n }\n }\n 128 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 1,\n nonterminal_produced: 67,\n }\n }\n 129 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 1,\n nonterminal_produced: 67,\n }\n }\n 130 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 3,\n nonterminal_produced: 68,\n }\n }\n 131 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 5,\n nonterminal_produced: 69,\n }\n }\n 132 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 1,\n nonterminal_produced: 70,\n }\n }\n 133 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 0,\n nonterminal_produced: 70,\n }\n }\n 134 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 4,\n nonterminal_produced: 71,\n }\n }\n 135 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 3,\n nonterminal_produced: 72,\n }\n }\n 136 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 0,\n nonterminal_produced: 72,\n }\n }\n 137 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 4,\n nonterminal_produced: 72,\n }\n }\n 138 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 1,\n nonterminal_produced: 72,\n }\n }\n 139 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 1,\n nonterminal_produced: 73,\n }\n }\n 140 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 0,\n nonterminal_produced: 73,\n }\n }\n 141 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 2,\n nonterminal_produced: 73,\n }\n }\n 142 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 1,\n nonterminal_produced: 73,\n }\n }\n 143 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 1,\n nonterminal_produced: 74,\n }\n }\n 144 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 0,\n nonterminal_produced: 74,\n }\n }\n 145 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 2,\n nonterminal_produced: 74,\n }\n }\n 146 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 1,\n nonterminal_produced: 74,\n }\n }\n 147 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 1,\n nonterminal_produced: 75,\n }\n }\n 148 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 0,\n nonterminal_produced: 75,\n }\n }\n 149 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 2,\n nonterminal_produced: 75,\n }\n }\n 150 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 1,\n nonterminal_produced: 75,\n }\n }\n 151 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 1,\n nonterminal_produced: 76,\n }\n }\n 152 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 0,\n nonterminal_produced: 76,\n }\n }\n 153 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 2,\n nonterminal_produced: 76,\n }\n }\n 154 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 1,\n nonterminal_produced: 76,\n }\n }\n 155 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 1,\n nonterminal_produced: 77,\n }\n }\n 156 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 0,\n nonterminal_produced: 77,\n }\n }\n 157 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 2,\n nonterminal_produced: 77,\n }\n }\n 158 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 1,\n nonterminal_produced: 77,\n }\n }\n 159 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 1,\n nonterminal_produced: 78,\n }\n }\n 160 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 0,\n nonterminal_produced: 78,\n }\n }\n 161 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 2,\n nonterminal_produced: 78,\n }\n }\n 162 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 1,\n nonterminal_produced: 78,\n }\n }\n 163 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 1,\n nonterminal_produced: 79,\n }\n }\n 164 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 0,\n nonterminal_produced: 79,\n }\n }\n 165 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 2,\n nonterminal_produced: 79,\n }\n }\n 166 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 1,\n nonterminal_produced: 79,\n }\n }\n 167 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 1,\n nonterminal_produced: 80,\n }\n }\n 168 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 0,\n nonterminal_produced: 80,\n }\n }\n 169 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 2,\n nonterminal_produced: 80,\n }\n }\n 170 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 1,\n nonterminal_produced: 80,\n }\n }\n 171 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 1,\n nonterminal_produced: 81,\n }\n }\n 172 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 0,\n nonterminal_produced: 81,\n }\n }\n 173 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 2,\n nonterminal_produced: 81,\n }\n }\n 174 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 1,\n nonterminal_produced: 81,\n }\n }\n 175 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 1,\n nonterminal_produced: 82,\n }\n }\n 176 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 0,\n nonterminal_produced: 82,\n }\n }\n 177 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 2,\n nonterminal_produced: 82,\n }\n }\n 178 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 1,\n nonterminal_produced: 82,\n }\n }\n 179 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 3,\n nonterminal_produced: 83,\n }\n }\n 180 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 5,\n nonterminal_produced: 83,\n }\n }\n 181 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 3,\n nonterminal_produced: 83,\n }\n }\n 182 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 1,\n nonterminal_produced: 83,\n }\n }\n 183 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 1,\n nonterminal_produced: 84,\n }\n }\n 184 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 0,\n nonterminal_produced: 84,\n }\n }\n 185 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 5,\n nonterminal_produced: 85,\n }\n }\n 186 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 3,\n nonterminal_produced: 85,\n }\n }\n 187 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 3,\n nonterminal_produced: 86,\n }\n }\n 188 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 1,\n nonterminal_produced: 87,\n }\n }\n 189 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 1,\n nonterminal_produced: 87,\n }\n }\n 190 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 1,\n nonterminal_produced: 88,\n }\n }\n 191 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 1,\n nonterminal_produced: 88,\n }\n }\n 192 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 1,\n nonterminal_produced: 89,\n }\n }\n 193 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 0,\n nonterminal_produced: 89,\n }\n }\n 194 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 6,\n nonterminal_produced: 90,\n }\n }\n 195 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 3,\n nonterminal_produced: 91,\n }\n }\n 196 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 0,\n nonterminal_produced: 92,\n }\n }\n 197 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 1,\n nonterminal_produced: 92,\n }\n }\n 198 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 1,\n nonterminal_produced: 93,\n }\n }\n 199 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 2,\n nonterminal_produced: 93,\n }\n }\n 200 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 3,\n nonterminal_produced: 94,\n }\n }\n 201 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 1,\n nonterminal_produced: 95,\n }\n }\n 202 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 0,\n nonterminal_produced: 95,\n }\n }\n 203 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 2,\n nonterminal_produced: 96,\n }\n }\n 204 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 1,\n nonterminal_produced: 97,\n }\n }\n 205 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 6,\n nonterminal_produced: 98,\n }\n }\n 206 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 7,\n nonterminal_produced: 98,\n }\n }\n 207 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 3,\n nonterminal_produced: 99,\n }\n }\n 208 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 3,\n nonterminal_produced: 100,\n }\n }\n 209 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 3,\n nonterminal_produced: 101,\n }\n }\n 210 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 1,\n nonterminal_produced: 101,\n }\n }\n 211 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 1,\n nonterminal_produced: 101,\n }\n }\n 212 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 1,\n nonterminal_produced: 101,\n }\n }\n 213 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 3,\n nonterminal_produced: 101,\n }\n }\n 214 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 3,\n nonterminal_produced: 101,\n }\n }\n 215 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 5,\n nonterminal_produced: 101,\n }\n }\n 216 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 3,\n nonterminal_produced: 101,\n }\n }\n 217 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 3,\n nonterminal_produced: 102,\n }\n }\n 218 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 5,\n nonterminal_produced: 103,\n }\n }\n 219 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 1,\n nonterminal_produced: 104,\n }\n }\n 220 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 0,\n nonterminal_produced: 104,\n }\n }\n 221 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 3,\n nonterminal_produced: 105,\n }\n }\n 222 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 1,\n nonterminal_produced: 106,\n }\n }\n 223 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 3,\n nonterminal_produced: 106,\n }\n }\n 224 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 5,\n nonterminal_produced: 107,\n }\n }\n 225 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 3,\n nonterminal_produced: 107,\n }\n }\n 226 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 1,\n nonterminal_produced: 107,\n }\n }\n 227 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 4,\n nonterminal_produced: 107,\n }\n }\n 228 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 1,\n nonterminal_produced: 107,\n }\n }\n 229 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 1,\n nonterminal_produced: 107,\n }\n }\n 230 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 1,\n nonterminal_produced: 107,\n }\n }\n 231 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 3,\n nonterminal_produced: 107,\n }\n }\n 232 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 5,\n nonterminal_produced: 107,\n }\n }\n 233 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 3,\n nonterminal_produced: 107,\n }\n }\n 234 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 6,\n nonterminal_produced: 107,\n }\n }\n 235 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 7,\n nonterminal_produced: 107,\n }\n }\n 236 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 2,\n nonterminal_produced: 107,\n }\n }\n 237 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 4,\n nonterminal_produced: 107,\n }\n }\n 238 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 5,\n nonterminal_produced: 107,\n }\n }\n 239 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 5,\n nonterminal_produced: 107,\n }\n }\n 240 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 3,\n nonterminal_produced: 107,\n }\n }\n 241 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 5,\n nonterminal_produced: 107,\n }\n }\n 242 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 10,\n nonterminal_produced: 107,\n }\n }\n 243 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 5,\n nonterminal_produced: 107,\n }\n }\n 244 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 6,\n nonterminal_produced: 107,\n }\n }\n 245 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 1,\n nonterminal_produced: 107,\n }\n }\n 246 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 4,\n nonterminal_produced: 107,\n }\n }\n 247 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 3,\n nonterminal_produced: 108,\n }\n }\n 248 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 1,\n nonterminal_produced: 109,\n }\n }\n 249 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 1,\n nonterminal_produced: 110,\n }\n }\n 250 => {\n __state_machine::SimulatedReduce::Reduce {\n states_to_pop: 3,\n nonterminal_produced: 110,\n }\n }\n 251 => __state_machine::SimulatedReduce::Accept,\n _ => panic!(\"invalid reduction index {}\", __reduce_index)\n }\n }\n pub struct AnnotatedModuleParser {\n _priv: (),\n }\n\n impl AnnotatedModuleParser {\n pub fn new() -> AnnotatedModuleParser {\n AnnotatedModuleParser {\n _priv: (),\n }\n }\n\n #[allow(dead_code)]\n pub fn parse<\n 'input,\n __TOKEN: __ToTriple<'input, >,\n __TOKENS: IntoIterator,\n >(\n &self,\n text: &'input str,\n __tokens0: __TOKENS,\n ) -> Result, __lalrpop_util::ParseError, ()>>\n {\n let __tokens = __tokens0.into_iter();\n let mut __tokens = __tokens.map(|t| __ToTriple::to_triple(t));\n let __r = __state_machine::Parser::drive(\n __StateMachine {\n text,\n __phantom: ::std::marker::PhantomData::<(&())>,\n },\n __tokens,\n );\n __r\n }\n }\n pub(crate) fn __reduce<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> Option,__lalrpop_util::ParseError, ()>>>\n {\n let (__pop_states, __nonterminal) = match __action {\n 0 => {\n __reduce0(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 1 => {\n __reduce1(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 2 => {\n __reduce2(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 3 => {\n __reduce3(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 4 => {\n __reduce4(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 5 => {\n __reduce5(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 6 => {\n __reduce6(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 7 => {\n __reduce7(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 8 => {\n __reduce8(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 9 => {\n __reduce9(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 10 => {\n __reduce10(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 11 => {\n __reduce11(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 12 => {\n __reduce12(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 13 => {\n __reduce13(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 14 => {\n __reduce14(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 15 => {\n __reduce15(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 16 => {\n __reduce16(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 17 => {\n __reduce17(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 18 => {\n __reduce18(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 19 => {\n __reduce19(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 20 => {\n __reduce20(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 21 => {\n __reduce21(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 22 => {\n __reduce22(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 23 => {\n __reduce23(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 24 => {\n __reduce24(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 25 => {\n __reduce25(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 26 => {\n __reduce26(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 27 => {\n __reduce27(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 28 => {\n __reduce28(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 29 => {\n __reduce29(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 30 => {\n __reduce30(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 31 => {\n __reduce31(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 32 => {\n __reduce32(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 33 => {\n __reduce33(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 34 => {\n __reduce34(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 35 => {\n __reduce35(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 36 => {\n __reduce36(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 37 => {\n __reduce37(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 38 => {\n __reduce38(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 39 => {\n __reduce39(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 40 => {\n __reduce40(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 41 => {\n __reduce41(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 42 => {\n __reduce42(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 43 => {\n __reduce43(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 44 => {\n __reduce44(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 45 => {\n __reduce45(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 46 => {\n __reduce46(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 47 => {\n __reduce47(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 48 => {\n __reduce48(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 49 => {\n __reduce49(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 50 => {\n __reduce50(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 51 => {\n __reduce51(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 52 => {\n __reduce52(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 53 => {\n __reduce53(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 54 => {\n __reduce54(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 55 => {\n __reduce55(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 56 => {\n __reduce56(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 57 => {\n __reduce57(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 58 => {\n __reduce58(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 59 => {\n __reduce59(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 60 => {\n __reduce60(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 61 => {\n __reduce61(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 62 => {\n __reduce62(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 63 => {\n __reduce63(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 64 => {\n __reduce64(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 65 => {\n __reduce65(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 66 => {\n __reduce66(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 67 => {\n __reduce67(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 68 => {\n __reduce68(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 69 => {\n __reduce69(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 70 => {\n __reduce70(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 71 => {\n __reduce71(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 72 => {\n __reduce72(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 73 => {\n __reduce73(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 74 => {\n __reduce74(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 75 => {\n __reduce75(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 76 => {\n __reduce76(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 77 => {\n __reduce77(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 78 => {\n __reduce78(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 79 => {\n __reduce79(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 80 => {\n __reduce80(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 81 => {\n __reduce81(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 82 => {\n __reduce82(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 83 => {\n __reduce83(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 84 => {\n __reduce84(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 85 => {\n __reduce85(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 86 => {\n __reduce86(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 87 => {\n __reduce87(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 88 => {\n __reduce88(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 89 => {\n __reduce89(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 90 => {\n __reduce90(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 91 => {\n __reduce91(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 92 => {\n __reduce92(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 93 => {\n __reduce93(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 94 => {\n __reduce94(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 95 => {\n __reduce95(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 96 => {\n __reduce96(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 97 => {\n __reduce97(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 98 => {\n __reduce98(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 99 => {\n __reduce99(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 100 => {\n __reduce100(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 101 => {\n __reduce101(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 102 => {\n __reduce102(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 103 => {\n __reduce103(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 104 => {\n __reduce104(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 105 => {\n __reduce105(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 106 => {\n __reduce106(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 107 => {\n __reduce107(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 108 => {\n __reduce108(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 109 => {\n __reduce109(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 110 => {\n __reduce110(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 111 => {\n __reduce111(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 112 => {\n __reduce112(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 113 => {\n __reduce113(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 114 => {\n __reduce114(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 115 => {\n __reduce115(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 116 => {\n __reduce116(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 117 => {\n __reduce117(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 118 => {\n __reduce118(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 119 => {\n __reduce119(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 120 => {\n __reduce120(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 121 => {\n __reduce121(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 122 => {\n __reduce122(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 123 => {\n __reduce123(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 124 => {\n __reduce124(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 125 => {\n __reduce125(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 126 => {\n __reduce126(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 127 => {\n __reduce127(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 128 => {\n __reduce128(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 129 => {\n __reduce129(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 130 => {\n __reduce130(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 131 => {\n __reduce131(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 132 => {\n __reduce132(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 133 => {\n __reduce133(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 134 => {\n __reduce134(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 135 => {\n __reduce135(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 136 => {\n __reduce136(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 137 => {\n __reduce137(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 138 => {\n __reduce138(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 139 => {\n __reduce139(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 140 => {\n __reduce140(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 141 => {\n __reduce141(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 142 => {\n __reduce142(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 143 => {\n __reduce143(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 144 => {\n __reduce144(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 145 => {\n __reduce145(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 146 => {\n __reduce146(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 147 => {\n __reduce147(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 148 => {\n __reduce148(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 149 => {\n __reduce149(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 150 => {\n __reduce150(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 151 => {\n __reduce151(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 152 => {\n __reduce152(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 153 => {\n __reduce153(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 154 => {\n __reduce154(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 155 => {\n __reduce155(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 156 => {\n __reduce156(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 157 => {\n __reduce157(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 158 => {\n __reduce158(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 159 => {\n __reduce159(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 160 => {\n __reduce160(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 161 => {\n __reduce161(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 162 => {\n __reduce162(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 163 => {\n __reduce163(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 164 => {\n __reduce164(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 165 => {\n __reduce165(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 166 => {\n __reduce166(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 167 => {\n __reduce167(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 168 => {\n __reduce168(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 169 => {\n __reduce169(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 170 => {\n __reduce170(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 171 => {\n __reduce171(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 172 => {\n __reduce172(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 173 => {\n __reduce173(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 174 => {\n __reduce174(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 175 => {\n __reduce175(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 176 => {\n __reduce176(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 177 => {\n __reduce177(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 178 => {\n __reduce178(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 179 => {\n __reduce179(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 180 => {\n __reduce180(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 181 => {\n __reduce181(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 182 => {\n __reduce182(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 183 => {\n __reduce183(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 184 => {\n __reduce184(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 185 => {\n __reduce185(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 186 => {\n __reduce186(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 187 => {\n __reduce187(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 188 => {\n __reduce188(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 189 => {\n __reduce189(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 190 => {\n __reduce190(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 191 => {\n __reduce191(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 192 => {\n __reduce192(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 193 => {\n __reduce193(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 194 => {\n __reduce194(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 195 => {\n __reduce195(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 196 => {\n __reduce196(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 197 => {\n __reduce197(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 198 => {\n __reduce198(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 199 => {\n __reduce199(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 200 => {\n __reduce200(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 201 => {\n __reduce201(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 202 => {\n __reduce202(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 203 => {\n __reduce203(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 204 => {\n __reduce204(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 205 => {\n __reduce205(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 206 => {\n __reduce206(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 207 => {\n __reduce207(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 208 => {\n __reduce208(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 209 => {\n __reduce209(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 210 => {\n __reduce210(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 211 => {\n __reduce211(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 212 => {\n __reduce212(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 213 => {\n __reduce213(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 214 => {\n __reduce214(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 215 => {\n __reduce215(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 216 => {\n __reduce216(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 217 => {\n __reduce217(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 218 => {\n __reduce218(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 219 => {\n __reduce219(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 220 => {\n __reduce220(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 221 => {\n __reduce221(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 222 => {\n __reduce222(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 223 => {\n __reduce223(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 224 => {\n __reduce224(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 225 => {\n __reduce225(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 226 => {\n __reduce226(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 227 => {\n __reduce227(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 228 => {\n __reduce228(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 229 => {\n __reduce229(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 230 => {\n __reduce230(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 231 => {\n __reduce231(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 232 => {\n __reduce232(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 233 => {\n __reduce233(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 234 => {\n __reduce234(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 235 => {\n __reduce235(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 236 => {\n __reduce236(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 237 => {\n __reduce237(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 238 => {\n __reduce238(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 239 => {\n __reduce239(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 240 => {\n __reduce240(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 241 => {\n __reduce241(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 242 => {\n __reduce242(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 243 => {\n __reduce243(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 244 => {\n __reduce244(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 245 => {\n __reduce245(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 246 => {\n __reduce246(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 247 => {\n __reduce247(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 248 => {\n __reduce248(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 249 => {\n __reduce249(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 250 => {\n __reduce250(text, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)\n }\n 251 => {\n // __AnnotatedModule = AnnotatedModule => ActionFn(0);\n let __sym0 = __pop_Variant39(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym0.2.clone();\n let __nt = super::__action0::<>(text, __sym0);\n return Some(Ok(__nt));\n }\n _ => panic!(\"invalid action code {}\", __action)\n };\n let __states_len = __states.len();\n __states.truncate(__states_len - __pop_states);\n let __state = *__states.last().unwrap() as usize;\n let __next_state = __GOTO[__state * 112 + __nonterminal] - 1;\n __states.push(__next_state);\n None\n }\n fn __pop_Variant44<\n 'input,\n >(\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>\n ) -> (usize, (), usize)\n {\n match __symbols.pop().unwrap() {\n (__l, __Symbol::Variant44(__v), __r) => (__l, __v, __r),\n _ => panic!(\"symbol type mismatch\")\n }\n }\n fn __pop_Variant32<\n 'input,\n >(\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>\n ) -> (usize, (Annotated, Vec>), usize)\n {\n match __symbols.pop().unwrap() {\n (__l, __Symbol::Variant32(__v), __r) => (__l, __v, __r),\n _ => panic!(\"symbol type mismatch\")\n }\n }\n fn __pop_Variant70<\n 'input,\n >(\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>\n ) -> (usize, (Annotated, Annotated), usize)\n {\n match __symbols.pop().unwrap() {\n (__l, __Symbol::Variant70(__v), __r) => (__l, __v, __r),\n _ => panic!(\"symbol type mismatch\")\n }\n }\n fn __pop_Variant10<\n 'input,\n >(\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>\n ) -> (usize, (Atom, Constant), usize)\n {\n match __symbols.pop().unwrap() {\n (__l, __Symbol::Variant10(__v), __r) => (__l, __v, __r),\n _ => panic!(\"symbol type mismatch\")\n }\n }\n fn __pop_Variant27<\n 'input,\n >(\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>\n ) -> (usize, (Expression, MapExactAssoc, Expression), usize)\n {\n match __symbols.pop().unwrap() {\n (__l, __Symbol::Variant27(__v), __r) => (__l, __v, __r),\n _ => panic!(\"symbol type mismatch\")\n }\n }\n fn __pop_Variant22<\n 'input,\n >(\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>\n ) -> (usize, (Expression, Vec), usize)\n {\n match __symbols.pop().unwrap() {\n (__l, __Symbol::Variant22(__v), __r) => (__l, __v, __r),\n _ => panic!(\"symbol type mismatch\")\n }\n }\n fn __pop_Variant30<\n 'input,\n >(\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>\n ) -> (usize, (FunctionName, Function), usize)\n {\n match __symbols.pop().unwrap() {\n (__l, __Symbol::Variant30(__v), __r) => (__l, __v, __r),\n _ => panic!(\"symbol type mismatch\")\n }\n }\n fn __pop_Variant8<\n 'input,\n >(\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>\n ) -> (usize, (Tok<'input>, Constant), usize)\n {\n match __symbols.pop().unwrap() {\n (__l, __Symbol::Variant8(__v), __r) => (__l, __v, __r),\n _ => panic!(\"symbol type mismatch\")\n }\n }\n fn __pop_Variant3<\n 'input,\n >(\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>\n ) -> (usize, (bool, &'input str), usize)\n {\n match __symbols.pop().unwrap() {\n (__l, __Symbol::Variant3(__v), __r) => (__l, __v, __r),\n _ => panic!(\"symbol type mismatch\")\n }\n }\n fn __pop_Variant19<\n 'input,\n >(\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>\n ) -> (usize, Annotated<(Annotated, Annotated)>, usize)\n {\n match __symbols.pop().unwrap() {\n (__l, __Symbol::Variant19(__v), __r) => (__l, __v, __r),\n _ => panic!(\"symbol type mismatch\")\n }\n }\n fn __pop_Variant12<\n 'input,\n >(\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>\n ) -> (usize, Annotated<(Expression, MapExactAssoc, Expression)>, usize)\n {\n match __symbols.pop().unwrap() {\n (__l, __Symbol::Variant12(__v), __r) => (__l, __v, __r),\n _ => panic!(\"symbol type mismatch\")\n }\n }\n fn __pop_Variant16<\n 'input,\n >(\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>\n ) -> (usize, Annotated, usize)\n {\n match __symbols.pop().unwrap() {\n (__l, __Symbol::Variant16(__v), __r) => (__l, __v, __r),\n _ => panic!(\"symbol type mismatch\")\n }\n }\n fn __pop_Variant35<\n 'input,\n >(\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>\n ) -> (usize, Annotated, usize)\n {\n match __symbols.pop().unwrap() {\n (__l, __Symbol::Variant35(__v), __r) => (__l, __v, __r),\n _ => panic!(\"symbol type mismatch\")\n }\n }\n fn __pop_Variant37<\n 'input,\n >(\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>\n ) -> (usize, Annotated, usize)\n {\n match __symbols.pop().unwrap() {\n (__l, __Symbol::Variant37(__v), __r) => (__l, __v, __r),\n _ => panic!(\"symbol type mismatch\")\n }\n }\n fn __pop_Variant38<\n 'input,\n >(\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>\n ) -> (usize, Annotated, usize)\n {\n match __symbols.pop().unwrap() {\n (__l, __Symbol::Variant38(__v), __r) => (__l, __v, __r),\n _ => panic!(\"symbol type mismatch\")\n }\n }\n fn __pop_Variant39<\n 'input,\n >(\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>\n ) -> (usize, Annotated, usize)\n {\n match __symbols.pop().unwrap() {\n (__l, __Symbol::Variant39(__v), __r) => (__l, __v, __r),\n _ => panic!(\"symbol type mismatch\")\n }\n }\n fn __pop_Variant4<\n 'input,\n >(\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>\n ) -> (usize, Annotated, usize)\n {\n match __symbols.pop().unwrap() {\n (__l, __Symbol::Variant4(__v), __r) => (__l, __v, __r),\n _ => panic!(\"symbol type mismatch\")\n }\n }\n fn __pop_Variant14<\n 'input,\n >(\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>\n ) -> (usize, Annotated, usize)\n {\n match __symbols.pop().unwrap() {\n (__l, __Symbol::Variant14(__v), __r) => (__l, __v, __r),\n _ => panic!(\"symbol type mismatch\")\n }\n }\n fn __pop_Variant41<\n 'input,\n >(\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>\n ) -> (usize, Annotated>>, usize)\n {\n match __symbols.pop().unwrap() {\n (__l, __Symbol::Variant41(__v), __r) => (__l, __v, __r),\n _ => panic!(\"symbol type mismatch\")\n }\n }\n fn __pop_Variant45<\n 'input,\n >(\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>\n ) -> (usize, Atom, usize)\n {\n match __symbols.pop().unwrap() {\n (__l, __Symbol::Variant45(__v), __r) => (__l, __v, __r),\n _ => panic!(\"symbol type mismatch\")\n }\n }\n fn __pop_Variant46<\n 'input,\n >(\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>\n ) -> (usize, AtomicTerm, usize)\n {\n match __symbols.pop().unwrap() {\n (__l, __Symbol::Variant46(__v), __r) => (__l, __v, __r),\n _ => panic!(\"symbol type mismatch\")\n }\n }\n fn __pop_Variant66<\n 'input,\n >(\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>\n ) -> (usize, BigInt, usize)\n {\n match __symbols.pop().unwrap() {\n (__l, __Symbol::Variant66(__v), __r) => (__l, __v, __r),\n _ => panic!(\"symbol type mismatch\")\n }\n }\n fn __pop_Variant49<\n 'input,\n >(\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>\n ) -> (usize, CaseClause, usize)\n {\n match __symbols.pop().unwrap() {\n (__l, __Symbol::Variant49(__v), __r) => (__l, __v, __r),\n _ => panic!(\"symbol type mismatch\")\n }\n }\n fn __pop_Variant24<\n 'input,\n >(\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>\n ) -> (usize, Constant, usize)\n {\n match __symbols.pop().unwrap() {\n (__l, __Symbol::Variant24(__v), __r) => (__l, __v, __r),\n _ => panic!(\"symbol type mismatch\")\n }\n }\n fn __pop_Variant6<\n 'input,\n >(\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>\n ) -> (usize, Expression, usize)\n {\n match __symbols.pop().unwrap() {\n (__l, __Symbol::Variant6(__v), __r) => (__l, __v, __r),\n _ => panic!(\"symbol type mismatch\")\n }\n }\n fn __pop_Variant62<\n 'input,\n >(\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>\n ) -> (usize, Function, usize)\n {\n match __symbols.pop().unwrap() {\n (__l, __Symbol::Variant62(__v), __r) => (__l, __v, __r),\n _ => panic!(\"symbol type mismatch\")\n }\n }\n fn __pop_Variant63<\n 'input,\n >(\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>\n ) -> (usize, FunctionDefinition, usize)\n {\n match __symbols.pop().unwrap() {\n (__l, __Symbol::Variant63(__v), __r) => (__l, __v, __r),\n _ => panic!(\"symbol type mismatch\")\n }\n }\n fn __pop_Variant28<\n 'input,\n >(\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>\n ) -> (usize, FunctionName, usize)\n {\n match __symbols.pop().unwrap() {\n (__l, __Symbol::Variant28(__v), __r) => (__l, __v, __r),\n _ => panic!(\"symbol type mismatch\")\n }\n }\n fn __pop_Variant61<\n 'input,\n >(\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>\n ) -> (usize, MapExactAssoc, usize)\n {\n match __symbols.pop().unwrap() {\n (__l, __Symbol::Variant61(__v), __r) => (__l, __v, __r),\n _ => panic!(\"symbol type mismatch\")\n }\n }\n fn __pop_Variant67<\n 'input,\n >(\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>\n ) -> (usize, Module, usize)\n {\n match __symbols.pop().unwrap() {\n (__l, __Symbol::Variant67(__v), __r) => (__l, __v, __r),\n _ => panic!(\"symbol type mismatch\")\n }\n }\n fn __pop_Variant68<\n 'input,\n >(\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>\n ) -> (usize, Pattern, usize)\n {\n match __symbols.pop().unwrap() {\n (__l, __Symbol::Variant68(__v), __r) => (__l, __v, __r),\n _ => panic!(\"symbol type mismatch\")\n }\n }\n fn __pop_Variant71<\n 'input,\n >(\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>\n ) -> (usize, SingleExpression, usize)\n {\n match __symbols.pop().unwrap() {\n (__l, __Symbol::Variant71(__v), __r) => (__l, __v, __r),\n _ => panic!(\"symbol type mismatch\")\n }\n }\n fn __pop_Variant0<\n 'input,\n >(\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>\n ) -> (usize, Tok<'input>, usize)\n {\n match __symbols.pop().unwrap() {\n (__l, __Symbol::Variant0(__v), __r) => (__l, __v, __r),\n _ => panic!(\"symbol type mismatch\")\n }\n }\n fn __pop_Variant59<\n 'input,\n >(\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>\n ) -> (usize, Vec<(Annotated, Vec>)>, usize)\n {\n match __symbols.pop().unwrap() {\n (__l, __Symbol::Variant59(__v), __r) => (__l, __v, __r),\n _ => panic!(\"symbol type mismatch\")\n }\n }\n fn __pop_Variant50<\n 'input,\n >(\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>\n ) -> (usize, Vec<(Atom, Constant)>, usize)\n {\n match __symbols.pop().unwrap() {\n (__l, __Symbol::Variant50(__v), __r) => (__l, __v, __r),\n _ => panic!(\"symbol type mismatch\")\n }\n }\n fn __pop_Variant47<\n 'input,\n >(\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>\n ) -> (usize, Vec<(Expression, Vec)>, usize)\n {\n match __symbols.pop().unwrap() {\n (__l, __Symbol::Variant47(__v), __r) => (__l, __v, __r),\n _ => panic!(\"symbol type mismatch\")\n }\n }\n fn __pop_Variant55<\n 'input,\n >(\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>\n ) -> (usize, Vec, Annotated)>>, usize)\n {\n match __symbols.pop().unwrap() {\n (__l, __Symbol::Variant55(__v), __r) => (__l, __v, __r),\n _ => panic!(\"symbol type mismatch\")\n }\n }\n fn __pop_Variant51<\n 'input,\n >(\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>\n ) -> (usize, Vec>, usize)\n {\n match __symbols.pop().unwrap() {\n (__l, __Symbol::Variant51(__v), __r) => (__l, __v, __r),\n _ => panic!(\"symbol type mismatch\")\n }\n }\n fn __pop_Variant53<\n 'input,\n >(\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>\n ) -> (usize, Vec>, usize)\n {\n match __symbols.pop().unwrap() {\n (__l, __Symbol::Variant53(__v), __r) => (__l, __v, __r),\n _ => panic!(\"symbol type mismatch\")\n }\n }\n fn __pop_Variant54<\n 'input,\n >(\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>\n ) -> (usize, Vec>, usize)\n {\n match __symbols.pop().unwrap() {\n (__l, __Symbol::Variant54(__v), __r) => (__l, __v, __r),\n _ => panic!(\"symbol type mismatch\")\n }\n }\n fn __pop_Variant52<\n 'input,\n >(\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>\n ) -> (usize, Vec>, usize)\n {\n match __symbols.pop().unwrap() {\n (__l, __Symbol::Variant52(__v), __r) => (__l, __v, __r),\n _ => panic!(\"symbol type mismatch\")\n }\n }\n fn __pop_Variant56<\n 'input,\n >(\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>\n ) -> (usize, Vec, usize)\n {\n match __symbols.pop().unwrap() {\n (__l, __Symbol::Variant56(__v), __r) => (__l, __v, __r),\n _ => panic!(\"symbol type mismatch\")\n }\n }\n fn __pop_Variant57<\n 'input,\n >(\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>\n ) -> (usize, Vec, usize)\n {\n match __symbols.pop().unwrap() {\n (__l, __Symbol::Variant57(__v), __r) => (__l, __v, __r),\n _ => panic!(\"symbol type mismatch\")\n }\n }\n fn __pop_Variant58<\n 'input,\n >(\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>\n ) -> (usize, Vec, usize)\n {\n match __symbols.pop().unwrap() {\n (__l, __Symbol::Variant58(__v), __r) => (__l, __v, __r),\n _ => panic!(\"symbol type mismatch\")\n }\n }\n fn __pop_Variant2<\n 'input,\n >(\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>\n ) -> (usize, char, usize)\n {\n match __symbols.pop().unwrap() {\n (__l, __Symbol::Variant2(__v), __r) => (__l, __v, __r),\n _ => panic!(\"symbol type mismatch\")\n }\n }\n fn __pop_Variant69<\n 'input,\n >(\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>\n ) -> (usize, ::std::option::Option<(Annotated, Vec>)>, usize)\n {\n match __symbols.pop().unwrap() {\n (__l, __Symbol::Variant69(__v), __r) => (__l, __v, __r),\n _ => panic!(\"symbol type mismatch\")\n }\n }\n fn __pop_Variant21<\n 'input,\n >(\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>\n ) -> (usize, ::std::option::Option<(Atom, Constant)>, usize)\n {\n match __symbols.pop().unwrap() {\n (__l, __Symbol::Variant21(__v), __r) => (__l, __v, __r),\n _ => panic!(\"symbol type mismatch\")\n }\n }\n fn __pop_Variant48<\n 'input,\n >(\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>\n ) -> (usize, ::std::option::Option<(Expression, Vec)>, usize)\n {\n match __symbols.pop().unwrap() {\n (__l, __Symbol::Variant48(__v), __r) => (__l, __v, __r),\n _ => panic!(\"symbol type mismatch\")\n }\n }\n fn __pop_Variant9<\n 'input,\n >(\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>\n ) -> (usize, ::std::option::Option<(Tok<'input>, Constant)>, usize)\n {\n match __symbols.pop().unwrap() {\n (__l, __Symbol::Variant9(__v), __r) => (__l, __v, __r),\n _ => panic!(\"symbol type mismatch\")\n }\n }\n fn __pop_Variant43<\n 'input,\n >(\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>\n ) -> (usize, ::std::option::Option, Annotated)>>, usize)\n {\n match __symbols.pop().unwrap() {\n (__l, __Symbol::Variant43(__v), __r) => (__l, __v, __r),\n _ => panic!(\"symbol type mismatch\")\n }\n }\n fn __pop_Variant34<\n 'input,\n >(\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>\n ) -> (usize, ::std::option::Option>, usize)\n {\n match __symbols.pop().unwrap() {\n (__l, __Symbol::Variant34(__v), __r) => (__l, __v, __r),\n _ => panic!(\"symbol type mismatch\")\n }\n }\n fn __pop_Variant42<\n 'input,\n >(\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>\n ) -> (usize, ::std::option::Option>, usize)\n {\n match __symbols.pop().unwrap() {\n (__l, __Symbol::Variant42(__v), __r) => (__l, __v, __r),\n _ => panic!(\"symbol type mismatch\")\n }\n }\n fn __pop_Variant5<\n 'input,\n >(\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>\n ) -> (usize, ::std::option::Option>, usize)\n {\n match __symbols.pop().unwrap() {\n (__l, __Symbol::Variant5(__v), __r) => (__l, __v, __r),\n _ => panic!(\"symbol type mismatch\")\n }\n }\n fn __pop_Variant40<\n 'input,\n >(\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>\n ) -> (usize, ::std::option::Option>, usize)\n {\n match __symbols.pop().unwrap() {\n (__l, __Symbol::Variant40(__v), __r) => (__l, __v, __r),\n _ => panic!(\"symbol type mismatch\")\n }\n }\n fn __pop_Variant60<\n 'input,\n >(\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>\n ) -> (usize, ::std::option::Option, usize)\n {\n match __symbols.pop().unwrap() {\n (__l, __Symbol::Variant60(__v), __r) => (__l, __v, __r),\n _ => panic!(\"symbol type mismatch\")\n }\n }\n fn __pop_Variant7<\n 'input,\n >(\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>\n ) -> (usize, ::std::option::Option, usize)\n {\n match __symbols.pop().unwrap() {\n (__l, __Symbol::Variant7(__v), __r) => (__l, __v, __r),\n _ => panic!(\"symbol type mismatch\")\n }\n }\n fn __pop_Variant65<\n 'input,\n >(\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>\n ) -> (usize, ::std::option::Option, usize)\n {\n match __symbols.pop().unwrap() {\n (__l, __Symbol::Variant65(__v), __r) => (__l, __v, __r),\n _ => panic!(\"symbol type mismatch\")\n }\n }\n fn __pop_Variant33<\n 'input,\n >(\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>\n ) -> (usize, ::std::vec::Vec<(Annotated, Vec>)>, usize)\n {\n match __symbols.pop().unwrap() {\n (__l, __Symbol::Variant33(__v), __r) => (__l, __v, __r),\n _ => panic!(\"symbol type mismatch\")\n }\n }\n fn __pop_Variant11<\n 'input,\n >(\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>\n ) -> (usize, ::std::vec::Vec<(Atom, Constant)>, usize)\n {\n match __symbols.pop().unwrap() {\n (__l, __Symbol::Variant11(__v), __r) => (__l, __v, __r),\n _ => panic!(\"symbol type mismatch\")\n }\n }\n fn __pop_Variant23<\n 'input,\n >(\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>\n ) -> (usize, ::std::vec::Vec<(Expression, Vec)>, usize)\n {\n match __symbols.pop().unwrap() {\n (__l, __Symbol::Variant23(__v), __r) => (__l, __v, __r),\n _ => panic!(\"symbol type mismatch\")\n }\n }\n fn __pop_Variant31<\n 'input,\n >(\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>\n ) -> (usize, ::std::vec::Vec<(FunctionName, Function)>, usize)\n {\n match __symbols.pop().unwrap() {\n (__l, __Symbol::Variant31(__v), __r) => (__l, __v, __r),\n _ => panic!(\"symbol type mismatch\")\n }\n }\n fn __pop_Variant20<\n 'input,\n >(\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>\n ) -> (usize, ::std::vec::Vec, Annotated)>>, usize)\n {\n match __symbols.pop().unwrap() {\n (__l, __Symbol::Variant20(__v), __r) => (__l, __v, __r),\n _ => panic!(\"symbol type mismatch\")\n }\n }\n fn __pop_Variant13<\n 'input,\n >(\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>\n ) -> (usize, ::std::vec::Vec>, usize)\n {\n match __symbols.pop().unwrap() {\n (__l, __Symbol::Variant13(__v), __r) => (__l, __v, __r),\n _ => panic!(\"symbol type mismatch\")\n }\n }\n fn __pop_Variant17<\n 'input,\n >(\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>\n ) -> (usize, ::std::vec::Vec>, usize)\n {\n match __symbols.pop().unwrap() {\n (__l, __Symbol::Variant17(__v), __r) => (__l, __v, __r),\n _ => panic!(\"symbol type mismatch\")\n }\n }\n fn __pop_Variant36<\n 'input,\n >(\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>\n ) -> (usize, ::std::vec::Vec>, usize)\n {\n match __symbols.pop().unwrap() {\n (__l, __Symbol::Variant36(__v), __r) => (__l, __v, __r),\n _ => panic!(\"symbol type mismatch\")\n }\n }\n fn __pop_Variant18<\n 'input,\n >(\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>\n ) -> (usize, ::std::vec::Vec>, usize)\n {\n match __symbols.pop().unwrap() {\n (__l, __Symbol::Variant18(__v), __r) => (__l, __v, __r),\n _ => panic!(\"symbol type mismatch\")\n }\n }\n fn __pop_Variant15<\n 'input,\n >(\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>\n ) -> (usize, ::std::vec::Vec>, usize)\n {\n match __symbols.pop().unwrap() {\n (__l, __Symbol::Variant15(__v), __r) => (__l, __v, __r),\n _ => panic!(\"symbol type mismatch\")\n }\n }\n fn __pop_Variant25<\n 'input,\n >(\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>\n ) -> (usize, ::std::vec::Vec, usize)\n {\n match __symbols.pop().unwrap() {\n (__l, __Symbol::Variant25(__v), __r) => (__l, __v, __r),\n _ => panic!(\"symbol type mismatch\")\n }\n }\n fn __pop_Variant26<\n 'input,\n >(\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>\n ) -> (usize, ::std::vec::Vec, usize)\n {\n match __symbols.pop().unwrap() {\n (__l, __Symbol::Variant26(__v), __r) => (__l, __v, __r),\n _ => panic!(\"symbol type mismatch\")\n }\n }\n fn __pop_Variant64<\n 'input,\n >(\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>\n ) -> (usize, ::std::vec::Vec, usize)\n {\n match __symbols.pop().unwrap() {\n (__l, __Symbol::Variant64(__v), __r) => (__l, __v, __r),\n _ => panic!(\"symbol type mismatch\")\n }\n }\n fn __pop_Variant29<\n 'input,\n >(\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>\n ) -> (usize, ::std::vec::Vec, usize)\n {\n match __symbols.pop().unwrap() {\n (__l, __Symbol::Variant29(__v), __r) => (__l, __v, __r),\n _ => panic!(\"symbol type mismatch\")\n }\n }\n fn __pop_Variant1<\n 'input,\n >(\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>\n ) -> (usize, &'input str, usize)\n {\n match __symbols.pop().unwrap() {\n (__l, __Symbol::Variant1(__v), __r) => (__l, __v, __r),\n _ => panic!(\"symbol type mismatch\")\n }\n }\n pub(crate) fn __reduce0<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // (\"|\" ) = \"|\", AnnotatedPattern => ActionFn(73);\n let __sym1 = __pop_Variant4(__symbols);\n let __sym0 = __pop_Variant0(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym1.2.clone();\n let __nt = super::__action73::<>(text, __sym0, __sym1);\n __symbols.push((__start, __Symbol::Variant4(__nt), __end));\n (2, 0)\n }\n pub(crate) fn __reduce1<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // (\"|\" )? = \"|\", AnnotatedPattern => ActionFn(197);\n let __sym1 = __pop_Variant4(__symbols);\n let __sym0 = __pop_Variant0(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym1.2.clone();\n let __nt = super::__action197::<>(text, __sym0, __sym1);\n __symbols.push((__start, __Symbol::Variant5(__nt), __end));\n (2, 1)\n }\n pub(crate) fn __reduce2<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // (\"|\" )? = => ActionFn(72);\n let __start = __symbols.last().map(|s| s.2.clone()).unwrap_or_default();\n let __end = __lookahead_start.cloned().unwrap_or_else(|| __start.clone());\n let __nt = super::__action72::<>(text, &__start, &__end);\n __symbols.push((__start, __Symbol::Variant5(__nt), __end));\n (0, 1)\n }\n pub(crate) fn __reduce3<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // (\"|\" ) = \"|\", Expression => ActionFn(95);\n let __sym1 = __pop_Variant6(__symbols);\n let __sym0 = __pop_Variant0(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym1.2.clone();\n let __nt = super::__action95::<>(text, __sym0, __sym1);\n __symbols.push((__start, __Symbol::Variant6(__nt), __end));\n (2, 2)\n }\n pub(crate) fn __reduce4<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // (\"|\" )? = \"|\", Expression => ActionFn(200);\n let __sym1 = __pop_Variant6(__symbols);\n let __sym0 = __pop_Variant0(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym1.2.clone();\n let __nt = super::__action200::<>(text, __sym0, __sym1);\n __symbols.push((__start, __Symbol::Variant7(__nt), __end));\n (2, 3)\n }\n pub(crate) fn __reduce5<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // (\"|\" )? = => ActionFn(94);\n let __start = __symbols.last().map(|s| s.2.clone()).unwrap_or_default();\n let __end = __lookahead_start.cloned().unwrap_or_else(|| __start.clone());\n let __nt = super::__action94::<>(text, &__start, &__end);\n __symbols.push((__start, __Symbol::Variant7(__nt), __end));\n (0, 3)\n }\n pub(crate) fn __reduce6<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // (\"|\" Constant) = \"|\", Constant => ActionFn(67);\n let __sym1 = __pop_Variant24(__symbols);\n let __sym0 = __pop_Variant0(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym1.2.clone();\n let __nt = super::__action67::<>(text, __sym0, __sym1);\n __symbols.push((__start, __Symbol::Variant8(__nt), __end));\n (2, 4)\n }\n pub(crate) fn __reduce7<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // (\"|\" Constant)? = \"|\", Constant => ActionFn(205);\n let __sym1 = __pop_Variant24(__symbols);\n let __sym0 = __pop_Variant0(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym1.2.clone();\n let __nt = super::__action205::<>(text, __sym0, __sym1);\n __symbols.push((__start, __Symbol::Variant9(__nt), __end));\n (2, 5)\n }\n pub(crate) fn __reduce8<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // (\"|\" Constant)? = => ActionFn(66);\n let __start = __symbols.last().map(|s| s.2.clone()).unwrap_or_default();\n let __end = __lookahead_start.cloned().unwrap_or_else(|| __start.clone());\n let __nt = super::__action66::<>(text, &__start, &__end);\n __symbols.push((__start, __Symbol::Variant9(__nt), __end));\n (0, 5)\n }\n pub(crate) fn __reduce9<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // (<( \"=\" )> \",\") = Atom, \"=\", Constant, \",\" => ActionFn(210);\n let __sym3 = __pop_Variant0(__symbols);\n let __sym2 = __pop_Variant24(__symbols);\n let __sym1 = __pop_Variant0(__symbols);\n let __sym0 = __pop_Variant45(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym3.2.clone();\n let __nt = super::__action210::<>(text, __sym0, __sym1, __sym2, __sym3);\n __symbols.push((__start, __Symbol::Variant10(__nt), __end));\n (4, 6)\n }\n pub(crate) fn __reduce10<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // (<( \"=\" )> \",\")* = => ActionFn(125);\n let __start = __symbols.last().map(|s| s.2.clone()).unwrap_or_default();\n let __end = __lookahead_start.cloned().unwrap_or_else(|| __start.clone());\n let __nt = super::__action125::<>(text, &__start, &__end);\n __symbols.push((__start, __Symbol::Variant11(__nt), __end));\n (0, 7)\n }\n pub(crate) fn __reduce11<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // (<( \"=\" )> \",\")* = (<( \"=\" )> \",\")+ => ActionFn(126);\n let __sym0 = __pop_Variant11(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym0.2.clone();\n let __nt = super::__action126::<>(text, __sym0);\n __symbols.push((__start, __Symbol::Variant11(__nt), __end));\n (1, 7)\n }\n pub(crate) fn __reduce12<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // (<( \"=\" )> \",\")+ = Atom, \"=\", Constant, \",\" => ActionFn(212);\n let __sym3 = __pop_Variant0(__symbols);\n let __sym2 = __pop_Variant24(__symbols);\n let __sym1 = __pop_Variant0(__symbols);\n let __sym0 = __pop_Variant45(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym3.2.clone();\n let __nt = super::__action212::<>(text, __sym0, __sym1, __sym2, __sym3);\n __symbols.push((__start, __Symbol::Variant11(__nt), __end));\n (4, 8)\n }\n pub(crate) fn __reduce13<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // (<( \"=\" )> \",\")+ = (<( \"=\" )> \",\")+, Atom, \"=\", Constant, \",\" => ActionFn(213);\n let __sym4 = __pop_Variant0(__symbols);\n let __sym3 = __pop_Variant24(__symbols);\n let __sym2 = __pop_Variant0(__symbols);\n let __sym1 = __pop_Variant45(__symbols);\n let __sym0 = __pop_Variant11(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym4.2.clone();\n let __nt = super::__action213::<>(text, __sym0, __sym1, __sym2, __sym3, __sym4);\n __symbols.push((__start, __Symbol::Variant11(__nt), __end));\n (5, 8)\n }\n pub(crate) fn __reduce14<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // ( )>> \",\") = Annotated<( )>, \",\" => ActionFn(147);\n let __sym1 = __pop_Variant0(__symbols);\n let __sym0 = __pop_Variant12(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym1.2.clone();\n let __nt = super::__action147::<>(text, __sym0, __sym1);\n __symbols.push((__start, __Symbol::Variant12(__nt), __end));\n (2, 9)\n }\n pub(crate) fn __reduce15<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // ( )>> \",\")* = => ActionFn(145);\n let __start = __symbols.last().map(|s| s.2.clone()).unwrap_or_default();\n let __end = __lookahead_start.cloned().unwrap_or_else(|| __start.clone());\n let __nt = super::__action145::<>(text, &__start, &__end);\n __symbols.push((__start, __Symbol::Variant13(__nt), __end));\n (0, 10)\n }\n pub(crate) fn __reduce16<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // ( )>> \",\")* = ( )>> \",\")+ => ActionFn(146);\n let __sym0 = __pop_Variant13(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym0.2.clone();\n let __nt = super::__action146::<>(text, __sym0);\n __symbols.push((__start, __Symbol::Variant13(__nt), __end));\n (1, 10)\n }\n pub(crate) fn __reduce17<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // ( )>> \",\")+ = Annotated<( )>, \",\" => ActionFn(216);\n let __sym1 = __pop_Variant0(__symbols);\n let __sym0 = __pop_Variant12(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym1.2.clone();\n let __nt = super::__action216::<>(text, __sym0, __sym1);\n __symbols.push((__start, __Symbol::Variant13(__nt), __end));\n (2, 11)\n }\n pub(crate) fn __reduce18<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // ( )>> \",\")+ = ( )>> \",\")+, Annotated<( )>, \",\" => ActionFn(217);\n let __sym2 = __pop_Variant0(__symbols);\n let __sym1 = __pop_Variant12(__symbols);\n let __sym0 = __pop_Variant13(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym2.2.clone();\n let __nt = super::__action217::<>(text, __sym0, __sym1, __sym2);\n __symbols.push((__start, __Symbol::Variant13(__nt), __end));\n (3, 11)\n }\n pub(crate) fn __reduce19<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // (> \",\") = Annotated, \",\" => ActionFn(137);\n let __sym1 = __pop_Variant0(__symbols);\n let __sym0 = __pop_Variant14(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym1.2.clone();\n let __nt = super::__action137::<>(text, __sym0, __sym1);\n __symbols.push((__start, __Symbol::Variant14(__nt), __end));\n (2, 12)\n }\n pub(crate) fn __reduce20<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // (> \",\")* = => ActionFn(135);\n let __start = __symbols.last().map(|s| s.2.clone()).unwrap_or_default();\n let __end = __lookahead_start.cloned().unwrap_or_else(|| __start.clone());\n let __nt = super::__action135::<>(text, &__start, &__end);\n __symbols.push((__start, __Symbol::Variant15(__nt), __end));\n (0, 13)\n }\n pub(crate) fn __reduce21<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // (> \",\")* = (> \",\")+ => ActionFn(136);\n let __sym0 = __pop_Variant15(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym0.2.clone();\n let __nt = super::__action136::<>(text, __sym0);\n __symbols.push((__start, __Symbol::Variant15(__nt), __end));\n (1, 13)\n }\n pub(crate) fn __reduce22<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // (> \",\")+ = Annotated, \",\" => ActionFn(220);\n let __sym1 = __pop_Variant0(__symbols);\n let __sym0 = __pop_Variant14(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym1.2.clone();\n let __nt = super::__action220::<>(text, __sym0, __sym1);\n __symbols.push((__start, __Symbol::Variant15(__nt), __end));\n (2, 14)\n }\n pub(crate) fn __reduce23<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // (> \",\")+ = (> \",\")+, Annotated, \",\" => ActionFn(221);\n let __sym2 = __pop_Variant0(__symbols);\n let __sym1 = __pop_Variant14(__symbols);\n let __sym0 = __pop_Variant15(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym2.2.clone();\n let __nt = super::__action221::<>(text, __sym0, __sym1, __sym2);\n __symbols.push((__start, __Symbol::Variant15(__nt), __end));\n (3, 14)\n }\n pub(crate) fn __reduce24<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // (> \",\") = Annotated, \",\" => ActionFn(132);\n let __sym1 = __pop_Variant0(__symbols);\n let __sym0 = __pop_Variant16(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym1.2.clone();\n let __nt = super::__action132::<>(text, __sym0, __sym1);\n __symbols.push((__start, __Symbol::Variant16(__nt), __end));\n (2, 15)\n }\n pub(crate) fn __reduce25<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // (> \",\")* = => ActionFn(130);\n let __start = __symbols.last().map(|s| s.2.clone()).unwrap_or_default();\n let __end = __lookahead_start.cloned().unwrap_or_else(|| __start.clone());\n let __nt = super::__action130::<>(text, &__start, &__end);\n __symbols.push((__start, __Symbol::Variant17(__nt), __end));\n (0, 16)\n }\n pub(crate) fn __reduce26<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // (> \",\")* = (> \",\")+ => ActionFn(131);\n let __sym0 = __pop_Variant17(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym0.2.clone();\n let __nt = super::__action131::<>(text, __sym0);\n __symbols.push((__start, __Symbol::Variant17(__nt), __end));\n (1, 16)\n }\n pub(crate) fn __reduce27<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // (> \",\")+ = Annotated, \",\" => ActionFn(224);\n let __sym1 = __pop_Variant0(__symbols);\n let __sym0 = __pop_Variant16(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym1.2.clone();\n let __nt = super::__action224::<>(text, __sym0, __sym1);\n __symbols.push((__start, __Symbol::Variant17(__nt), __end));\n (2, 17)\n }\n pub(crate) fn __reduce28<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // (> \",\")+ = (> \",\")+, Annotated, \",\" => ActionFn(225);\n let __sym2 = __pop_Variant0(__symbols);\n let __sym1 = __pop_Variant16(__symbols);\n let __sym0 = __pop_Variant17(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym2.2.clone();\n let __nt = super::__action225::<>(text, __sym0, __sym1, __sym2);\n __symbols.push((__start, __Symbol::Variant17(__nt), __end));\n (3, 17)\n }\n pub(crate) fn __reduce29<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // ( \",\") = AnnotatedPattern, \",\" => ActionFn(154);\n let __sym1 = __pop_Variant0(__symbols);\n let __sym0 = __pop_Variant4(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym1.2.clone();\n let __nt = super::__action154::<>(text, __sym0, __sym1);\n __symbols.push((__start, __Symbol::Variant4(__nt), __end));\n (2, 18)\n }\n pub(crate) fn __reduce30<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // ( \",\")* = => ActionFn(152);\n let __start = __symbols.last().map(|s| s.2.clone()).unwrap_or_default();\n let __end = __lookahead_start.cloned().unwrap_or_else(|| __start.clone());\n let __nt = super::__action152::<>(text, &__start, &__end);\n __symbols.push((__start, __Symbol::Variant18(__nt), __end));\n (0, 19)\n }\n pub(crate) fn __reduce31<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // ( \",\")* = ( \",\")+ => ActionFn(153);\n let __sym0 = __pop_Variant18(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym0.2.clone();\n let __nt = super::__action153::<>(text, __sym0);\n __symbols.push((__start, __Symbol::Variant18(__nt), __end));\n (1, 19)\n }\n pub(crate) fn __reduce32<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // ( \",\")+ = AnnotatedPattern, \",\" => ActionFn(228);\n let __sym1 = __pop_Variant0(__symbols);\n let __sym0 = __pop_Variant4(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym1.2.clone();\n let __nt = super::__action228::<>(text, __sym0, __sym1);\n __symbols.push((__start, __Symbol::Variant18(__nt), __end));\n (2, 20)\n }\n pub(crate) fn __reduce33<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // ( \",\")+ = ( \",\")+, AnnotatedPattern, \",\" => ActionFn(229);\n let __sym2 = __pop_Variant0(__symbols);\n let __sym1 = __pop_Variant4(__symbols);\n let __sym0 = __pop_Variant18(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym2.2.clone();\n let __nt = super::__action229::<>(text, __sym0, __sym1, __sym2);\n __symbols.push((__start, __Symbol::Variant18(__nt), __end));\n (3, 20)\n }\n pub(crate) fn __reduce34<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // ( \",\") = AnnotatedPatternMapEntry, \",\" => ActionFn(159);\n let __sym1 = __pop_Variant0(__symbols);\n let __sym0 = __pop_Variant19(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym1.2.clone();\n let __nt = super::__action159::<>(text, __sym0, __sym1);\n __symbols.push((__start, __Symbol::Variant19(__nt), __end));\n (2, 21)\n }\n pub(crate) fn __reduce35<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // ( \",\")* = => ActionFn(157);\n let __start = __symbols.last().map(|s| s.2.clone()).unwrap_or_default();\n let __end = __lookahead_start.cloned().unwrap_or_else(|| __start.clone());\n let __nt = super::__action157::<>(text, &__start, &__end);\n __symbols.push((__start, __Symbol::Variant20(__nt), __end));\n (0, 22)\n }\n pub(crate) fn __reduce36<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // ( \",\")* = ( \",\")+ => ActionFn(158);\n let __sym0 = __pop_Variant20(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym0.2.clone();\n let __nt = super::__action158::<>(text, __sym0);\n __symbols.push((__start, __Symbol::Variant20(__nt), __end));\n (1, 22)\n }\n pub(crate) fn __reduce37<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // ( \",\")+ = AnnotatedPatternMapEntry, \",\" => ActionFn(232);\n let __sym1 = __pop_Variant0(__symbols);\n let __sym0 = __pop_Variant19(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym1.2.clone();\n let __nt = super::__action232::<>(text, __sym0, __sym1);\n __symbols.push((__start, __Symbol::Variant20(__nt), __end));\n (2, 23)\n }\n pub(crate) fn __reduce38<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // ( \",\")+ = ( \",\")+, AnnotatedPatternMapEntry, \",\" => ActionFn(233);\n let __sym2 = __pop_Variant0(__symbols);\n let __sym1 = __pop_Variant19(__symbols);\n let __sym0 = __pop_Variant20(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym2.2.clone();\n let __nt = super::__action233::<>(text, __sym0, __sym1, __sym2);\n __symbols.push((__start, __Symbol::Variant20(__nt), __end));\n (3, 23)\n }\n pub(crate) fn __reduce39<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // ( \"=\" ) = Atom, \"=\", Constant => ActionFn(110);\n let __sym2 = __pop_Variant24(__symbols);\n let __sym1 = __pop_Variant0(__symbols);\n let __sym0 = __pop_Variant45(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym2.2.clone();\n let __nt = super::__action110::<>(text, __sym0, __sym1, __sym2);\n __symbols.push((__start, __Symbol::Variant10(__nt), __end));\n (3, 24)\n }\n pub(crate) fn __reduce40<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // ( \"=\" )? = Atom, \"=\", Constant => ActionFn(211);\n let __sym2 = __pop_Variant24(__symbols);\n let __sym1 = __pop_Variant0(__symbols);\n let __sym0 = __pop_Variant45(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym2.2.clone();\n let __nt = super::__action211::<>(text, __sym0, __sym1, __sym2);\n __symbols.push((__start, __Symbol::Variant21(__nt), __end));\n (3, 25)\n }\n pub(crate) fn __reduce41<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // ( \"=\" )? = => ActionFn(124);\n let __start = __symbols.last().map(|s| s.2.clone()).unwrap_or_default();\n let __end = __lookahead_start.cloned().unwrap_or_else(|| __start.clone());\n let __nt = super::__action124::<>(text, &__start, &__end);\n __symbols.push((__start, __Symbol::Variant21(__nt), __end));\n (0, 25)\n }\n pub(crate) fn __reduce42<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // ( \",\") = BinaryElem, \",\" => ActionFn(169);\n let __sym1 = __pop_Variant0(__symbols);\n let __sym0 = __pop_Variant22(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym1.2.clone();\n let __nt = super::__action169::<>(text, __sym0, __sym1);\n __symbols.push((__start, __Symbol::Variant22(__nt), __end));\n (2, 26)\n }\n pub(crate) fn __reduce43<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // ( \",\")* = => ActionFn(167);\n let __start = __symbols.last().map(|s| s.2.clone()).unwrap_or_default();\n let __end = __lookahead_start.cloned().unwrap_or_else(|| __start.clone());\n let __nt = super::__action167::<>(text, &__start, &__end);\n __symbols.push((__start, __Symbol::Variant23(__nt), __end));\n (0, 27)\n }\n pub(crate) fn __reduce44<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // ( \",\")* = ( \",\")+ => ActionFn(168);\n let __sym0 = __pop_Variant23(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym0.2.clone();\n let __nt = super::__action168::<>(text, __sym0);\n __symbols.push((__start, __Symbol::Variant23(__nt), __end));\n (1, 27)\n }\n pub(crate) fn __reduce45<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // ( \",\")+ = BinaryElem, \",\" => ActionFn(240);\n let __sym1 = __pop_Variant0(__symbols);\n let __sym0 = __pop_Variant22(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym1.2.clone();\n let __nt = super::__action240::<>(text, __sym0, __sym1);\n __symbols.push((__start, __Symbol::Variant23(__nt), __end));\n (2, 28)\n }\n pub(crate) fn __reduce46<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // ( \",\")+ = ( \",\")+, BinaryElem, \",\" => ActionFn(241);\n let __sym2 = __pop_Variant0(__symbols);\n let __sym1 = __pop_Variant22(__symbols);\n let __sym0 = __pop_Variant23(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym2.2.clone();\n let __nt = super::__action241::<>(text, __sym0, __sym1, __sym2);\n __symbols.push((__start, __Symbol::Variant23(__nt), __end));\n (3, 28)\n }\n pub(crate) fn __reduce47<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // ( \",\") = Constant, \",\" => ActionFn(174);\n let __sym1 = __pop_Variant0(__symbols);\n let __sym0 = __pop_Variant24(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym1.2.clone();\n let __nt = super::__action174::<>(text, __sym0, __sym1);\n __symbols.push((__start, __Symbol::Variant24(__nt), __end));\n (2, 29)\n }\n pub(crate) fn __reduce48<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // ( \",\")* = => ActionFn(172);\n let __start = __symbols.last().map(|s| s.2.clone()).unwrap_or_default();\n let __end = __lookahead_start.cloned().unwrap_or_else(|| __start.clone());\n let __nt = super::__action172::<>(text, &__start, &__end);\n __symbols.push((__start, __Symbol::Variant25(__nt), __end));\n (0, 30)\n }\n pub(crate) fn __reduce49<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // ( \",\")* = ( \",\")+ => ActionFn(173);\n let __sym0 = __pop_Variant25(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym0.2.clone();\n let __nt = super::__action173::<>(text, __sym0);\n __symbols.push((__start, __Symbol::Variant25(__nt), __end));\n (1, 30)\n }\n pub(crate) fn __reduce50<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // ( \",\")+ = Constant, \",\" => ActionFn(244);\n let __sym1 = __pop_Variant0(__symbols);\n let __sym0 = __pop_Variant24(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym1.2.clone();\n let __nt = super::__action244::<>(text, __sym0, __sym1);\n __symbols.push((__start, __Symbol::Variant25(__nt), __end));\n (2, 31)\n }\n pub(crate) fn __reduce51<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // ( \",\")+ = ( \",\")+, Constant, \",\" => ActionFn(245);\n let __sym2 = __pop_Variant0(__symbols);\n let __sym1 = __pop_Variant24(__symbols);\n let __sym0 = __pop_Variant25(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym2.2.clone();\n let __nt = super::__action245::<>(text, __sym0, __sym1, __sym2);\n __symbols.push((__start, __Symbol::Variant25(__nt), __end));\n (3, 31)\n }\n pub(crate) fn __reduce52<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // ( \",\") = Expression, \",\" => ActionFn(142);\n let __sym1 = __pop_Variant0(__symbols);\n let __sym0 = __pop_Variant6(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym1.2.clone();\n let __nt = super::__action142::<>(text, __sym0, __sym1);\n __symbols.push((__start, __Symbol::Variant6(__nt), __end));\n (2, 32)\n }\n pub(crate) fn __reduce53<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // ( \",\")* = => ActionFn(140);\n let __start = __symbols.last().map(|s| s.2.clone()).unwrap_or_default();\n let __end = __lookahead_start.cloned().unwrap_or_else(|| __start.clone());\n let __nt = super::__action140::<>(text, &__start, &__end);\n __symbols.push((__start, __Symbol::Variant26(__nt), __end));\n (0, 33)\n }\n pub(crate) fn __reduce54<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // ( \",\")* = ( \",\")+ => ActionFn(141);\n let __sym0 = __pop_Variant26(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym0.2.clone();\n let __nt = super::__action141::<>(text, __sym0);\n __symbols.push((__start, __Symbol::Variant26(__nt), __end));\n (1, 33)\n }\n pub(crate) fn __reduce55<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // ( \",\")+ = Expression, \",\" => ActionFn(248);\n let __sym1 = __pop_Variant0(__symbols);\n let __sym0 = __pop_Variant6(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym1.2.clone();\n let __nt = super::__action248::<>(text, __sym0, __sym1);\n __symbols.push((__start, __Symbol::Variant26(__nt), __end));\n (2, 34)\n }\n pub(crate) fn __reduce56<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // ( \",\")+ = ( \",\")+, Expression, \",\" => ActionFn(249);\n let __sym2 = __pop_Variant0(__symbols);\n let __sym1 = __pop_Variant6(__symbols);\n let __sym0 = __pop_Variant26(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym2.2.clone();\n let __nt = super::__action249::<>(text, __sym0, __sym1, __sym2);\n __symbols.push((__start, __Symbol::Variant26(__nt), __end));\n (3, 34)\n }\n pub(crate) fn __reduce57<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // ( ) = Expression, ExactAssoc, Expression => ActionFn(92);\n let __sym2 = __pop_Variant6(__symbols);\n let __sym1 = __pop_Variant61(__symbols);\n let __sym0 = __pop_Variant6(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym2.2.clone();\n let __nt = super::__action92::<>(text, __sym0, __sym1, __sym2);\n __symbols.push((__start, __Symbol::Variant27(__nt), __end));\n (3, 35)\n }\n pub(crate) fn __reduce58<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // ( \",\") = FunctionName, \",\" => ActionFn(122);\n let __sym1 = __pop_Variant0(__symbols);\n let __sym0 = __pop_Variant28(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym1.2.clone();\n let __nt = super::__action122::<>(text, __sym0, __sym1);\n __symbols.push((__start, __Symbol::Variant28(__nt), __end));\n (2, 36)\n }\n pub(crate) fn __reduce59<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // ( \",\")* = => ActionFn(120);\n let __start = __symbols.last().map(|s| s.2.clone()).unwrap_or_default();\n let __end = __lookahead_start.cloned().unwrap_or_else(|| __start.clone());\n let __nt = super::__action120::<>(text, &__start, &__end);\n __symbols.push((__start, __Symbol::Variant29(__nt), __end));\n (0, 37)\n }\n pub(crate) fn __reduce60<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // ( \",\")* = ( \",\")+ => ActionFn(121);\n let __sym0 = __pop_Variant29(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym0.2.clone();\n let __nt = super::__action121::<>(text, __sym0);\n __symbols.push((__start, __Symbol::Variant29(__nt), __end));\n (1, 37)\n }\n pub(crate) fn __reduce61<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // ( \",\")+ = FunctionName, \",\" => ActionFn(254);\n let __sym1 = __pop_Variant0(__symbols);\n let __sym0 = __pop_Variant28(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym1.2.clone();\n let __nt = super::__action254::<>(text, __sym0, __sym1);\n __symbols.push((__start, __Symbol::Variant29(__nt), __end));\n (2, 38)\n }\n pub(crate) fn __reduce62<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // ( \",\")+ = ( \",\")+, FunctionName, \",\" => ActionFn(255);\n let __sym2 = __pop_Variant0(__symbols);\n let __sym1 = __pop_Variant28(__symbols);\n let __sym0 = __pop_Variant29(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym2.2.clone();\n let __nt = super::__action255::<>(text, __sym0, __sym1, __sym2);\n __symbols.push((__start, __Symbol::Variant29(__nt), __end));\n (3, 38)\n }\n pub(crate) fn __reduce63<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // ( \"=\" ) = FunctionName, \"=\", Fun => ActionFn(82);\n let __sym2 = __pop_Variant62(__symbols);\n let __sym1 = __pop_Variant0(__symbols);\n let __sym0 = __pop_Variant28(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym2.2.clone();\n let __nt = super::__action82::<>(text, __sym0, __sym1, __sym2);\n __symbols.push((__start, __Symbol::Variant30(__nt), __end));\n (3, 39)\n }\n pub(crate) fn __reduce64<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // ( \"=\" )+ = FunctionName, \"=\", Fun => ActionFn(258);\n let __sym2 = __pop_Variant62(__symbols);\n let __sym1 = __pop_Variant0(__symbols);\n let __sym0 = __pop_Variant28(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym2.2.clone();\n let __nt = super::__action258::<>(text, __sym0, __sym1, __sym2);\n __symbols.push((__start, __Symbol::Variant31(__nt), __end));\n (3, 40)\n }\n pub(crate) fn __reduce65<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // ( \"=\" )+ = ( \"=\" )+, FunctionName, \"=\", Fun => ActionFn(259);\n let __sym3 = __pop_Variant62(__symbols);\n let __sym2 = __pop_Variant0(__symbols);\n let __sym1 = __pop_Variant28(__symbols);\n let __sym0 = __pop_Variant31(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym3.2.clone();\n let __nt = super::__action259::<>(text, __sym0, __sym1, __sym2, __sym3);\n __symbols.push((__start, __Symbol::Variant31(__nt), __end));\n (4, 40)\n }\n pub(crate) fn __reduce66<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // ( \",\") = PatternBinaryElem, \",\" => ActionFn(164);\n let __sym1 = __pop_Variant0(__symbols);\n let __sym0 = __pop_Variant32(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym1.2.clone();\n let __nt = super::__action164::<>(text, __sym0, __sym1);\n __symbols.push((__start, __Symbol::Variant32(__nt), __end));\n (2, 41)\n }\n pub(crate) fn __reduce67<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // ( \",\")* = => ActionFn(162);\n let __start = __symbols.last().map(|s| s.2.clone()).unwrap_or_default();\n let __end = __lookahead_start.cloned().unwrap_or_else(|| __start.clone());\n let __nt = super::__action162::<>(text, &__start, &__end);\n __symbols.push((__start, __Symbol::Variant33(__nt), __end));\n (0, 42)\n }\n pub(crate) fn __reduce68<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // ( \",\")* = ( \",\")+ => ActionFn(163);\n let __sym0 = __pop_Variant33(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym0.2.clone();\n let __nt = super::__action163::<>(text, __sym0);\n __symbols.push((__start, __Symbol::Variant33(__nt), __end));\n (1, 42)\n }\n pub(crate) fn __reduce69<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // ( \",\")+ = PatternBinaryElem, \",\" => ActionFn(260);\n let __sym1 = __pop_Variant0(__symbols);\n let __sym0 = __pop_Variant32(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym1.2.clone();\n let __nt = super::__action260::<>(text, __sym0, __sym1);\n __symbols.push((__start, __Symbol::Variant33(__nt), __end));\n (2, 43)\n }\n pub(crate) fn __reduce70<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // ( \",\")+ = ( \",\")+, PatternBinaryElem, \",\" => ActionFn(261);\n let __sym2 = __pop_Variant0(__symbols);\n let __sym1 = __pop_Variant32(__symbols);\n let __sym0 = __pop_Variant33(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym2.2.clone();\n let __nt = super::__action261::<>(text, __sym0, __sym1, __sym2);\n __symbols.push((__start, __Symbol::Variant33(__nt), __end));\n (3, 43)\n }\n pub(crate) fn __reduce71<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Annotated<( )> = Expression, ExactAssoc, Expression => ActionFn(252);\n let __sym2 = __pop_Variant6(__symbols);\n let __sym1 = __pop_Variant61(__symbols);\n let __sym0 = __pop_Variant6(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym2.2.clone();\n let __nt = super::__action252::<>(text, __sym0, __sym1, __sym2);\n __symbols.push((__start, __Symbol::Variant12(__nt), __end));\n (3, 44)\n }\n pub(crate) fn __reduce72<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Annotated<( )> = \"(\", Expression, ExactAssoc, Expression, Annotations, \")\" => ActionFn(253);\n let __sym5 = __pop_Variant0(__symbols);\n let __sym4 = __pop_Variant44(__symbols);\n let __sym3 = __pop_Variant6(__symbols);\n let __sym2 = __pop_Variant61(__symbols);\n let __sym1 = __pop_Variant6(__symbols);\n let __sym0 = __pop_Variant0(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym5.2.clone();\n let __nt = super::__action253::<>(text, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5);\n __symbols.push((__start, __Symbol::Variant12(__nt), __end));\n (6, 44)\n }\n pub(crate) fn __reduce73<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Annotated<( )>? = Annotated<( )> => ActionFn(143);\n let __sym0 = __pop_Variant12(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym0.2.clone();\n let __nt = super::__action143::<>(text, __sym0);\n __symbols.push((__start, __Symbol::Variant34(__nt), __end));\n (1, 45)\n }\n pub(crate) fn __reduce74<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Annotated<( )>? = => ActionFn(144);\n let __start = __symbols.last().map(|s| s.2.clone()).unwrap_or_default();\n let __end = __lookahead_start.cloned().unwrap_or_else(|| __start.clone());\n let __nt = super::__action144::<>(text, &__start, &__end);\n __symbols.push((__start, __Symbol::Variant34(__nt), __end));\n (0, 45)\n }\n pub(crate) fn __reduce75<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Annotated = Atom => ActionFn(83);\n let __sym0 = __pop_Variant45(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym0.2.clone();\n let __nt = super::__action83::<>(text, __sym0);\n __symbols.push((__start, __Symbol::Variant16(__nt), __end));\n (1, 46)\n }\n pub(crate) fn __reduce76<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Annotated = \"(\", Atom, Annotations, \")\" => ActionFn(84);\n let __sym3 = __pop_Variant0(__symbols);\n let __sym2 = __pop_Variant44(__symbols);\n let __sym1 = __pop_Variant45(__symbols);\n let __sym0 = __pop_Variant0(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym3.2.clone();\n let __nt = super::__action84::<>(text, __sym0, __sym1, __sym2, __sym3);\n __symbols.push((__start, __Symbol::Variant16(__nt), __end));\n (4, 46)\n }\n pub(crate) fn __reduce77<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Annotated = Clause => ActionFn(87);\n let __sym0 = __pop_Variant49(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym0.2.clone();\n let __nt = super::__action87::<>(text, __sym0);\n __symbols.push((__start, __Symbol::Variant35(__nt), __end));\n (1, 47)\n }\n pub(crate) fn __reduce78<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Annotated = \"(\", Clause, Annotations, \")\" => ActionFn(88);\n let __sym3 = __pop_Variant0(__symbols);\n let __sym2 = __pop_Variant44(__symbols);\n let __sym1 = __pop_Variant49(__symbols);\n let __sym0 = __pop_Variant0(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym3.2.clone();\n let __nt = super::__action88::<>(text, __sym0, __sym1, __sym2, __sym3);\n __symbols.push((__start, __Symbol::Variant35(__nt), __end));\n (4, 47)\n }\n pub(crate) fn __reduce79<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Annotated* = => ActionFn(85);\n let __start = __symbols.last().map(|s| s.2.clone()).unwrap_or_default();\n let __end = __lookahead_start.cloned().unwrap_or_else(|| __start.clone());\n let __nt = super::__action85::<>(text, &__start, &__end);\n __symbols.push((__start, __Symbol::Variant36(__nt), __end));\n (0, 48)\n }\n pub(crate) fn __reduce80<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Annotated* = Annotated+ => ActionFn(86);\n let __sym0 = __pop_Variant36(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym0.2.clone();\n let __nt = super::__action86::<>(text, __sym0);\n __symbols.push((__start, __Symbol::Variant36(__nt), __end));\n (1, 48)\n }\n pub(crate) fn __reduce81<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Annotated+ = Annotated => ActionFn(148);\n let __sym0 = __pop_Variant35(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym0.2.clone();\n let __nt = super::__action148::<>(text, __sym0);\n __symbols.push((__start, __Symbol::Variant36(__nt), __end));\n (1, 49)\n }\n pub(crate) fn __reduce82<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Annotated+ = Annotated+, Annotated => ActionFn(149);\n let __sym1 = __pop_Variant35(__symbols);\n let __sym0 = __pop_Variant36(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym1.2.clone();\n let __nt = super::__action149::<>(text, __sym0, __sym1);\n __symbols.push((__start, __Symbol::Variant36(__nt), __end));\n (2, 49)\n }\n pub(crate) fn __reduce83<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Annotated = Fun => ActionFn(105);\n let __sym0 = __pop_Variant62(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym0.2.clone();\n let __nt = super::__action105::<>(text, __sym0);\n __symbols.push((__start, __Symbol::Variant37(__nt), __end));\n (1, 50)\n }\n pub(crate) fn __reduce84<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Annotated = \"(\", Fun, Annotations, \")\" => ActionFn(106);\n let __sym3 = __pop_Variant0(__symbols);\n let __sym2 = __pop_Variant44(__symbols);\n let __sym1 = __pop_Variant62(__symbols);\n let __sym0 = __pop_Variant0(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym3.2.clone();\n let __nt = super::__action106::<>(text, __sym0, __sym1, __sym2, __sym3);\n __symbols.push((__start, __Symbol::Variant37(__nt), __end));\n (4, 50)\n }\n pub(crate) fn __reduce85<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Annotated = FunctionName => ActionFn(107);\n let __sym0 = __pop_Variant28(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym0.2.clone();\n let __nt = super::__action107::<>(text, __sym0);\n __symbols.push((__start, __Symbol::Variant38(__nt), __end));\n (1, 51)\n }\n pub(crate) fn __reduce86<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Annotated = \"(\", FunctionName, Annotations, \")\" => ActionFn(108);\n let __sym3 = __pop_Variant0(__symbols);\n let __sym2 = __pop_Variant44(__symbols);\n let __sym1 = __pop_Variant28(__symbols);\n let __sym0 = __pop_Variant0(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym3.2.clone();\n let __nt = super::__action108::<>(text, __sym0, __sym1, __sym2, __sym3);\n __symbols.push((__start, __Symbol::Variant38(__nt), __end));\n (4, 51)\n }\n pub(crate) fn __reduce87<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Annotated = Module => ActionFn(114);\n let __sym0 = __pop_Variant67(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym0.2.clone();\n let __nt = super::__action114::<>(text, __sym0);\n __symbols.push((__start, __Symbol::Variant39(__nt), __end));\n (1, 52)\n }\n pub(crate) fn __reduce88<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Annotated = \"(\", Module, Annotations, \")\" => ActionFn(115);\n let __sym3 = __pop_Variant0(__symbols);\n let __sym2 = __pop_Variant44(__symbols);\n let __sym1 = __pop_Variant67(__symbols);\n let __sym0 = __pop_Variant0(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym3.2.clone();\n let __nt = super::__action115::<>(text, __sym0, __sym1, __sym2, __sym3);\n __symbols.push((__start, __Symbol::Variant39(__nt), __end));\n (4, 52)\n }\n pub(crate) fn __reduce89<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Annotated = Annotated, \"=\", AnnotatedPattern => ActionFn(306);\n let __sym2 = __pop_Variant4(__symbols);\n let __sym1 = __pop_Variant0(__symbols);\n let __sym0 = __pop_Variant16(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym2.2.clone();\n let __nt = super::__action306::<>(text, __sym0, __sym1, __sym2);\n __symbols.push((__start, __Symbol::Variant4(__nt), __end));\n (3, 53)\n }\n pub(crate) fn __reduce90<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Annotated = Variable => ActionFn(307);\n let __sym0 = __pop_Variant45(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym0.2.clone();\n let __nt = super::__action307::<>(text, __sym0);\n __symbols.push((__start, __Symbol::Variant4(__nt), __end));\n (1, 53)\n }\n pub(crate) fn __reduce91<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Annotated = AtomicTerm => ActionFn(308);\n let __sym0 = __pop_Variant46(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym0.2.clone();\n let __nt = super::__action308::<>(text, __sym0);\n __symbols.push((__start, __Symbol::Variant4(__nt), __end));\n (1, 53)\n }\n pub(crate) fn __reduce92<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Annotated = PatternBinary => ActionFn(309);\n let __sym0 = __pop_Variant59(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym0.2.clone();\n let __nt = super::__action309::<>(text, __sym0);\n __symbols.push((__start, __Symbol::Variant4(__nt), __end));\n (1, 53)\n }\n pub(crate) fn __reduce93<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Annotated = \"{\", Comma, \"}\" => ActionFn(310);\n let __sym2 = __pop_Variant0(__symbols);\n let __sym1 = __pop_Variant54(__symbols);\n let __sym0 = __pop_Variant0(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym2.2.clone();\n let __nt = super::__action310::<>(text, __sym0, __sym1, __sym2);\n __symbols.push((__start, __Symbol::Variant4(__nt), __end));\n (3, 53)\n }\n pub(crate) fn __reduce94<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Annotated = \"~{\", Comma, \"}~\" => ActionFn(311);\n let __sym2 = __pop_Variant0(__symbols);\n let __sym1 = __pop_Variant55(__symbols);\n let __sym0 = __pop_Variant0(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym2.2.clone();\n let __nt = super::__action311::<>(text, __sym0, __sym1, __sym2);\n __symbols.push((__start, __Symbol::Variant4(__nt), __end));\n (3, 53)\n }\n pub(crate) fn __reduce95<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Annotated = \"[\", Comma, \"|\", AnnotatedPattern, \"]\" => ActionFn(312);\n let __sym4 = __pop_Variant0(__symbols);\n let __sym3 = __pop_Variant4(__symbols);\n let __sym2 = __pop_Variant0(__symbols);\n let __sym1 = __pop_Variant54(__symbols);\n let __sym0 = __pop_Variant0(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym4.2.clone();\n let __nt = super::__action312::<>(text, __sym0, __sym1, __sym2, __sym3, __sym4);\n __symbols.push((__start, __Symbol::Variant4(__nt), __end));\n (5, 53)\n }\n pub(crate) fn __reduce96<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Annotated = \"[\", Comma, \"]\" => ActionFn(313);\n let __sym2 = __pop_Variant0(__symbols);\n let __sym1 = __pop_Variant54(__symbols);\n let __sym0 = __pop_Variant0(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym2.2.clone();\n let __nt = super::__action313::<>(text, __sym0, __sym1, __sym2);\n __symbols.push((__start, __Symbol::Variant4(__nt), __end));\n (3, 53)\n }\n pub(crate) fn __reduce97<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Annotated = \"(\", Annotated, \"=\", AnnotatedPattern, Annotations, \")\" => ActionFn(314);\n let __sym5 = __pop_Variant0(__symbols);\n let __sym4 = __pop_Variant44(__symbols);\n let __sym3 = __pop_Variant4(__symbols);\n let __sym2 = __pop_Variant0(__symbols);\n let __sym1 = __pop_Variant16(__symbols);\n let __sym0 = __pop_Variant0(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym5.2.clone();\n let __nt = super::__action314::<>(text, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5);\n __symbols.push((__start, __Symbol::Variant4(__nt), __end));\n (6, 53)\n }\n pub(crate) fn __reduce98<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Annotated = \"(\", Variable, Annotations, \")\" => ActionFn(315);\n let __sym3 = __pop_Variant0(__symbols);\n let __sym2 = __pop_Variant44(__symbols);\n let __sym1 = __pop_Variant45(__symbols);\n let __sym0 = __pop_Variant0(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym3.2.clone();\n let __nt = super::__action315::<>(text, __sym0, __sym1, __sym2, __sym3);\n __symbols.push((__start, __Symbol::Variant4(__nt), __end));\n (4, 53)\n }\n pub(crate) fn __reduce99<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Annotated = \"(\", AtomicTerm, Annotations, \")\" => ActionFn(316);\n let __sym3 = __pop_Variant0(__symbols);\n let __sym2 = __pop_Variant44(__symbols);\n let __sym1 = __pop_Variant46(__symbols);\n let __sym0 = __pop_Variant0(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym3.2.clone();\n let __nt = super::__action316::<>(text, __sym0, __sym1, __sym2, __sym3);\n __symbols.push((__start, __Symbol::Variant4(__nt), __end));\n (4, 53)\n }\n pub(crate) fn __reduce100<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Annotated = \"(\", PatternBinary, Annotations, \")\" => ActionFn(317);\n let __sym3 = __pop_Variant0(__symbols);\n let __sym2 = __pop_Variant44(__symbols);\n let __sym1 = __pop_Variant59(__symbols);\n let __sym0 = __pop_Variant0(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym3.2.clone();\n let __nt = super::__action317::<>(text, __sym0, __sym1, __sym2, __sym3);\n __symbols.push((__start, __Symbol::Variant4(__nt), __end));\n (4, 53)\n }\n pub(crate) fn __reduce101<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Annotated = \"(\", \"{\", Comma, \"}\", Annotations, \")\" => ActionFn(318);\n let __sym5 = __pop_Variant0(__symbols);\n let __sym4 = __pop_Variant44(__symbols);\n let __sym3 = __pop_Variant0(__symbols);\n let __sym2 = __pop_Variant54(__symbols);\n let __sym1 = __pop_Variant0(__symbols);\n let __sym0 = __pop_Variant0(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym5.2.clone();\n let __nt = super::__action318::<>(text, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5);\n __symbols.push((__start, __Symbol::Variant4(__nt), __end));\n (6, 53)\n }\n pub(crate) fn __reduce102<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Annotated = \"(\", \"~{\", Comma, \"}~\", Annotations, \")\" => ActionFn(319);\n let __sym5 = __pop_Variant0(__symbols);\n let __sym4 = __pop_Variant44(__symbols);\n let __sym3 = __pop_Variant0(__symbols);\n let __sym2 = __pop_Variant55(__symbols);\n let __sym1 = __pop_Variant0(__symbols);\n let __sym0 = __pop_Variant0(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym5.2.clone();\n let __nt = super::__action319::<>(text, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5);\n __symbols.push((__start, __Symbol::Variant4(__nt), __end));\n (6, 53)\n }\n pub(crate) fn __reduce103<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Annotated = \"(\", \"[\", Comma, \"|\", AnnotatedPattern, \"]\", Annotations, \")\" => ActionFn(320);\n let __sym7 = __pop_Variant0(__symbols);\n let __sym6 = __pop_Variant44(__symbols);\n let __sym5 = __pop_Variant0(__symbols);\n let __sym4 = __pop_Variant4(__symbols);\n let __sym3 = __pop_Variant0(__symbols);\n let __sym2 = __pop_Variant54(__symbols);\n let __sym1 = __pop_Variant0(__symbols);\n let __sym0 = __pop_Variant0(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym7.2.clone();\n let __nt = super::__action320::<>(text, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5, __sym6, __sym7);\n __symbols.push((__start, __Symbol::Variant4(__nt), __end));\n (8, 53)\n }\n pub(crate) fn __reduce104<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Annotated = \"(\", \"[\", Comma, \"]\", Annotations, \")\" => ActionFn(321);\n let __sym5 = __pop_Variant0(__symbols);\n let __sym4 = __pop_Variant44(__symbols);\n let __sym3 = __pop_Variant0(__symbols);\n let __sym2 = __pop_Variant54(__symbols);\n let __sym1 = __pop_Variant0(__symbols);\n let __sym0 = __pop_Variant0(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym5.2.clone();\n let __nt = super::__action321::<>(text, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5);\n __symbols.push((__start, __Symbol::Variant4(__nt), __end));\n (6, 53)\n }\n pub(crate) fn __reduce105<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Annotated = PatternMapEntry => ActionFn(75);\n let __sym0 = __pop_Variant70(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym0.2.clone();\n let __nt = super::__action75::<>(text, __sym0);\n __symbols.push((__start, __Symbol::Variant19(__nt), __end));\n (1, 54)\n }\n pub(crate) fn __reduce106<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Annotated = \"(\", PatternMapEntry, Annotations, \")\" => ActionFn(76);\n let __sym3 = __pop_Variant0(__symbols);\n let __sym2 = __pop_Variant44(__symbols);\n let __sym1 = __pop_Variant70(__symbols);\n let __sym0 = __pop_Variant0(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym3.2.clone();\n let __nt = super::__action76::<>(text, __sym0, __sym1, __sym2, __sym3);\n __symbols.push((__start, __Symbol::Variant19(__nt), __end));\n (4, 54)\n }\n pub(crate) fn __reduce107<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Annotated = SingleExpression => ActionFn(98);\n let __sym0 = __pop_Variant71(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym0.2.clone();\n let __nt = super::__action98::<>(text, __sym0);\n __symbols.push((__start, __Symbol::Variant14(__nt), __end));\n (1, 55)\n }\n pub(crate) fn __reduce108<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Annotated = \"(\", SingleExpression, Annotations, \")\" => ActionFn(99);\n let __sym3 = __pop_Variant0(__symbols);\n let __sym2 = __pop_Variant44(__symbols);\n let __sym1 = __pop_Variant71(__symbols);\n let __sym0 = __pop_Variant0(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym3.2.clone();\n let __nt = super::__action99::<>(text, __sym0, __sym1, __sym2, __sym3);\n __symbols.push((__start, __Symbol::Variant14(__nt), __end));\n (4, 55)\n }\n pub(crate) fn __reduce109<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Annotated? = Annotated => ActionFn(133);\n let __sym0 = __pop_Variant14(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym0.2.clone();\n let __nt = super::__action133::<>(text, __sym0);\n __symbols.push((__start, __Symbol::Variant40(__nt), __end));\n (1, 56)\n }\n pub(crate) fn __reduce110<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Annotated? = => ActionFn(134);\n let __start = __symbols.last().map(|s| s.2.clone()).unwrap_or_default();\n let __end = __lookahead_start.cloned().unwrap_or_else(|| __start.clone());\n let __nt = super::__action134::<>(text, &__start, &__end);\n __symbols.push((__start, __Symbol::Variant40(__nt), __end));\n (0, 56)\n }\n pub(crate) fn __reduce111<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Annotated = ValueList => ActionFn(100);\n let __sym0 = __pop_Variant52(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym0.2.clone();\n let __nt = super::__action100::<>(text, __sym0);\n __symbols.push((__start, __Symbol::Variant41(__nt), __end));\n (1, 57)\n }\n pub(crate) fn __reduce112<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Annotated = \"(\", ValueList, Annotations, \")\" => ActionFn(101);\n let __sym3 = __pop_Variant0(__symbols);\n let __sym2 = __pop_Variant44(__symbols);\n let __sym1 = __pop_Variant52(__symbols);\n let __sym0 = __pop_Variant0(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym3.2.clone();\n let __nt = super::__action101::<>(text, __sym0, __sym1, __sym2, __sym3);\n __symbols.push((__start, __Symbol::Variant41(__nt), __end));\n (4, 57)\n }\n pub(crate) fn __reduce113<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Annotated = Variable => ActionFn(103);\n let __sym0 = __pop_Variant45(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym0.2.clone();\n let __nt = super::__action103::<>(text, __sym0);\n __symbols.push((__start, __Symbol::Variant16(__nt), __end));\n (1, 58)\n }\n pub(crate) fn __reduce114<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Annotated = \"(\", Variable, Annotations, \")\" => ActionFn(104);\n let __sym3 = __pop_Variant0(__symbols);\n let __sym2 = __pop_Variant44(__symbols);\n let __sym1 = __pop_Variant45(__symbols);\n let __sym0 = __pop_Variant0(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym3.2.clone();\n let __nt = super::__action104::<>(text, __sym0, __sym1, __sym2, __sym3);\n __symbols.push((__start, __Symbol::Variant16(__nt), __end));\n (4, 58)\n }\n pub(crate) fn __reduce115<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Annotated? = Annotated => ActionFn(128);\n let __sym0 = __pop_Variant16(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym0.2.clone();\n let __nt = super::__action128::<>(text, __sym0);\n __symbols.push((__start, __Symbol::Variant42(__nt), __end));\n (1, 59)\n }\n pub(crate) fn __reduce116<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Annotated? = => ActionFn(129);\n let __start = __symbols.last().map(|s| s.2.clone()).unwrap_or_default();\n let __end = __lookahead_start.cloned().unwrap_or_else(|| __start.clone());\n let __nt = super::__action129::<>(text, &__start, &__end);\n __symbols.push((__start, __Symbol::Variant42(__nt), __end));\n (0, 59)\n }\n pub(crate) fn __reduce117<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // AnnotatedModule = Annotated => ActionFn(4);\n let __sym0 = __pop_Variant39(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym0.2.clone();\n let __nt = super::__action4::<>(text, __sym0);\n __symbols.push((__start, __Symbol::Variant39(__nt), __end));\n (1, 60)\n }\n pub(crate) fn __reduce118<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // AnnotatedPattern = Annotated => ActionFn(41);\n let __sym0 = __pop_Variant4(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym0.2.clone();\n let __nt = super::__action41::<>(text, __sym0);\n __symbols.push((__start, __Symbol::Variant4(__nt), __end));\n (1, 61)\n }\n pub(crate) fn __reduce119<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // AnnotatedPattern? = AnnotatedPattern => ActionFn(150);\n let __sym0 = __pop_Variant4(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym0.2.clone();\n let __nt = super::__action150::<>(text, __sym0);\n __symbols.push((__start, __Symbol::Variant5(__nt), __end));\n (1, 62)\n }\n pub(crate) fn __reduce120<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // AnnotatedPattern? = => ActionFn(151);\n let __start = __symbols.last().map(|s| s.2.clone()).unwrap_or_default();\n let __end = __lookahead_start.cloned().unwrap_or_else(|| __start.clone());\n let __nt = super::__action151::<>(text, &__start, &__end);\n __symbols.push((__start, __Symbol::Variant5(__nt), __end));\n (0, 62)\n }\n pub(crate) fn __reduce121<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // AnnotatedPatternMapEntry = Annotated => ActionFn(43);\n let __sym0 = __pop_Variant19(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym0.2.clone();\n let __nt = super::__action43::<>(text, __sym0);\n __symbols.push((__start, __Symbol::Variant19(__nt), __end));\n (1, 63)\n }\n pub(crate) fn __reduce122<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // AnnotatedPatternMapEntry? = AnnotatedPatternMapEntry => ActionFn(155);\n let __sym0 = __pop_Variant19(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym0.2.clone();\n let __nt = super::__action155::<>(text, __sym0);\n __symbols.push((__start, __Symbol::Variant43(__nt), __end));\n (1, 64)\n }\n pub(crate) fn __reduce123<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // AnnotatedPatternMapEntry? = => ActionFn(156);\n let __start = __symbols.last().map(|s| s.2.clone()).unwrap_or_default();\n let __end = __lookahead_start.cloned().unwrap_or_else(|| __start.clone());\n let __nt = super::__action156::<>(text, &__start, &__end);\n __symbols.push((__start, __Symbol::Variant43(__nt), __end));\n (0, 64)\n }\n pub(crate) fn __reduce124<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Annotations = \"-|\", \"[\", Comma, \"]\" => ActionFn(64);\n let __sym3 = __pop_Variant0(__symbols);\n let __sym2 = __pop_Variant56(__symbols);\n let __sym1 = __pop_Variant0(__symbols);\n let __sym0 = __pop_Variant0(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym3.2.clone();\n let __nt = super::__action64::<>(text, __sym0, __sym1, __sym2, __sym3);\n __symbols.push((__start, __Symbol::Variant44(__nt), __end));\n (4, 65)\n }\n pub(crate) fn __reduce125<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Atom = \"Atom\" => ActionFn(2);\n let __sym0 = __pop_Variant1(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym0.2.clone();\n let __nt = super::__action2::<>(text, __sym0);\n __symbols.push((__start, __Symbol::Variant45(__nt), __end));\n (1, 66)\n }\n pub(crate) fn __reduce126<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // AtomicTerm = Integer => ActionFn(58);\n let __sym0 = __pop_Variant66(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym0.2.clone();\n let __nt = super::__action58::<>(text, __sym0);\n __symbols.push((__start, __Symbol::Variant46(__nt), __end));\n (1, 67)\n }\n pub(crate) fn __reduce127<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // AtomicTerm = Atom => ActionFn(59);\n let __sym0 = __pop_Variant45(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym0.2.clone();\n let __nt = super::__action59::<>(text, __sym0);\n __symbols.push((__start, __Symbol::Variant46(__nt), __end));\n (1, 67)\n }\n pub(crate) fn __reduce128<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // AtomicTerm = \"Char\" => ActionFn(60);\n let __sym0 = __pop_Variant2(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym0.2.clone();\n let __nt = super::__action60::<>(text, __sym0);\n __symbols.push((__start, __Symbol::Variant46(__nt), __end));\n (1, 67)\n }\n pub(crate) fn __reduce129<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // AtomicTerm = \"String\" => ActionFn(61);\n let __sym0 = __pop_Variant1(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym0.2.clone();\n let __nt = super::__action61::<>(text, __sym0);\n __symbols.push((__start, __Symbol::Variant46(__nt), __end));\n (1, 67)\n }\n pub(crate) fn __reduce130<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Binary = \"#{\", Comma, \"}#\" => ActionFn(53);\n let __sym2 = __pop_Variant0(__symbols);\n let __sym1 = __pop_Variant47(__symbols);\n let __sym0 = __pop_Variant0(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym2.2.clone();\n let __nt = super::__action53::<>(text, __sym0, __sym1, __sym2);\n __symbols.push((__start, __Symbol::Variant47(__nt), __end));\n (3, 68)\n }\n pub(crate) fn __reduce131<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // BinaryElem = \"#<\", Expression, \">(\", Comma, \")\" => ActionFn(54);\n let __sym4 = __pop_Variant0(__symbols);\n let __sym3 = __pop_Variant57(__symbols);\n let __sym2 = __pop_Variant0(__symbols);\n let __sym1 = __pop_Variant6(__symbols);\n let __sym0 = __pop_Variant0(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym4.2.clone();\n let __nt = super::__action54::<>(text, __sym0, __sym1, __sym2, __sym3, __sym4);\n __symbols.push((__start, __Symbol::Variant22(__nt), __end));\n (5, 69)\n }\n pub(crate) fn __reduce132<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // BinaryElem? = BinaryElem => ActionFn(165);\n let __sym0 = __pop_Variant22(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym0.2.clone();\n let __nt = super::__action165::<>(text, __sym0);\n __symbols.push((__start, __Symbol::Variant48(__nt), __end));\n (1, 70)\n }\n pub(crate) fn __reduce133<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // BinaryElem? = => ActionFn(166);\n let __start = __symbols.last().map(|s| s.2.clone()).unwrap_or_default();\n let __end = __lookahead_start.cloned().unwrap_or_else(|| __start.clone());\n let __nt = super::__action166::<>(text, &__start, &__end);\n __symbols.push((__start, __Symbol::Variant48(__nt), __end));\n (0, 70)\n }\n pub(crate) fn __reduce134<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Clause = Patterns, Guard, \"->\", Expression => ActionFn(35);\n let __sym3 = __pop_Variant6(__symbols);\n let __sym2 = __pop_Variant0(__symbols);\n let __sym1 = __pop_Variant6(__symbols);\n let __sym0 = __pop_Variant54(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym3.2.clone();\n let __nt = super::__action35::<>(text, __sym0, __sym1, __sym2, __sym3);\n __symbols.push((__start, __Symbol::Variant49(__nt), __end));\n (4, 71)\n }\n pub(crate) fn __reduce135<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Comma<( \"=\" )> = Atom, \"=\", Constant => ActionFn(236);\n let __sym2 = __pop_Variant24(__symbols);\n let __sym1 = __pop_Variant0(__symbols);\n let __sym0 = __pop_Variant45(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym2.2.clone();\n let __nt = super::__action236::<>(text, __sym0, __sym1, __sym2);\n __symbols.push((__start, __Symbol::Variant50(__nt), __end));\n (3, 72)\n }\n pub(crate) fn __reduce136<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Comma<( \"=\" )> = => ActionFn(237);\n let __start = __symbols.last().map(|s| s.2.clone()).unwrap_or_default();\n let __end = __lookahead_start.cloned().unwrap_or_else(|| __start.clone());\n let __nt = super::__action237::<>(text, &__start, &__end);\n __symbols.push((__start, __Symbol::Variant50(__nt), __end));\n (0, 72)\n }\n pub(crate) fn __reduce137<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Comma<( \"=\" )> = (<( \"=\" )> \",\")+, Atom, \"=\", Constant => ActionFn(238);\n let __sym3 = __pop_Variant24(__symbols);\n let __sym2 = __pop_Variant0(__symbols);\n let __sym1 = __pop_Variant45(__symbols);\n let __sym0 = __pop_Variant11(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym3.2.clone();\n let __nt = super::__action238::<>(text, __sym0, __sym1, __sym2, __sym3);\n __symbols.push((__start, __Symbol::Variant50(__nt), __end));\n (4, 72)\n }\n pub(crate) fn __reduce138<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Comma<( \"=\" )> = (<( \"=\" )> \",\")+ => ActionFn(239);\n let __sym0 = __pop_Variant11(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym0.2.clone();\n let __nt = super::__action239::<>(text, __sym0);\n __symbols.push((__start, __Symbol::Variant50(__nt), __end));\n (1, 72)\n }\n pub(crate) fn __reduce139<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Comma )>> = Annotated<( )> => ActionFn(264);\n let __sym0 = __pop_Variant12(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym0.2.clone();\n let __nt = super::__action264::<>(text, __sym0);\n __symbols.push((__start, __Symbol::Variant51(__nt), __end));\n (1, 73)\n }\n pub(crate) fn __reduce140<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Comma )>> = => ActionFn(265);\n let __start = __symbols.last().map(|s| s.2.clone()).unwrap_or_default();\n let __end = __lookahead_start.cloned().unwrap_or_else(|| __start.clone());\n let __nt = super::__action265::<>(text, &__start, &__end);\n __symbols.push((__start, __Symbol::Variant51(__nt), __end));\n (0, 73)\n }\n pub(crate) fn __reduce141<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Comma )>> = ( )>> \",\")+, Annotated<( )> => ActionFn(266);\n let __sym1 = __pop_Variant12(__symbols);\n let __sym0 = __pop_Variant13(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym1.2.clone();\n let __nt = super::__action266::<>(text, __sym0, __sym1);\n __symbols.push((__start, __Symbol::Variant51(__nt), __end));\n (2, 73)\n }\n pub(crate) fn __reduce142<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Comma )>> = ( )>> \",\")+ => ActionFn(267);\n let __sym0 = __pop_Variant13(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym0.2.clone();\n let __nt = super::__action267::<>(text, __sym0);\n __symbols.push((__start, __Symbol::Variant51(__nt), __end));\n (1, 73)\n }\n pub(crate) fn __reduce143<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Comma> = Annotated => ActionFn(272);\n let __sym0 = __pop_Variant14(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym0.2.clone();\n let __nt = super::__action272::<>(text, __sym0);\n __symbols.push((__start, __Symbol::Variant52(__nt), __end));\n (1, 74)\n }\n pub(crate) fn __reduce144<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Comma> = => ActionFn(273);\n let __start = __symbols.last().map(|s| s.2.clone()).unwrap_or_default();\n let __end = __lookahead_start.cloned().unwrap_or_else(|| __start.clone());\n let __nt = super::__action273::<>(text, &__start, &__end);\n __symbols.push((__start, __Symbol::Variant52(__nt), __end));\n (0, 74)\n }\n pub(crate) fn __reduce145<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Comma> = (> \",\")+, Annotated => ActionFn(274);\n let __sym1 = __pop_Variant14(__symbols);\n let __sym0 = __pop_Variant15(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym1.2.clone();\n let __nt = super::__action274::<>(text, __sym0, __sym1);\n __symbols.push((__start, __Symbol::Variant52(__nt), __end));\n (2, 74)\n }\n pub(crate) fn __reduce146<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Comma> = (> \",\")+ => ActionFn(275);\n let __sym0 = __pop_Variant15(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym0.2.clone();\n let __nt = super::__action275::<>(text, __sym0);\n __symbols.push((__start, __Symbol::Variant52(__nt), __end));\n (1, 74)\n }\n pub(crate) fn __reduce147<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Comma> = Annotated => ActionFn(276);\n let __sym0 = __pop_Variant16(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym0.2.clone();\n let __nt = super::__action276::<>(text, __sym0);\n __symbols.push((__start, __Symbol::Variant53(__nt), __end));\n (1, 75)\n }\n pub(crate) fn __reduce148<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Comma> = => ActionFn(277);\n let __start = __symbols.last().map(|s| s.2.clone()).unwrap_or_default();\n let __end = __lookahead_start.cloned().unwrap_or_else(|| __start.clone());\n let __nt = super::__action277::<>(text, &__start, &__end);\n __symbols.push((__start, __Symbol::Variant53(__nt), __end));\n (0, 75)\n }\n pub(crate) fn __reduce149<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Comma> = (> \",\")+, Annotated => ActionFn(278);\n let __sym1 = __pop_Variant16(__symbols);\n let __sym0 = __pop_Variant17(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym1.2.clone();\n let __nt = super::__action278::<>(text, __sym0, __sym1);\n __symbols.push((__start, __Symbol::Variant53(__nt), __end));\n (2, 75)\n }\n pub(crate) fn __reduce150<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Comma> = (> \",\")+ => ActionFn(279);\n let __sym0 = __pop_Variant17(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym0.2.clone();\n let __nt = super::__action279::<>(text, __sym0);\n __symbols.push((__start, __Symbol::Variant53(__nt), __end));\n (1, 75)\n }\n pub(crate) fn __reduce151<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Comma = AnnotatedPattern => ActionFn(280);\n let __sym0 = __pop_Variant4(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym0.2.clone();\n let __nt = super::__action280::<>(text, __sym0);\n __symbols.push((__start, __Symbol::Variant54(__nt), __end));\n (1, 76)\n }\n pub(crate) fn __reduce152<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Comma = => ActionFn(281);\n let __start = __symbols.last().map(|s| s.2.clone()).unwrap_or_default();\n let __end = __lookahead_start.cloned().unwrap_or_else(|| __start.clone());\n let __nt = super::__action281::<>(text, &__start, &__end);\n __symbols.push((__start, __Symbol::Variant54(__nt), __end));\n (0, 76)\n }\n pub(crate) fn __reduce153<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Comma = ( \",\")+, AnnotatedPattern => ActionFn(282);\n let __sym1 = __pop_Variant4(__symbols);\n let __sym0 = __pop_Variant18(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym1.2.clone();\n let __nt = super::__action282::<>(text, __sym0, __sym1);\n __symbols.push((__start, __Symbol::Variant54(__nt), __end));\n (2, 76)\n }\n pub(crate) fn __reduce154<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Comma = ( \",\")+ => ActionFn(283);\n let __sym0 = __pop_Variant18(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym0.2.clone();\n let __nt = super::__action283::<>(text, __sym0);\n __symbols.push((__start, __Symbol::Variant54(__nt), __end));\n (1, 76)\n }\n pub(crate) fn __reduce155<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Comma = AnnotatedPatternMapEntry => ActionFn(284);\n let __sym0 = __pop_Variant19(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym0.2.clone();\n let __nt = super::__action284::<>(text, __sym0);\n __symbols.push((__start, __Symbol::Variant55(__nt), __end));\n (1, 77)\n }\n pub(crate) fn __reduce156<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Comma = => ActionFn(285);\n let __start = __symbols.last().map(|s| s.2.clone()).unwrap_or_default();\n let __end = __lookahead_start.cloned().unwrap_or_else(|| __start.clone());\n let __nt = super::__action285::<>(text, &__start, &__end);\n __symbols.push((__start, __Symbol::Variant55(__nt), __end));\n (0, 77)\n }\n pub(crate) fn __reduce157<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Comma = ( \",\")+, AnnotatedPatternMapEntry => ActionFn(286);\n let __sym1 = __pop_Variant19(__symbols);\n let __sym0 = __pop_Variant20(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym1.2.clone();\n let __nt = super::__action286::<>(text, __sym0, __sym1);\n __symbols.push((__start, __Symbol::Variant55(__nt), __end));\n (2, 77)\n }\n pub(crate) fn __reduce158<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Comma = ( \",\")+ => ActionFn(287);\n let __sym0 = __pop_Variant20(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym0.2.clone();\n let __nt = super::__action287::<>(text, __sym0);\n __symbols.push((__start, __Symbol::Variant55(__nt), __end));\n (1, 77)\n }\n pub(crate) fn __reduce159<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Comma = BinaryElem => ActionFn(288);\n let __sym0 = __pop_Variant22(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym0.2.clone();\n let __nt = super::__action288::<>(text, __sym0);\n __symbols.push((__start, __Symbol::Variant47(__nt), __end));\n (1, 78)\n }\n pub(crate) fn __reduce160<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Comma = => ActionFn(289);\n let __start = __symbols.last().map(|s| s.2.clone()).unwrap_or_default();\n let __end = __lookahead_start.cloned().unwrap_or_else(|| __start.clone());\n let __nt = super::__action289::<>(text, &__start, &__end);\n __symbols.push((__start, __Symbol::Variant47(__nt), __end));\n (0, 78)\n }\n pub(crate) fn __reduce161<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Comma = ( \",\")+, BinaryElem => ActionFn(290);\n let __sym1 = __pop_Variant22(__symbols);\n let __sym0 = __pop_Variant23(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym1.2.clone();\n let __nt = super::__action290::<>(text, __sym0, __sym1);\n __symbols.push((__start, __Symbol::Variant47(__nt), __end));\n (2, 78)\n }\n pub(crate) fn __reduce162<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Comma = ( \",\")+ => ActionFn(291);\n let __sym0 = __pop_Variant23(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym0.2.clone();\n let __nt = super::__action291::<>(text, __sym0);\n __symbols.push((__start, __Symbol::Variant47(__nt), __end));\n (1, 78)\n }\n pub(crate) fn __reduce163<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Comma = Constant => ActionFn(292);\n let __sym0 = __pop_Variant24(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym0.2.clone();\n let __nt = super::__action292::<>(text, __sym0);\n __symbols.push((__start, __Symbol::Variant56(__nt), __end));\n (1, 79)\n }\n pub(crate) fn __reduce164<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Comma = => ActionFn(293);\n let __start = __symbols.last().map(|s| s.2.clone()).unwrap_or_default();\n let __end = __lookahead_start.cloned().unwrap_or_else(|| __start.clone());\n let __nt = super::__action293::<>(text, &__start, &__end);\n __symbols.push((__start, __Symbol::Variant56(__nt), __end));\n (0, 79)\n }\n pub(crate) fn __reduce165<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Comma = ( \",\")+, Constant => ActionFn(294);\n let __sym1 = __pop_Variant24(__symbols);\n let __sym0 = __pop_Variant25(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym1.2.clone();\n let __nt = super::__action294::<>(text, __sym0, __sym1);\n __symbols.push((__start, __Symbol::Variant56(__nt), __end));\n (2, 79)\n }\n pub(crate) fn __reduce166<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Comma = ( \",\")+ => ActionFn(295);\n let __sym0 = __pop_Variant25(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym0.2.clone();\n let __nt = super::__action295::<>(text, __sym0);\n __symbols.push((__start, __Symbol::Variant56(__nt), __end));\n (1, 79)\n }\n pub(crate) fn __reduce167<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Comma = Expression => ActionFn(296);\n let __sym0 = __pop_Variant6(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym0.2.clone();\n let __nt = super::__action296::<>(text, __sym0);\n __symbols.push((__start, __Symbol::Variant57(__nt), __end));\n (1, 80)\n }\n pub(crate) fn __reduce168<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Comma = => ActionFn(297);\n let __start = __symbols.last().map(|s| s.2.clone()).unwrap_or_default();\n let __end = __lookahead_start.cloned().unwrap_or_else(|| __start.clone());\n let __nt = super::__action297::<>(text, &__start, &__end);\n __symbols.push((__start, __Symbol::Variant57(__nt), __end));\n (0, 80)\n }\n pub(crate) fn __reduce169<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Comma = ( \",\")+, Expression => ActionFn(298);\n let __sym1 = __pop_Variant6(__symbols);\n let __sym0 = __pop_Variant26(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym1.2.clone();\n let __nt = super::__action298::<>(text, __sym0, __sym1);\n __symbols.push((__start, __Symbol::Variant57(__nt), __end));\n (2, 80)\n }\n pub(crate) fn __reduce170<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Comma = ( \",\")+ => ActionFn(299);\n let __sym0 = __pop_Variant26(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym0.2.clone();\n let __nt = super::__action299::<>(text, __sym0);\n __symbols.push((__start, __Symbol::Variant57(__nt), __end));\n (1, 80)\n }\n pub(crate) fn __reduce171<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Comma = FunctionName => ActionFn(302);\n let __sym0 = __pop_Variant28(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym0.2.clone();\n let __nt = super::__action302::<>(text, __sym0);\n __symbols.push((__start, __Symbol::Variant58(__nt), __end));\n (1, 81)\n }\n pub(crate) fn __reduce172<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Comma = => ActionFn(303);\n let __start = __symbols.last().map(|s| s.2.clone()).unwrap_or_default();\n let __end = __lookahead_start.cloned().unwrap_or_else(|| __start.clone());\n let __nt = super::__action303::<>(text, &__start, &__end);\n __symbols.push((__start, __Symbol::Variant58(__nt), __end));\n (0, 81)\n }\n pub(crate) fn __reduce173<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Comma = ( \",\")+, FunctionName => ActionFn(304);\n let __sym1 = __pop_Variant28(__symbols);\n let __sym0 = __pop_Variant29(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym1.2.clone();\n let __nt = super::__action304::<>(text, __sym0, __sym1);\n __symbols.push((__start, __Symbol::Variant58(__nt), __end));\n (2, 81)\n }\n pub(crate) fn __reduce174<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Comma = ( \",\")+ => ActionFn(305);\n let __sym0 = __pop_Variant29(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym0.2.clone();\n let __nt = super::__action305::<>(text, __sym0);\n __symbols.push((__start, __Symbol::Variant58(__nt), __end));\n (1, 81)\n }\n pub(crate) fn __reduce175<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Comma = PatternBinaryElem => ActionFn(322);\n let __sym0 = __pop_Variant32(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym0.2.clone();\n let __nt = super::__action322::<>(text, __sym0);\n __symbols.push((__start, __Symbol::Variant59(__nt), __end));\n (1, 82)\n }\n pub(crate) fn __reduce176<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Comma = => ActionFn(323);\n let __start = __symbols.last().map(|s| s.2.clone()).unwrap_or_default();\n let __end = __lookahead_start.cloned().unwrap_or_else(|| __start.clone());\n let __nt = super::__action323::<>(text, &__start, &__end);\n __symbols.push((__start, __Symbol::Variant59(__nt), __end));\n (0, 82)\n }\n pub(crate) fn __reduce177<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Comma = ( \",\")+, PatternBinaryElem => ActionFn(324);\n let __sym1 = __pop_Variant32(__symbols);\n let __sym0 = __pop_Variant33(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym1.2.clone();\n let __nt = super::__action324::<>(text, __sym0, __sym1);\n __symbols.push((__start, __Symbol::Variant59(__nt), __end));\n (2, 82)\n }\n pub(crate) fn __reduce178<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Comma = ( \",\")+ => ActionFn(325);\n let __sym0 = __pop_Variant33(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym0.2.clone();\n let __nt = super::__action325::<>(text, __sym0);\n __symbols.push((__start, __Symbol::Variant59(__nt), __end));\n (1, 82)\n }\n pub(crate) fn __reduce179<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Constant = \"{\", Comma, \"}\" => ActionFn(55);\n let __sym2 = __pop_Variant0(__symbols);\n let __sym1 = __pop_Variant56(__symbols);\n let __sym0 = __pop_Variant0(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym2.2.clone();\n let __nt = super::__action55::<>(text, __sym0, __sym1, __sym2);\n __symbols.push((__start, __Symbol::Variant24(__nt), __end));\n (3, 83)\n }\n pub(crate) fn __reduce180<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Constant = \"[\", Comma, \"|\", Constant, \"]\" => ActionFn(206);\n let __sym4 = __pop_Variant0(__symbols);\n let __sym3 = __pop_Variant24(__symbols);\n let __sym2 = __pop_Variant0(__symbols);\n let __sym1 = __pop_Variant56(__symbols);\n let __sym0 = __pop_Variant0(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym4.2.clone();\n let __nt = super::__action206::<>(text, __sym0, __sym1, __sym2, __sym3, __sym4);\n __symbols.push((__start, __Symbol::Variant24(__nt), __end));\n (5, 83)\n }\n pub(crate) fn __reduce181<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Constant = \"[\", Comma, \"]\" => ActionFn(207);\n let __sym2 = __pop_Variant0(__symbols);\n let __sym1 = __pop_Variant56(__symbols);\n let __sym0 = __pop_Variant0(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym2.2.clone();\n let __nt = super::__action207::<>(text, __sym0, __sym1, __sym2);\n __symbols.push((__start, __Symbol::Variant24(__nt), __end));\n (3, 83)\n }\n pub(crate) fn __reduce182<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Constant = AtomicTerm => ActionFn(57);\n let __sym0 = __pop_Variant46(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym0.2.clone();\n let __nt = super::__action57::<>(text, __sym0);\n __symbols.push((__start, __Symbol::Variant24(__nt), __end));\n (1, 83)\n }\n pub(crate) fn __reduce183<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Constant? = Constant => ActionFn(170);\n let __sym0 = __pop_Variant24(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym0.2.clone();\n let __nt = super::__action170::<>(text, __sym0);\n __symbols.push((__start, __Symbol::Variant60(__nt), __end));\n (1, 84)\n }\n pub(crate) fn __reduce184<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Constant? = => ActionFn(171);\n let __start = __symbols.last().map(|s| s.2.clone()).unwrap_or_default();\n let __end = __lookahead_start.cloned().unwrap_or_else(|| __start.clone());\n let __nt = super::__action171::<>(text, &__start, &__end);\n __symbols.push((__start, __Symbol::Variant60(__nt), __end));\n (0, 84)\n }\n pub(crate) fn __reduce185<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // ConstantList = \"[\", Comma, \"|\", Constant, \"]\" => ActionFn(208);\n let __sym4 = __pop_Variant0(__symbols);\n let __sym3 = __pop_Variant24(__symbols);\n let __sym2 = __pop_Variant0(__symbols);\n let __sym1 = __pop_Variant56(__symbols);\n let __sym0 = __pop_Variant0(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym4.2.clone();\n let __nt = super::__action208::<>(text, __sym0, __sym1, __sym2, __sym3, __sym4);\n __symbols.push((__start, __Symbol::Variant44(__nt), __end));\n (5, 85)\n }\n pub(crate) fn __reduce186<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // ConstantList = \"[\", Comma, \"]\" => ActionFn(209);\n let __sym2 = __pop_Variant0(__symbols);\n let __sym1 = __pop_Variant56(__symbols);\n let __sym0 = __pop_Variant0(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym2.2.clone();\n let __nt = super::__action209::<>(text, __sym0, __sym1, __sym2);\n __symbols.push((__start, __Symbol::Variant44(__nt), __end));\n (3, 85)\n }\n pub(crate) fn __reduce187<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // ConstantTuple = \"{\", Comma, \"}\" => ActionFn(62);\n let __sym2 = __pop_Variant0(__symbols);\n let __sym1 = __pop_Variant56(__symbols);\n let __sym0 = __pop_Variant0(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym2.2.clone();\n let __nt = super::__action62::<>(text, __sym0, __sym1, __sym2);\n __symbols.push((__start, __Symbol::Variant44(__nt), __end));\n (3, 86)\n }\n pub(crate) fn __reduce188<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // ExactAssoc = \":=\" => ActionFn(11);\n let __sym0 = __pop_Variant0(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym0.2.clone();\n let __nt = super::__action11::<>(text, __sym0);\n __symbols.push((__start, __Symbol::Variant61(__nt), __end));\n (1, 87)\n }\n pub(crate) fn __reduce189<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // ExactAssoc = \"=>\" => ActionFn(12);\n let __sym0 = __pop_Variant0(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym0.2.clone();\n let __nt = super::__action12::<>(text, __sym0);\n __symbols.push((__start, __Symbol::Variant61(__nt), __end));\n (1, 87)\n }\n pub(crate) fn __reduce190<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Expression = Annotated => ActionFn(13);\n let __sym0 = __pop_Variant41(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym0.2.clone();\n let __nt = super::__action13::<>(text, __sym0);\n __symbols.push((__start, __Symbol::Variant6(__nt), __end));\n (1, 88)\n }\n pub(crate) fn __reduce191<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Expression = Annotated => ActionFn(14);\n let __sym0 = __pop_Variant14(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym0.2.clone();\n let __nt = super::__action14::<>(text, __sym0);\n __symbols.push((__start, __Symbol::Variant6(__nt), __end));\n (1, 88)\n }\n pub(crate) fn __reduce192<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Expression? = Expression => ActionFn(138);\n let __sym0 = __pop_Variant6(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym0.2.clone();\n let __nt = super::__action138::<>(text, __sym0);\n __symbols.push((__start, __Symbol::Variant7(__nt), __end));\n (1, 89)\n }\n pub(crate) fn __reduce193<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Expression? = => ActionFn(139);\n let __start = __symbols.last().map(|s| s.2.clone()).unwrap_or_default();\n let __end = __lookahead_start.cloned().unwrap_or_else(|| __start.clone());\n let __nt = super::__action139::<>(text, &__start, &__end);\n __symbols.push((__start, __Symbol::Variant7(__nt), __end));\n (0, 89)\n }\n pub(crate) fn __reduce194<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Fun = \"fun\", \"(\", Comma>, \")\", \"->\", Expression => ActionFn(10);\n let __sym5 = __pop_Variant6(__symbols);\n let __sym4 = __pop_Variant0(__symbols);\n let __sym3 = __pop_Variant0(__symbols);\n let __sym2 = __pop_Variant53(__symbols);\n let __sym1 = __pop_Variant0(__symbols);\n let __sym0 = __pop_Variant0(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym5.2.clone();\n let __nt = super::__action10::<>(text, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5);\n __symbols.push((__start, __Symbol::Variant62(__nt), __end));\n (6, 90)\n }\n pub(crate) fn __reduce195<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // FunctionDefinition = Annotated, \"=\", Annotated => ActionFn(9);\n let __sym2 = __pop_Variant37(__symbols);\n let __sym1 = __pop_Variant0(__symbols);\n let __sym0 = __pop_Variant38(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym2.2.clone();\n let __nt = super::__action9::<>(text, __sym0, __sym1, __sym2);\n __symbols.push((__start, __Symbol::Variant63(__nt), __end));\n (3, 91)\n }\n pub(crate) fn __reduce196<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // FunctionDefinition* = => ActionFn(112);\n let __start = __symbols.last().map(|s| s.2.clone()).unwrap_or_default();\n let __end = __lookahead_start.cloned().unwrap_or_else(|| __start.clone());\n let __nt = super::__action112::<>(text, &__start, &__end);\n __symbols.push((__start, __Symbol::Variant64(__nt), __end));\n (0, 92)\n }\n pub(crate) fn __reduce197<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // FunctionDefinition* = FunctionDefinition+ => ActionFn(113);\n let __sym0 = __pop_Variant64(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym0.2.clone();\n let __nt = super::__action113::<>(text, __sym0);\n __symbols.push((__start, __Symbol::Variant64(__nt), __end));\n (1, 92)\n }\n pub(crate) fn __reduce198<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // FunctionDefinition+ = FunctionDefinition => ActionFn(116);\n let __sym0 = __pop_Variant63(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym0.2.clone();\n let __nt = super::__action116::<>(text, __sym0);\n __symbols.push((__start, __Symbol::Variant64(__nt), __end));\n (1, 93)\n }\n pub(crate) fn __reduce199<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // FunctionDefinition+ = FunctionDefinition+, FunctionDefinition => ActionFn(117);\n let __sym1 = __pop_Variant63(__symbols);\n let __sym0 = __pop_Variant64(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym1.2.clone();\n let __nt = super::__action117::<>(text, __sym0, __sym1);\n __symbols.push((__start, __Symbol::Variant64(__nt), __end));\n (2, 93)\n }\n pub(crate) fn __reduce200<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // FunctionName = Atom, \"/\", Integer => ActionFn(8);\n let __sym2 = __pop_Variant66(__symbols);\n let __sym1 = __pop_Variant0(__symbols);\n let __sym0 = __pop_Variant45(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym2.2.clone();\n let __nt = super::__action8::<>(text, __sym0, __sym1, __sym2);\n __symbols.push((__start, __Symbol::Variant28(__nt), __end));\n (3, 94)\n }\n pub(crate) fn __reduce201<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // FunctionName? = FunctionName => ActionFn(118);\n let __sym0 = __pop_Variant28(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym0.2.clone();\n let __nt = super::__action118::<>(text, __sym0);\n __symbols.push((__start, __Symbol::Variant65(__nt), __end));\n (1, 95)\n }\n pub(crate) fn __reduce202<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // FunctionName? = => ActionFn(119);\n let __start = __symbols.last().map(|s| s.2.clone()).unwrap_or_default();\n let __end = __lookahead_start.cloned().unwrap_or_else(|| __start.clone());\n let __nt = super::__action119::<>(text, &__start, &__end);\n __symbols.push((__start, __Symbol::Variant65(__nt), __end));\n (0, 95)\n }\n pub(crate) fn __reduce203<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Guard = \"when\", Expression => ActionFn(36);\n let __sym1 = __pop_Variant6(__symbols);\n let __sym0 = __pop_Variant0(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym1.2.clone();\n let __nt = super::__action36::<>(text, __sym0, __sym1);\n __symbols.push((__start, __Symbol::Variant6(__nt), __end));\n (2, 96)\n }\n pub(crate) fn __reduce204<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Integer = \"Integer\" => ActionFn(1);\n let __sym0 = __pop_Variant3(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym0.2.clone();\n let __nt = super::__action1::<>(text, __sym0);\n __symbols.push((__start, __Symbol::Variant66(__nt), __end));\n (1, 97)\n }\n pub(crate) fn __reduce205<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Module = \"module\", Atom, ModuleFunctions, \"attributes\", ModuleAttributes, \"end\" => ActionFn(300);\n let __sym5 = __pop_Variant0(__symbols);\n let __sym4 = __pop_Variant50(__symbols);\n let __sym3 = __pop_Variant0(__symbols);\n let __sym2 = __pop_Variant58(__symbols);\n let __sym1 = __pop_Variant45(__symbols);\n let __sym0 = __pop_Variant0(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym5.2.clone();\n let __nt = super::__action300::<>(text, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5);\n __symbols.push((__start, __Symbol::Variant67(__nt), __end));\n (6, 98)\n }\n pub(crate) fn __reduce206<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Module = \"module\", Atom, ModuleFunctions, \"attributes\", ModuleAttributes, FunctionDefinition+, \"end\" => ActionFn(301);\n let __sym6 = __pop_Variant0(__symbols);\n let __sym5 = __pop_Variant64(__symbols);\n let __sym4 = __pop_Variant50(__symbols);\n let __sym3 = __pop_Variant0(__symbols);\n let __sym2 = __pop_Variant58(__symbols);\n let __sym1 = __pop_Variant45(__symbols);\n let __sym0 = __pop_Variant0(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym6.2.clone();\n let __nt = super::__action301::<>(text, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5, __sym6);\n __symbols.push((__start, __Symbol::Variant67(__nt), __end));\n (7, 98)\n }\n pub(crate) fn __reduce207<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // ModuleAttributes = \"[\", Comma<( \"=\" )>, \"]\" => ActionFn(7);\n let __sym2 = __pop_Variant0(__symbols);\n let __sym1 = __pop_Variant50(__symbols);\n let __sym0 = __pop_Variant0(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym2.2.clone();\n let __nt = super::__action7::<>(text, __sym0, __sym1, __sym2);\n __symbols.push((__start, __Symbol::Variant50(__nt), __end));\n (3, 99)\n }\n pub(crate) fn __reduce208<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // ModuleFunctions = \"[\", Comma, \"]\" => ActionFn(6);\n let __sym2 = __pop_Variant0(__symbols);\n let __sym1 = __pop_Variant58(__symbols);\n let __sym0 = __pop_Variant0(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym2.2.clone();\n let __nt = super::__action6::<>(text, __sym0, __sym1, __sym2);\n __symbols.push((__start, __Symbol::Variant58(__nt), __end));\n (3, 100)\n }\n pub(crate) fn __reduce209<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Pattern = Annotated, \"=\", AnnotatedPattern => ActionFn(44);\n let __sym2 = __pop_Variant4(__symbols);\n let __sym1 = __pop_Variant0(__symbols);\n let __sym0 = __pop_Variant16(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym2.2.clone();\n let __nt = super::__action44::<>(text, __sym0, __sym1, __sym2);\n __symbols.push((__start, __Symbol::Variant68(__nt), __end));\n (3, 101)\n }\n pub(crate) fn __reduce210<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Pattern = Variable => ActionFn(45);\n let __sym0 = __pop_Variant45(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym0.2.clone();\n let __nt = super::__action45::<>(text, __sym0);\n __symbols.push((__start, __Symbol::Variant68(__nt), __end));\n (1, 101)\n }\n pub(crate) fn __reduce211<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Pattern = AtomicTerm => ActionFn(46);\n let __sym0 = __pop_Variant46(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym0.2.clone();\n let __nt = super::__action46::<>(text, __sym0);\n __symbols.push((__start, __Symbol::Variant68(__nt), __end));\n (1, 101)\n }\n pub(crate) fn __reduce212<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Pattern = PatternBinary => ActionFn(47);\n let __sym0 = __pop_Variant59(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym0.2.clone();\n let __nt = super::__action47::<>(text, __sym0);\n __symbols.push((__start, __Symbol::Variant68(__nt), __end));\n (1, 101)\n }\n pub(crate) fn __reduce213<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Pattern = \"{\", Comma, \"}\" => ActionFn(48);\n let __sym2 = __pop_Variant0(__symbols);\n let __sym1 = __pop_Variant54(__symbols);\n let __sym0 = __pop_Variant0(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym2.2.clone();\n let __nt = super::__action48::<>(text, __sym0, __sym1, __sym2);\n __symbols.push((__start, __Symbol::Variant68(__nt), __end));\n (3, 101)\n }\n pub(crate) fn __reduce214<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Pattern = \"~{\", Comma, \"}~\" => ActionFn(49);\n let __sym2 = __pop_Variant0(__symbols);\n let __sym1 = __pop_Variant55(__symbols);\n let __sym0 = __pop_Variant0(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym2.2.clone();\n let __nt = super::__action49::<>(text, __sym0, __sym1, __sym2);\n __symbols.push((__start, __Symbol::Variant68(__nt), __end));\n (3, 101)\n }\n pub(crate) fn __reduce215<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Pattern = \"[\", Comma, \"|\", AnnotatedPattern, \"]\" => ActionFn(198);\n let __sym4 = __pop_Variant0(__symbols);\n let __sym3 = __pop_Variant4(__symbols);\n let __sym2 = __pop_Variant0(__symbols);\n let __sym1 = __pop_Variant54(__symbols);\n let __sym0 = __pop_Variant0(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym4.2.clone();\n let __nt = super::__action198::<>(text, __sym0, __sym1, __sym2, __sym3, __sym4);\n __symbols.push((__start, __Symbol::Variant68(__nt), __end));\n (5, 101)\n }\n pub(crate) fn __reduce216<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Pattern = \"[\", Comma, \"]\" => ActionFn(199);\n let __sym2 = __pop_Variant0(__symbols);\n let __sym1 = __pop_Variant54(__symbols);\n let __sym0 = __pop_Variant0(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym2.2.clone();\n let __nt = super::__action199::<>(text, __sym0, __sym1, __sym2);\n __symbols.push((__start, __Symbol::Variant68(__nt), __end));\n (3, 101)\n }\n pub(crate) fn __reduce217<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // PatternBinary = \"#{\", Comma, \"}#\" => ActionFn(51);\n let __sym2 = __pop_Variant0(__symbols);\n let __sym1 = __pop_Variant59(__symbols);\n let __sym0 = __pop_Variant0(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym2.2.clone();\n let __nt = super::__action51::<>(text, __sym0, __sym1, __sym2);\n __symbols.push((__start, __Symbol::Variant59(__nt), __end));\n (3, 102)\n }\n pub(crate) fn __reduce218<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // PatternBinaryElem = \"#<\", AnnotatedPattern, \">(\", Comma>, \")\" => ActionFn(52);\n let __sym4 = __pop_Variant0(__symbols);\n let __sym3 = __pop_Variant52(__symbols);\n let __sym2 = __pop_Variant0(__symbols);\n let __sym1 = __pop_Variant4(__symbols);\n let __sym0 = __pop_Variant0(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym4.2.clone();\n let __nt = super::__action52::<>(text, __sym0, __sym1, __sym2, __sym3, __sym4);\n __symbols.push((__start, __Symbol::Variant32(__nt), __end));\n (5, 103)\n }\n pub(crate) fn __reduce219<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // PatternBinaryElem? = PatternBinaryElem => ActionFn(160);\n let __sym0 = __pop_Variant32(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym0.2.clone();\n let __nt = super::__action160::<>(text, __sym0);\n __symbols.push((__start, __Symbol::Variant69(__nt), __end));\n (1, 104)\n }\n pub(crate) fn __reduce220<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // PatternBinaryElem? = => ActionFn(161);\n let __start = __symbols.last().map(|s| s.2.clone()).unwrap_or_default();\n let __end = __lookahead_start.cloned().unwrap_or_else(|| __start.clone());\n let __nt = super::__action161::<>(text, &__start, &__end);\n __symbols.push((__start, __Symbol::Variant69(__nt), __end));\n (0, 104)\n }\n pub(crate) fn __reduce221<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // PatternMapEntry = Annotated, \":=\", AnnotatedPattern => ActionFn(42);\n let __sym2 = __pop_Variant4(__symbols);\n let __sym1 = __pop_Variant0(__symbols);\n let __sym0 = __pop_Variant14(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym2.2.clone();\n let __nt = super::__action42::<>(text, __sym0, __sym1, __sym2);\n __symbols.push((__start, __Symbol::Variant70(__nt), __end));\n (3, 105)\n }\n pub(crate) fn __reduce222<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Patterns = AnnotatedPattern => ActionFn(39);\n let __sym0 = __pop_Variant4(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym0.2.clone();\n let __nt = super::__action39::<>(text, __sym0);\n __symbols.push((__start, __Symbol::Variant54(__nt), __end));\n (1, 106)\n }\n pub(crate) fn __reduce223<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Patterns = \"<\", Comma, \">\" => ActionFn(40);\n let __sym2 = __pop_Variant0(__symbols);\n let __sym1 = __pop_Variant54(__symbols);\n let __sym0 = __pop_Variant0(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym2.2.clone();\n let __nt = super::__action40::<>(text, __sym0, __sym1, __sym2);\n __symbols.push((__start, __Symbol::Variant54(__nt), __end));\n (3, 106)\n }\n pub(crate) fn __reduce224<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // SingleExpression = \"[\", Comma, \"|\", Expression, \"]\" => ActionFn(201);\n let __sym4 = __pop_Variant0(__symbols);\n let __sym3 = __pop_Variant6(__symbols);\n let __sym2 = __pop_Variant0(__symbols);\n let __sym1 = __pop_Variant57(__symbols);\n let __sym0 = __pop_Variant0(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym4.2.clone();\n let __nt = super::__action201::<>(text, __sym0, __sym1, __sym2, __sym3, __sym4);\n __symbols.push((__start, __Symbol::Variant71(__nt), __end));\n (5, 107)\n }\n pub(crate) fn __reduce225<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // SingleExpression = \"[\", Comma, \"]\" => ActionFn(202);\n let __sym2 = __pop_Variant0(__symbols);\n let __sym1 = __pop_Variant57(__symbols);\n let __sym0 = __pop_Variant0(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym2.2.clone();\n let __nt = super::__action202::<>(text, __sym0, __sym1, __sym2);\n __symbols.push((__start, __Symbol::Variant71(__nt), __end));\n (3, 107)\n }\n pub(crate) fn __reduce226<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // SingleExpression = FunctionName => ActionFn(17);\n let __sym0 = __pop_Variant28(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym0.2.clone();\n let __nt = super::__action17::<>(text, __sym0);\n __symbols.push((__start, __Symbol::Variant71(__nt), __end));\n (1, 107)\n }\n pub(crate) fn __reduce227<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // SingleExpression = \"fun\", Atom, \":\", FunctionName => ActionFn(18);\n let __sym3 = __pop_Variant28(__symbols);\n let __sym2 = __pop_Variant0(__symbols);\n let __sym1 = __pop_Variant45(__symbols);\n let __sym0 = __pop_Variant0(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym3.2.clone();\n let __nt = super::__action18::<>(text, __sym0, __sym1, __sym2, __sym3);\n __symbols.push((__start, __Symbol::Variant71(__nt), __end));\n (4, 107)\n }\n pub(crate) fn __reduce228<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // SingleExpression = AtomicTerm => ActionFn(19);\n let __sym0 = __pop_Variant46(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym0.2.clone();\n let __nt = super::__action19::<>(text, __sym0);\n __symbols.push((__start, __Symbol::Variant71(__nt), __end));\n (1, 107)\n }\n pub(crate) fn __reduce229<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // SingleExpression = Variable => ActionFn(20);\n let __sym0 = __pop_Variant45(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym0.2.clone();\n let __nt = super::__action20::<>(text, __sym0);\n __symbols.push((__start, __Symbol::Variant71(__nt), __end));\n (1, 107)\n }\n pub(crate) fn __reduce230<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // SingleExpression = Binary => ActionFn(21);\n let __sym0 = __pop_Variant47(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym0.2.clone();\n let __nt = super::__action21::<>(text, __sym0);\n __symbols.push((__start, __Symbol::Variant71(__nt), __end));\n (1, 107)\n }\n pub(crate) fn __reduce231<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // SingleExpression = \"{\", Comma, \"}\" => ActionFn(22);\n let __sym2 = __pop_Variant0(__symbols);\n let __sym1 = __pop_Variant57(__symbols);\n let __sym0 = __pop_Variant0(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym2.2.clone();\n let __nt = super::__action22::<>(text, __sym0, __sym1, __sym2);\n __symbols.push((__start, __Symbol::Variant71(__nt), __end));\n (3, 107)\n }\n pub(crate) fn __reduce232<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // SingleExpression = \"~{\", Comma )>>, \"|\", Expression, \"}~\" => ActionFn(203);\n let __sym4 = __pop_Variant0(__symbols);\n let __sym3 = __pop_Variant6(__symbols);\n let __sym2 = __pop_Variant0(__symbols);\n let __sym1 = __pop_Variant51(__symbols);\n let __sym0 = __pop_Variant0(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym4.2.clone();\n let __nt = super::__action203::<>(text, __sym0, __sym1, __sym2, __sym3, __sym4);\n __symbols.push((__start, __Symbol::Variant71(__nt), __end));\n (5, 107)\n }\n pub(crate) fn __reduce233<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // SingleExpression = \"~{\", Comma )>>, \"}~\" => ActionFn(204);\n let __sym2 = __pop_Variant0(__symbols);\n let __sym1 = __pop_Variant51(__symbols);\n let __sym0 = __pop_Variant0(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym2.2.clone();\n let __nt = super::__action204::<>(text, __sym0, __sym1, __sym2);\n __symbols.push((__start, __Symbol::Variant71(__nt), __end));\n (3, 107)\n }\n pub(crate) fn __reduce234<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // SingleExpression = \"let\", Variables, \"=\", Expression, \"in\", Expression => ActionFn(24);\n let __sym5 = __pop_Variant6(__symbols);\n let __sym4 = __pop_Variant0(__symbols);\n let __sym3 = __pop_Variant6(__symbols);\n let __sym2 = __pop_Variant0(__symbols);\n let __sym1 = __pop_Variant53(__symbols);\n let __sym0 = __pop_Variant0(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym5.2.clone();\n let __nt = super::__action24::<>(text, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5);\n __symbols.push((__start, __Symbol::Variant71(__nt), __end));\n (6, 107)\n }\n pub(crate) fn __reduce235<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // SingleExpression = \"call\", Expression, \":\", Expression, \"(\", Comma, \")\" => ActionFn(25);\n let __sym6 = __pop_Variant0(__symbols);\n let __sym5 = __pop_Variant57(__symbols);\n let __sym4 = __pop_Variant0(__symbols);\n let __sym3 = __pop_Variant6(__symbols);\n let __sym2 = __pop_Variant0(__symbols);\n let __sym1 = __pop_Variant6(__symbols);\n let __sym0 = __pop_Variant0(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym6.2.clone();\n let __nt = super::__action25::<>(text, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5, __sym6);\n __symbols.push((__start, __Symbol::Variant71(__nt), __end));\n (7, 107)\n }\n pub(crate) fn __reduce236<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // SingleExpression = \"catch\", Expression => ActionFn(26);\n let __sym1 = __pop_Variant6(__symbols);\n let __sym0 = __pop_Variant0(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym1.2.clone();\n let __nt = super::__action26::<>(text, __sym0, __sym1);\n __symbols.push((__start, __Symbol::Variant71(__nt), __end));\n (2, 107)\n }\n pub(crate) fn __reduce237<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // SingleExpression = \"case\", Expression, \"of\", \"end\" => ActionFn(268);\n let __sym3 = __pop_Variant0(__symbols);\n let __sym2 = __pop_Variant0(__symbols);\n let __sym1 = __pop_Variant6(__symbols);\n let __sym0 = __pop_Variant0(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym3.2.clone();\n let __nt = super::__action268::<>(text, __sym0, __sym1, __sym2, __sym3);\n __symbols.push((__start, __Symbol::Variant71(__nt), __end));\n (4, 107)\n }\n pub(crate) fn __reduce238<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // SingleExpression = \"case\", Expression, \"of\", Annotated+, \"end\" => ActionFn(269);\n let __sym4 = __pop_Variant0(__symbols);\n let __sym3 = __pop_Variant36(__symbols);\n let __sym2 = __pop_Variant0(__symbols);\n let __sym1 = __pop_Variant6(__symbols);\n let __sym0 = __pop_Variant0(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym4.2.clone();\n let __nt = super::__action269::<>(text, __sym0, __sym1, __sym2, __sym3, __sym4);\n __symbols.push((__start, __Symbol::Variant71(__nt), __end));\n (5, 107)\n }\n pub(crate) fn __reduce239<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // SingleExpression = \"primop\", Annotated, \"(\", Comma, \")\" => ActionFn(28);\n let __sym4 = __pop_Variant0(__symbols);\n let __sym3 = __pop_Variant57(__symbols);\n let __sym2 = __pop_Variant0(__symbols);\n let __sym1 = __pop_Variant16(__symbols);\n let __sym0 = __pop_Variant0(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym4.2.clone();\n let __nt = super::__action28::<>(text, __sym0, __sym1, __sym2, __sym3, __sym4);\n __symbols.push((__start, __Symbol::Variant71(__nt), __end));\n (5, 107)\n }\n pub(crate) fn __reduce240<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // SingleExpression = \"do\", Expression, Expression => ActionFn(29);\n let __sym2 = __pop_Variant6(__symbols);\n let __sym1 = __pop_Variant6(__symbols);\n let __sym0 = __pop_Variant0(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym2.2.clone();\n let __nt = super::__action29::<>(text, __sym0, __sym1, __sym2);\n __symbols.push((__start, __Symbol::Variant71(__nt), __end));\n (3, 107)\n }\n pub(crate) fn __reduce241<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // SingleExpression = \"apply\", Expression, \"(\", Comma, \")\" => ActionFn(30);\n let __sym4 = __pop_Variant0(__symbols);\n let __sym3 = __pop_Variant57(__symbols);\n let __sym2 = __pop_Variant0(__symbols);\n let __sym1 = __pop_Variant6(__symbols);\n let __sym0 = __pop_Variant0(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym4.2.clone();\n let __nt = super::__action30::<>(text, __sym0, __sym1, __sym2, __sym3, __sym4);\n __symbols.push((__start, __Symbol::Variant71(__nt), __end));\n (5, 107)\n }\n pub(crate) fn __reduce242<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // SingleExpression = \"try\", Expression, \"of\", Variables, \"->\", Expression, \"catch\", Variables, \"->\", Expression => ActionFn(31);\n let __sym9 = __pop_Variant6(__symbols);\n let __sym8 = __pop_Variant0(__symbols);\n let __sym7 = __pop_Variant53(__symbols);\n let __sym6 = __pop_Variant0(__symbols);\n let __sym5 = __pop_Variant6(__symbols);\n let __sym4 = __pop_Variant0(__symbols);\n let __sym3 = __pop_Variant53(__symbols);\n let __sym2 = __pop_Variant0(__symbols);\n let __sym1 = __pop_Variant6(__symbols);\n let __sym0 = __pop_Variant0(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym9.2.clone();\n let __nt = super::__action31::<>(text, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5, __sym6, __sym7, __sym8, __sym9);\n __symbols.push((__start, __Symbol::Variant71(__nt), __end));\n (10, 107)\n }\n pub(crate) fn __reduce243<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // SingleExpression = \"receive\", \"after\", Expression, \"->\", Expression => ActionFn(270);\n let __sym4 = __pop_Variant6(__symbols);\n let __sym3 = __pop_Variant0(__symbols);\n let __sym2 = __pop_Variant6(__symbols);\n let __sym1 = __pop_Variant0(__symbols);\n let __sym0 = __pop_Variant0(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym4.2.clone();\n let __nt = super::__action270::<>(text, __sym0, __sym1, __sym2, __sym3, __sym4);\n __symbols.push((__start, __Symbol::Variant71(__nt), __end));\n (5, 107)\n }\n pub(crate) fn __reduce244<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // SingleExpression = \"receive\", Annotated+, \"after\", Expression, \"->\", Expression => ActionFn(271);\n let __sym5 = __pop_Variant6(__symbols);\n let __sym4 = __pop_Variant0(__symbols);\n let __sym3 = __pop_Variant6(__symbols);\n let __sym2 = __pop_Variant0(__symbols);\n let __sym1 = __pop_Variant36(__symbols);\n let __sym0 = __pop_Variant0(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym5.2.clone();\n let __nt = super::__action271::<>(text, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5);\n __symbols.push((__start, __Symbol::Variant71(__nt), __end));\n (6, 107)\n }\n pub(crate) fn __reduce245<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // SingleExpression = Fun => ActionFn(33);\n let __sym0 = __pop_Variant62(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym0.2.clone();\n let __nt = super::__action33::<>(text, __sym0);\n __symbols.push((__start, __Symbol::Variant71(__nt), __end));\n (1, 107)\n }\n pub(crate) fn __reduce246<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // SingleExpression = \"letrec\", ( \"=\" )+, \"in\", Expression => ActionFn(34);\n let __sym3 = __pop_Variant6(__symbols);\n let __sym2 = __pop_Variant0(__symbols);\n let __sym1 = __pop_Variant31(__symbols);\n let __sym0 = __pop_Variant0(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym3.2.clone();\n let __nt = super::__action34::<>(text, __sym0, __sym1, __sym2, __sym3);\n __symbols.push((__start, __Symbol::Variant71(__nt), __end));\n (4, 107)\n }\n pub(crate) fn __reduce247<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // ValueList = \"<\", Comma>, \">\" => ActionFn(15);\n let __sym2 = __pop_Variant0(__symbols);\n let __sym1 = __pop_Variant52(__symbols);\n let __sym0 = __pop_Variant0(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym2.2.clone();\n let __nt = super::__action15::<>(text, __sym0, __sym1, __sym2);\n __symbols.push((__start, __Symbol::Variant52(__nt), __end));\n (3, 108)\n }\n pub(crate) fn __reduce248<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Variable = \"Variable\" => ActionFn(3);\n let __sym0 = __pop_Variant1(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym0.2.clone();\n let __nt = super::__action3::<>(text, __sym0);\n __symbols.push((__start, __Symbol::Variant45(__nt), __end));\n (1, 109)\n }\n pub(crate) fn __reduce249<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Variables = Annotated => ActionFn(37);\n let __sym0 = __pop_Variant16(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym0.2.clone();\n let __nt = super::__action37::<>(text, __sym0);\n __symbols.push((__start, __Symbol::Variant53(__nt), __end));\n (1, 110)\n }\n pub(crate) fn __reduce250<\n 'input,\n >(\n text: &'input str,\n __action: i16,\n __lookahead_start: Option<&usize>,\n __states: &mut ::std::vec::Vec,\n __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,\n _: ::std::marker::PhantomData<(&'input ())>,\n ) -> (usize, usize)\n {\n // Variables = \"<\", Comma>, \">\" => ActionFn(38);\n let __sym2 = __pop_Variant0(__symbols);\n let __sym1 = __pop_Variant53(__symbols);\n let __sym0 = __pop_Variant0(__symbols);\n let __start = __sym0.0.clone();\n let __end = __sym2.2.clone();\n let __nt = super::__action38::<>(text, __sym0, __sym1, __sym2);\n __symbols.push((__start, __Symbol::Variant53(__nt), __end));\n (3, 110)\n }\n}\npub use self::__parse__AnnotatedModule::AnnotatedModuleParser;\n\n#[allow(unused_variables)]\nfn __action0<\n 'input,\n>(\n text: &'input str,\n (_, __0, _): (usize, Annotated, usize),\n) -> Annotated\n{\n (__0)\n}\n\n#[allow(unused_variables)]\nfn __action1<\n 'input,\n>(\n text: &'input str,\n (_, i, _): (usize, (bool, &'input str), usize),\n) -> BigInt\n{\n {\n let mut num = BigInt::parse_bytes(i.1.as_bytes(), 10).unwrap();\n if !i.0 {\n num = -num;\n }\n num\n}\n}\n\n#[allow(unused_variables)]\nfn __action2<\n 'input,\n>(\n text: &'input str,\n (_, __0, _): (usize, &'input str, usize),\n) -> Atom\n{\n Atom::from_str(__0)\n}\n\n#[allow(unused_variables)]\nfn __action3<\n 'input,\n>(\n text: &'input str,\n (_, __0, _): (usize, &'input str, usize),\n) -> Atom\n{\n Atom::from_str(__0)\n}\n\n#[allow(unused_variables)]\nfn __action4<\n 'input,\n>(\n text: &'input str,\n (_, __0, _): (usize, Annotated, usize),\n) -> Annotated\n{\n __0\n}\n\n#[allow(unused_variables)]\nfn __action5<\n 'input,\n>(\n text: &'input str,\n (_, _, _): (usize, Tok<'input>, usize),\n (_, module_name, _): (usize, Atom, usize),\n (_, functions, _): (usize, Vec, usize),\n (_, _, _): (usize, Tok<'input>, usize),\n (_, attributes, _): (usize, Vec<(Atom, Constant)>, usize),\n (_, definitions, _): (usize, ::std::vec::Vec, usize),\n (_, _, _): (usize, Tok<'input>, usize),\n) -> Module\n{\n Module {\n name: module_name,\n declarations: functions,\n attributes: attributes,\n definitions: definitions,\n }\n}\n\n#[allow(unused_variables)]\nfn __action6<\n 'input,\n>(\n text: &'input str,\n (_, _, _): (usize, Tok<'input>, usize),\n (_, n, _): (usize, Vec, usize),\n (_, _, _): (usize, Tok<'input>, usize),\n) -> Vec\n{\n n\n}\n\n#[allow(unused_variables)]\nfn __action7<\n 'input,\n>(\n text: &'input str,\n (_, _, _): (usize, Tok<'input>, usize),\n (_, __0, _): (usize, Vec<(Atom, Constant)>, usize),\n (_, _, _): (usize, Tok<'input>, usize),\n) -> Vec<(Atom, Constant)>\n{\n (__0)\n}\n\n#[allow(unused_variables)]\nfn __action8<\n 'input,\n>(\n text: &'input str,\n (_, a, _): (usize, Atom, usize),\n (_, _, _): (usize, Tok<'input>, usize),\n (_, i, _): (usize, BigInt, usize),\n) -> FunctionName\n{\n FunctionName { name: a, arity: i.to_usize().unwrap() }\n}\n\n#[allow(unused_variables)]\nfn __action9<\n 'input,\n>(\n text: &'input str,\n (_, n, _): (usize, Annotated, usize),\n (_, _, _): (usize, Tok<'input>, usize),\n (_, f, _): (usize, Annotated, usize),\n) -> FunctionDefinition\n{\n FunctionDefinition { name: n, fun: f }\n}\n\n#[allow(unused_variables)]\nfn __action10<\n 'input,\n>(\n text: &'input str,\n (_, _, _): (usize, Tok<'input>, usize),\n (_, _, _): (usize, Tok<'input>, usize),\n (_, a, _): (usize, Vec>, usize),\n (_, _, _): (usize, Tok<'input>, usize),\n (_, _, _): (usize, Tok<'input>, usize),\n (_, e, _): (usize, Expression, usize),\n) -> Function\n{\n Function { vars: a, body: e }\n}\n\n#[allow(unused_variables)]\nfn __action11<\n 'input,\n>(\n text: &'input str,\n (_, __0, _): (usize, Tok<'input>, usize),\n) -> MapExactAssoc\n{\n MapExactAssoc::Exact\n}\n\n#[allow(unused_variables)]\nfn __action12<\n 'input,\n>(\n text: &'input str,\n (_, __0, _): (usize, Tok<'input>, usize),\n) -> MapExactAssoc\n{\n MapExactAssoc::Assoc\n}\n\n#[allow(unused_variables)]\nfn __action13<\n 'input,\n>(\n text: &'input str,\n (_, a, _): (usize, Annotated>>, usize),\n) -> Expression\n{\n a\n}\n\n#[allow(unused_variables)]\nfn __action14<\n 'input,\n>(\n text: &'input str,\n (_, s, _): (usize, Annotated, usize),\n) -> Expression\n{\n Annotated::empty(vec![s])\n}\n\n#[allow(unused_variables)]\nfn __action15<\n 'input,\n>(\n text: &'input str,\n (_, _, _): (usize, Tok<'input>, usize),\n (_, __0, _): (usize, Vec>, usize),\n (_, _, _): (usize, Tok<'input>, usize),\n) -> Vec>\n{\n __0\n}\n\n#[allow(unused_variables)]\nfn __action16<\n 'input,\n>(\n text: &'input str,\n (_, _, _): (usize, Tok<'input>, usize),\n (_, e, _): (usize, Vec, usize),\n (_, t, _): (usize, ::std::option::Option, usize),\n (_, _, _): (usize, Tok<'input>, usize),\n) -> SingleExpression\n{\n SingleExpression::List { head: e, tail: Box::new(t.unwrap_or(Expression::nil())) }\n}\n\n#[allow(unused_variables)]\nfn __action17<\n 'input,\n>(\n text: &'input str,\n (_, __0, _): (usize, FunctionName, usize),\n) -> SingleExpression\n{\n SingleExpression::FunctionName(__0)\n}\n\n#[allow(unused_variables)]\nfn __action18<\n 'input,\n>(\n text: &'input str,\n (_, _, _): (usize, Tok<'input>, usize),\n (_, m, _): (usize, Atom, usize),\n (_, _, _): (usize, Tok<'input>, usize),\n (_, f, _): (usize, FunctionName, usize),\n) -> SingleExpression\n{\n SingleExpression::ExternalFunctionName { module: m, name:f }\n}\n\n#[allow(unused_variables)]\nfn __action19<\n 'input,\n>(\n text: &'input str,\n (_, a, _): (usize, AtomicTerm, usize),\n) -> SingleExpression\n{\n SingleExpression::AtomicLiteral(a)\n}\n\n#[allow(unused_variables)]\nfn __action20<\n 'input,\n>(\n text: &'input str,\n (_, v, _): (usize, Atom, usize),\n) -> SingleExpression\n{\n SingleExpression::Variable(v)\n}\n\n#[allow(unused_variables)]\nfn __action21<\n 'input,\n>(\n text: &'input str,\n (_, b, _): (usize, Vec<(Expression, Vec)>, usize),\n) -> SingleExpression\n{\n SingleExpression::Binary(b)\n}\n\n#[allow(unused_variables)]\nfn __action22<\n 'input,\n>(\n text: &'input str,\n (_, _, _): (usize, Tok<'input>, usize),\n (_, t, _): (usize, Vec, usize),\n (_, _, _): (usize, Tok<'input>, usize),\n) -> SingleExpression\n{\n SingleExpression::Tuple(t)\n}\n\n#[allow(unused_variables)]\nfn __action23<\n 'input,\n>(\n text: &'input str,\n (_, _, _): (usize, Tok<'input>, usize),\n (_, v, _): (usize, Vec>, usize),\n (_, m, _): (usize, ::std::option::Option, usize),\n (_, _, _): (usize, Tok<'input>, usize),\n) -> SingleExpression\n{\n SingleExpression::Map(v, m)\n}\n\n#[allow(unused_variables)]\nfn __action24<\n 'input,\n>(\n text: &'input str,\n (_, _, _): (usize, Tok<'input>, usize),\n (_, v, _): (usize, Vec>, usize),\n (_, _, _): (usize, Tok<'input>, usize),\n (_, e, _): (usize, Expression, usize),\n (_, _, _): (usize, Tok<'input>, usize),\n (_, i, _): (usize, Expression, usize),\n) -> SingleExpression\n{\n SingleExpression::Let { vars: v, val: Box::new(e), body: Box::new(i) }\n}\n\n#[allow(unused_variables)]\nfn __action25<\n 'input,\n>(\n text: &'input str,\n (_, _, _): (usize, Tok<'input>, usize),\n (_, a, _): (usize, Expression, usize),\n (_, _, _): (usize, Tok<'input>, usize),\n (_, b, _): (usize, Expression, usize),\n (_, _, _): (usize, Tok<'input>, usize),\n (_, c, _): (usize, Vec, usize),\n (_, _, _): (usize, Tok<'input>, usize),\n) -> SingleExpression\n{\n SingleExpression::InterModuleCall {\n module: Box::new(a), name: Box::new(b), args: c }\n}\n\n#[allow(unused_variables)]\nfn __action26<\n 'input,\n>(\n text: &'input str,\n (_, _, _): (usize, Tok<'input>, usize),\n (_, e, _): (usize, Expression, usize),\n) -> SingleExpression\n{\n SingleExpression::Catch(Box::new(e))\n}\n\n#[allow(unused_variables)]\nfn __action27<\n 'input,\n>(\n text: &'input str,\n (_, _, _): (usize, Tok<'input>, usize),\n (_, e, _): (usize, Expression, usize),\n (_, _, _): (usize, Tok<'input>, usize),\n (_, a, _): (usize, ::std::vec::Vec>, usize),\n (_, _, _): (usize, Tok<'input>, usize),\n) -> SingleExpression\n{\n SingleExpression::Case { val: Box::new(e), clauses: a }\n}\n\n#[allow(unused_variables)]\nfn __action28<\n 'input,\n>(\n text: &'input str,\n (_, _, _): (usize, Tok<'input>, usize),\n (_, n, _): (usize, Annotated, usize),\n (_, _, _): (usize, Tok<'input>, usize),\n (_, a, _): (usize, Vec, usize),\n (_, _, _): (usize, Tok<'input>, usize),\n) -> SingleExpression\n{\n SingleExpression::PrimOpCall(PrimOpCall { name: n, args: a })\n}\n\n#[allow(unused_variables)]\nfn __action29<\n 'input,\n>(\n text: &'input str,\n (_, _, _): (usize, Tok<'input>, usize),\n (_, e1, _): (usize, Expression, usize),\n (_, e2, _): (usize, Expression, usize),\n) -> SingleExpression\n{\n SingleExpression::Do(Box::new(e1), Box::new(e2))\n}\n\n#[allow(unused_variables)]\nfn __action30<\n 'input,\n>(\n text: &'input str,\n (_, _, _): (usize, Tok<'input>, usize),\n (_, f, _): (usize, Expression, usize),\n (_, _, _): (usize, Tok<'input>, usize),\n (_, a, _): (usize, Vec, usize),\n (_, _, _): (usize, Tok<'input>, usize),\n) -> SingleExpression\n{\n SingleExpression::ApplyCall { fun: Box::new(f), args: a }\n}\n\n#[allow(unused_variables)]\nfn __action31<\n 'input,\n>(\n text: &'input str,\n (_, _, _): (usize, Tok<'input>, usize),\n (_, t, _): (usize, Expression, usize),\n (_, _, _): (usize, Tok<'input>, usize),\n (_, av, _): (usize, Vec>, usize),\n (_, _, _): (usize, Tok<'input>, usize),\n (_, a, _): (usize, Expression, usize),\n (_, _, _): (usize, Tok<'input>, usize),\n (_, cv, _): (usize, Vec>, usize),\n (_, _, _): (usize, Tok<'input>, usize),\n (_, c, _): (usize, Expression, usize),\n) -> SingleExpression\n{\n SingleExpression::Try { body: Box::new(t), then_vars: av, then: Box::new(a), \n catch_vars: cv, catch: Box::new(c) }\n}\n\n#[allow(unused_variables)]\nfn __action32<\n 'input,\n>(\n text: &'input str,\n (_, _, _): (usize, Tok<'input>, usize),\n (_, c, _): (usize, ::std::vec::Vec>, usize),\n (_, _, _): (usize, Tok<'input>, usize),\n (_, t, _): (usize, Expression, usize),\n (_, _, _): (usize, Tok<'input>, usize),\n (_, b, _): (usize, Expression, usize),\n) -> SingleExpression\n{\n SingleExpression::Receive { clauses: c, timeout_time: Box::new(t),\n timeout_body: Box::new(b) }\n}\n\n#[allow(unused_variables)]\nfn __action33<\n 'input,\n>(\n text: &'input str,\n (_, f, _): (usize, Function, usize),\n) -> SingleExpression\n{\n SingleExpression::Fun(Box::new(f))\n}\n\n#[allow(unused_variables)]\nfn __action34<\n 'input,\n>(\n text: &'input str,\n (_, _, _): (usize, Tok<'input>, usize),\n (_, f, _): (usize, ::std::vec::Vec<(FunctionName, Function)>, usize),\n (_, _, _): (usize, Tok<'input>, usize),\n (_, e, _): (usize, Expression, usize),\n) -> SingleExpression\n{\n SingleExpression::LetRec { funs: f, body: Box::new(e) }\n}\n\n#[allow(unused_variables)]\nfn __action35<\n 'input,\n>(\n text: &'input str,\n (_, p, _): (usize, Vec>, usize),\n (_, g, _): (usize, Expression, usize),\n (_, _, _): (usize, Tok<'input>, usize),\n (_, b, _): (usize, Expression, usize),\n) -> CaseClause\n{\n CaseClause { patterns: p, guard: g, body: b }\n}\n\n#[allow(unused_variables)]\nfn __action36<\n 'input,\n>(\n text: &'input str,\n (_, _, _): (usize, Tok<'input>, usize),\n (_, __0, _): (usize, Expression, usize),\n) -> Expression\n{\n __0\n}\n\n#[allow(unused_variables)]\nfn __action37<\n 'input,\n>(\n text: &'input str,\n (_, a, _): (usize, Annotated, usize),\n) -> Vec>\n{\n vec![a]\n}\n\n#[allow(unused_variables)]\nfn __action38<\n 'input,\n>(\n text: &'input str,\n (_, _, _): (usize, Tok<'input>, usize),\n (_, a, _): (usize, Vec>, usize),\n (_, _, _): (usize, Tok<'input>, usize),\n) -> Vec>\n{\n a\n}\n\n#[allow(unused_variables)]\nfn __action39<\n 'input,\n>(\n text: &'input str,\n (_, p, _): (usize, Annotated, usize),\n) -> Vec>\n{\n vec![p]\n}\n\n#[allow(unused_variables)]\nfn __action40<\n 'input,\n>(\n text: &'input str,\n (_, _, _): (usize, Tok<'input>, usize),\n (_, p, _): (usize, Vec>, usize),\n (_, _, _): (usize, Tok<'input>, usize),\n) -> Vec>\n{\n p\n}\n\n#[allow(unused_variables)]\nfn __action41<\n 'input,\n>(\n text: &'input str,\n (_, p, _): (usize, Annotated, usize),\n) -> Annotated\n{\n p\n}\n\n#[allow(unused_variables)]\nfn __action42<\n 'input,\n>(\n text: &'input str,\n (_, k, _): (usize, Annotated, usize),\n (_, _, _): (usize, Tok<'input>, usize),\n (_, v, _): (usize, Annotated, usize),\n) -> (Annotated, Annotated)\n{\n (k, v)\n}\n\n#[allow(unused_variables)]\nfn __action43<\n 'input,\n>(\n text: &'input str,\n (_, __0, _): (usize, Annotated<(Annotated, Annotated)>, usize),\n) -> Annotated<(Annotated, Annotated)>\n{\n __0\n}\n\n#[allow(unused_variables)]\nfn __action44<\n 'input,\n>(\n text: &'input str,\n (_, v, _): (usize, Annotated, usize),\n (_, _, _): (usize, Tok<'input>, usize),\n (_, p, _): (usize, Annotated, usize),\n) -> Pattern\n{\n Pattern::BindVar(v, Box::new(p))\n}\n\n#[allow(unused_variables)]\nfn __action45<\n 'input,\n>(\n text: &'input str,\n (_, v, _): (usize, Atom, usize),\n) -> Pattern\n{\n Pattern::BindVar(Annotated::empty(v), Box::new(Annotated::empty(Pattern::Wildcard)))\n}\n\n#[allow(unused_variables)]\nfn __action46<\n 'input,\n>(\n text: &'input str,\n (_, a, _): (usize, AtomicTerm, usize),\n) -> Pattern\n{\n Pattern::Atomic(a)\n}\n\n#[allow(unused_variables)]\nfn __action47<\n 'input,\n>(\n text: &'input str,\n (_, b, _): (usize, Vec<(Annotated, Vec>)>, usize),\n) -> Pattern\n{\n Pattern::Binary(b)\n}\n\n#[allow(unused_variables)]\nfn __action48<\n 'input,\n>(\n text: &'input str,\n (_, _, _): (usize, Tok<'input>, usize),\n (_, t, _): (usize, Vec>, usize),\n (_, _, _): (usize, Tok<'input>, usize),\n) -> Pattern\n{\n Pattern::Tuple(t)\n}\n\n#[allow(unused_variables)]\nfn __action49<\n 'input,\n>(\n text: &'input str,\n (_, _, _): (usize, Tok<'input>, usize),\n (_, m, _): (usize, Vec, Annotated)>>, usize),\n (_, _, _): (usize, Tok<'input>, usize),\n) -> Pattern\n{\n Pattern::Map(m)\n}\n\n#[allow(unused_variables)]\nfn __action50<\n 'input,\n>(\n text: &'input str,\n (_, _, _): (usize, Tok<'input>, usize),\n (_, l, _): (usize, Vec>, usize),\n (_, t, _): (usize, ::std::option::Option>, usize),\n (_, _, _): (usize, Tok<'input>, usize),\n) -> Pattern\n{\n Pattern::List(l, Box::new(t.unwrap_or(Pattern::nil())))\n}\n\n#[allow(unused_variables)]\nfn __action51<\n 'input,\n>(\n text: &'input str,\n (_, _, _): (usize, Tok<'input>, usize),\n (_, b, _): (usize, Vec<(Annotated, Vec>)>, usize),\n (_, _, _): (usize, Tok<'input>, usize),\n) -> Vec<(Annotated, Vec>)>\n{\n b\n}\n\n#[allow(unused_variables)]\nfn __action52<\n 'input,\n>(\n text: &'input str,\n (_, _, _): (usize, Tok<'input>, usize),\n (_, p, _): (usize, Annotated, usize),\n (_, _, _): (usize, Tok<'input>, usize),\n (_, a, _): (usize, Vec>, usize),\n (_, _, _): (usize, Tok<'input>, usize),\n) -> (Annotated, Vec>)\n{\n (p, a)\n}\n\n#[allow(unused_variables)]\nfn __action53<\n 'input,\n>(\n text: &'input str,\n (_, _, _): (usize, Tok<'input>, usize),\n (_, b, _): (usize, Vec<(Expression, Vec)>, usize),\n (_, _, _): (usize, Tok<'input>, usize),\n) -> Vec<(Expression, Vec)>\n{\n b\n}\n\n#[allow(unused_variables)]\nfn __action54<\n 'input,\n>(\n text: &'input str,\n (_, _, _): (usize, Tok<'input>, usize),\n (_, b, _): (usize, Expression, usize),\n (_, _, _): (usize, Tok<'input>, usize),\n (_, a, _): (usize, Vec, usize),\n (_, _, _): (usize, Tok<'input>, usize),\n) -> (Expression, Vec)\n{\n (b, a)\n}\n\n#[allow(unused_variables)]\nfn __action55<\n 'input,\n>(\n text: &'input str,\n (_, __0, _): (usize, Tok<'input>, usize),\n (_, __1, _): (usize, Vec, usize),\n (_, __2, _): (usize, Tok<'input>, usize),\n) -> Constant\n{\n Constant::Tuple(vec![])\n}\n\n#[allow(unused_variables)]\nfn __action56<\n 'input,\n>(\n text: &'input str,\n (_, __0, _): (usize, Tok<'input>, usize),\n (_, __1, _): (usize, Vec, usize),\n (_, __2, _): (usize, ::std::option::Option<(Tok<'input>, Constant)>, usize),\n (_, __3, _): (usize, Tok<'input>, usize),\n) -> Constant\n{\n Constant::List(vec![], Box::new(Constant::Atomic(AtomicTerm::Nil)))\n}\n\n#[allow(unused_variables)]\nfn __action57<\n 'input,\n>(\n text: &'input str,\n (_, __0, _): (usize, AtomicTerm, usize),\n) -> Constant\n{\n Constant::Atomic(__0)\n}\n\n#[allow(unused_variables)]\nfn __action58<\n 'input,\n>(\n text: &'input str,\n (_, i, _): (usize, BigInt, usize),\n) -> AtomicTerm\n{\n AtomicTerm::Integer(i)\n}\n\n#[allow(unused_variables)]\nfn __action59<\n 'input,\n>(\n text: &'input str,\n (_, a, _): (usize, Atom, usize),\n) -> AtomicTerm\n{\n AtomicTerm::Atom(a)\n}\n\n#[allow(unused_variables)]\nfn __action60<\n 'input,\n>(\n text: &'input str,\n (_, c, _): (usize, char, usize),\n) -> AtomicTerm\n{\n AtomicTerm::Char(c)\n}\n\n#[allow(unused_variables)]\nfn __action61<\n 'input,\n>(\n text: &'input str,\n (_, s, _): (usize, &'input str, usize),\n) -> AtomicTerm\n{\n AtomicTerm::String(s.to_string())\n}\n\n#[allow(unused_variables)]\nfn __action62<\n 'input,\n>(\n text: &'input str,\n (_, __0, _): (usize, Tok<'input>, usize),\n (_, __1, _): (usize, Vec, usize),\n (_, __2, _): (usize, Tok<'input>, usize),\n) -> ()\n{\n ()\n}\n\n#[allow(unused_variables)]\nfn __action63<\n 'input,\n>(\n text: &'input str,\n (_, __0, _): (usize, Tok<'input>, usize),\n (_, __1, _): (usize, Vec, usize),\n (_, __2, _): (usize, ::std::option::Option<(Tok<'input>, Constant)>, usize),\n (_, __3, _): (usize, Tok<'input>, usize),\n) -> ()\n{\n ()\n}\n\n#[allow(unused_variables)]\nfn __action64<\n 'input,\n>(\n text: &'input str,\n (_, _, _): (usize, Tok<'input>, usize),\n (_, _, _): (usize, Tok<'input>, usize),\n (_, c, _): (usize, Vec, usize),\n (_, _, _): (usize, Tok<'input>, usize),\n) -> ()\n{\n ()\n}\n\n#[allow(unused_variables)]\nfn __action65<\n 'input,\n>(\n text: &'input str,\n (_, __0, _): (usize, (Tok<'input>, Constant), usize),\n) -> ::std::option::Option<(Tok<'input>, Constant)>\n{\n Some(__0)\n}\n\n#[allow(unused_variables)]\nfn __action66<\n 'input,\n>(\n text: &'input str,\n __lookbehind: &usize,\n __lookahead: &usize,\n) -> ::std::option::Option<(Tok<'input>, Constant)>\n{\n None\n}\n\n#[allow(unused_variables)]\nfn __action67<\n 'input,\n>(\n text: &'input str,\n (_, __0, _): (usize, Tok<'input>, usize),\n (_, __1, _): (usize, Constant, usize),\n) -> (Tok<'input>, Constant)\n{\n (__0, __1)\n}\n\n#[allow(unused_variables)]\nfn __action68<\n 'input,\n>(\n text: &'input str,\n (_, rules, _): (usize, ::std::vec::Vec, usize),\n (_, last, _): (usize, ::std::option::Option, usize),\n) -> Vec\n{\n {\n let mut rules = rules;\n rules.extend(last);\n rules\n }\n}\n\n#[allow(unused_variables)]\nfn __action69<\n 'input,\n>(\n text: &'input str,\n (_, rules, _): (usize, ::std::vec::Vec<(Expression, Vec)>, usize),\n (_, last, _): (usize, ::std::option::Option<(Expression, Vec)>, usize),\n) -> Vec<(Expression, Vec)>\n{\n {\n let mut rules = rules;\n rules.extend(last);\n rules\n }\n}\n\n#[allow(unused_variables)]\nfn __action70<\n 'input,\n>(\n text: &'input str,\n (_, rules, _): (usize, ::std::vec::Vec<(Annotated, Vec>)>, usize),\n (_, last, _): (usize, ::std::option::Option<(Annotated, Vec>)>, usize),\n) -> Vec<(Annotated, Vec>)>\n{\n {\n let mut rules = rules;\n rules.extend(last);\n rules\n }\n}\n\n#[allow(unused_variables)]\nfn __action71<\n 'input,\n>(\n text: &'input str,\n (_, __0, _): (usize, Annotated, usize),\n) -> ::std::option::Option>\n{\n Some(__0)\n}\n\n#[allow(unused_variables)]\nfn __action72<\n 'input,\n>(\n text: &'input str,\n __lookbehind: &usize,\n __lookahead: &usize,\n) -> ::std::option::Option>\n{\n None\n}\n\n#[allow(unused_variables)]\nfn __action73<\n 'input,\n>(\n text: &'input str,\n (_, _, _): (usize, Tok<'input>, usize),\n (_, __0, _): (usize, Annotated, usize),\n) -> Annotated\n{\n (__0)\n}\n\n#[allow(unused_variables)]\nfn __action74<\n 'input,\n>(\n text: &'input str,\n (_, rules, _): (usize, ::std::vec::Vec, Annotated)>>, usize),\n (_, last, _): (usize, ::std::option::Option, Annotated)>>, usize),\n) -> Vec, Annotated)>>\n{\n {\n let mut rules = rules;\n rules.extend(last);\n rules\n }\n}\n\n#[allow(unused_variables)]\nfn __action75<\n 'input,\n>(\n text: &'input str,\n (_, i, _): (usize, (Annotated, Annotated), usize),\n) -> Annotated<(Annotated, Annotated)>\n{\n Annotated(i, vec![])\n}\n\n#[allow(unused_variables)]\nfn __action76<\n 'input,\n>(\n text: &'input str,\n (_, _, _): (usize, Tok<'input>, usize),\n (_, i, _): (usize, (Annotated, Annotated), usize),\n (_, _, _): (usize, (), usize),\n (_, _, _): (usize, Tok<'input>, usize),\n) -> Annotated<(Annotated, Annotated)>\n{\n Annotated(i, vec![])\n}\n\n#[allow(unused_variables)]\nfn __action77<\n 'input,\n>(\n text: &'input str,\n (_, i, _): (usize, Pattern, usize),\n) -> Annotated\n{\n Annotated(i, vec![])\n}\n\n#[allow(unused_variables)]\nfn __action78<\n 'input,\n>(\n text: &'input str,\n (_, _, _): (usize, Tok<'input>, usize),\n (_, i, _): (usize, Pattern, usize),\n (_, _, _): (usize, (), usize),\n (_, _, _): (usize, Tok<'input>, usize),\n) -> Annotated\n{\n Annotated(i, vec![])\n}\n\n#[allow(unused_variables)]\nfn __action79<\n 'input,\n>(\n text: &'input str,\n (_, rules, _): (usize, ::std::vec::Vec>, usize),\n (_, last, _): (usize, ::std::option::Option>, usize),\n) -> Vec>\n{\n {\n let mut rules = rules;\n rules.extend(last);\n rules\n }\n}\n\n#[allow(unused_variables)]\nfn __action80<\n 'input,\n>(\n text: &'input str,\n (_, __0, _): (usize, (FunctionName, Function), usize),\n) -> ::std::vec::Vec<(FunctionName, Function)>\n{\n vec![__0]\n}\n\n#[allow(unused_variables)]\nfn __action81<\n 'input,\n>(\n text: &'input str,\n (_, v, _): (usize, ::std::vec::Vec<(FunctionName, Function)>, usize),\n (_, e, _): (usize, (FunctionName, Function), usize),\n) -> ::std::vec::Vec<(FunctionName, Function)>\n{\n { let mut v = v; v.push(e); v }\n}\n\n#[allow(unused_variables)]\nfn __action82<\n 'input,\n>(\n text: &'input str,\n (_, __0, _): (usize, FunctionName, usize),\n (_, _, _): (usize, Tok<'input>, usize),\n (_, __1, _): (usize, Function, usize),\n) -> (FunctionName, Function)\n{\n (__0, __1)\n}\n\n#[allow(unused_variables)]\nfn __action83<\n 'input,\n>(\n text: &'input str,\n (_, i, _): (usize, Atom, usize),\n) -> Annotated\n{\n Annotated(i, vec![])\n}\n\n#[allow(unused_variables)]\nfn __action84<\n 'input,\n>(\n text: &'input str,\n (_, _, _): (usize, Tok<'input>, usize),\n (_, i, _): (usize, Atom, usize),\n (_, _, _): (usize, (), usize),\n (_, _, _): (usize, Tok<'input>, usize),\n) -> Annotated\n{\n Annotated(i, vec![])\n}\n\n#[allow(unused_variables)]\nfn __action85<\n 'input,\n>(\n text: &'input str,\n __lookbehind: &usize,\n __lookahead: &usize,\n) -> ::std::vec::Vec>\n{\n vec![]\n}\n\n#[allow(unused_variables)]\nfn __action86<\n 'input,\n>(\n text: &'input str,\n (_, v, _): (usize, ::std::vec::Vec>, usize),\n) -> ::std::vec::Vec>\n{\n v\n}\n\n#[allow(unused_variables)]\nfn __action87<\n 'input,\n>(\n text: &'input str,\n (_, i, _): (usize, CaseClause, usize),\n) -> Annotated\n{\n Annotated(i, vec![])\n}\n\n#[allow(unused_variables)]\nfn __action88<\n 'input,\n>(\n text: &'input str,\n (_, _, _): (usize, Tok<'input>, usize),\n (_, i, _): (usize, CaseClause, usize),\n (_, _, _): (usize, (), usize),\n (_, _, _): (usize, Tok<'input>, usize),\n) -> Annotated\n{\n Annotated(i, vec![])\n}\n\n#[allow(unused_variables)]\nfn __action89<\n 'input,\n>(\n text: &'input str,\n (_, rules, _): (usize, ::std::vec::Vec>, usize),\n (_, last, _): (usize, ::std::option::Option>, usize),\n) -> Vec>\n{\n {\n let mut rules = rules;\n rules.extend(last);\n rules\n }\n}\n\n#[allow(unused_variables)]\nfn __action90<\n 'input,\n>(\n text: &'input str,\n (_, i, _): (usize, (Expression, MapExactAssoc, Expression), usize),\n) -> Annotated<(Expression, MapExactAssoc, Expression)>\n{\n Annotated(i, vec![])\n}\n\n#[allow(unused_variables)]\nfn __action91<\n 'input,\n>(\n text: &'input str,\n (_, _, _): (usize, Tok<'input>, usize),\n (_, i, _): (usize, (Expression, MapExactAssoc, Expression), usize),\n (_, _, _): (usize, (), usize),\n (_, _, _): (usize, Tok<'input>, usize),\n) -> Annotated<(Expression, MapExactAssoc, Expression)>\n{\n Annotated(i, vec![])\n}\n\n#[allow(unused_variables)]\nfn __action92<\n 'input,\n>(\n text: &'input str,\n (_, __0, _): (usize, Expression, usize),\n (_, __1, _): (usize, MapExactAssoc, usize),\n (_, __2, _): (usize, Expression, usize),\n) -> (Expression, MapExactAssoc, Expression)\n{\n (__0, __1, __2)\n}\n\n#[allow(unused_variables)]\nfn __action93<\n 'input,\n>(\n text: &'input str,\n (_, __0, _): (usize, Expression, usize),\n) -> ::std::option::Option\n{\n Some(__0)\n}\n\n#[allow(unused_variables)]\nfn __action94<\n 'input,\n>(\n text: &'input str,\n __lookbehind: &usize,\n __lookahead: &usize,\n) -> ::std::option::Option\n{\n None\n}\n\n#[allow(unused_variables)]\nfn __action95<\n 'input,\n>(\n text: &'input str,\n (_, _, _): (usize, Tok<'input>, usize),\n (_, __0, _): (usize, Expression, usize),\n) -> Expression\n{\n (__0)\n}\n\n#[allow(unused_variables)]\nfn __action96<\n 'input,\n>(\n text: &'input str,\n (_, rules, _): (usize, ::std::vec::Vec, usize),\n (_, last, _): (usize, ::std::option::Option, usize),\n) -> Vec\n{\n {\n let mut rules = rules;\n rules.extend(last);\n rules\n }\n}\n\n#[allow(unused_variables)]\nfn __action97<\n 'input,\n>(\n text: &'input str,\n (_, rules, _): (usize, ::std::vec::Vec>, usize),\n (_, last, _): (usize, ::std::option::Option>, usize),\n) -> Vec>\n{\n {\n let mut rules = rules;\n rules.extend(last);\n rules\n }\n}\n\n#[allow(unused_variables)]\nfn __action98<\n 'input,\n>(\n text: &'input str,\n (_, i, _): (usize, SingleExpression, usize),\n) -> Annotated\n{\n Annotated(i, vec![])\n}\n\n#[allow(unused_variables)]\nfn __action99<\n 'input,\n>(\n text: &'input str,\n (_, _, _): (usize, Tok<'input>, usize),\n (_, i, _): (usize, SingleExpression, usize),\n (_, _, _): (usize, (), usize),\n (_, _, _): (usize, Tok<'input>, usize),\n) -> Annotated\n{\n Annotated(i, vec![])\n}\n\n#[allow(unused_variables)]\nfn __action100<\n 'input,\n>(\n text: &'input str,\n (_, i, _): (usize, Vec>, usize),\n) -> Annotated>>\n{\n Annotated(i, vec![])\n}\n\n#[allow(unused_variables)]\nfn __action101<\n 'input,\n>(\n text: &'input str,\n (_, _, _): (usize, Tok<'input>, usize),\n (_, i, _): (usize, Vec>, usize),\n (_, _, _): (usize, (), usize),\n (_, _, _): (usize, Tok<'input>, usize),\n) -> Annotated>>\n{\n Annotated(i, vec![])\n}\n\n#[allow(unused_variables)]\nfn __action102<\n 'input,\n>(\n text: &'input str,\n (_, rules, _): (usize, ::std::vec::Vec>, usize),\n (_, last, _): (usize, ::std::option::Option>, usize),\n) -> Vec>\n{\n {\n let mut rules = rules;\n rules.extend(last);\n rules\n }\n}\n\n#[allow(unused_variables)]\nfn __action103<\n 'input,\n>(\n text: &'input str,\n (_, i, _): (usize, Atom, usize),\n) -> Annotated\n{\n Annotated(i, vec![])\n}\n\n#[allow(unused_variables)]\nfn __action104<\n 'input,\n>(\n text: &'input str,\n (_, _, _): (usize, Tok<'input>, usize),\n (_, i, _): (usize, Atom, usize),\n (_, _, _): (usize, (), usize),\n (_, _, _): (usize, Tok<'input>, usize),\n) -> Annotated\n{\n Annotated(i, vec![])\n}\n\n#[allow(unused_variables)]\nfn __action105<\n 'input,\n>(\n text: &'input str,\n (_, i, _): (usize, Function, usize),\n) -> Annotated\n{\n Annotated(i, vec![])\n}\n\n#[allow(unused_variables)]\nfn __action106<\n 'input,\n>(\n text: &'input str,\n (_, _, _): (usize, Tok<'input>, usize),\n (_, i, _): (usize, Function, usize),\n (_, _, _): (usize, (), usize),\n (_, _, _): (usize, Tok<'input>, usize),\n) -> Annotated\n{\n Annotated(i, vec![])\n}\n\n#[allow(unused_variables)]\nfn __action107<\n 'input,\n>(\n text: &'input str,\n (_, i, _): (usize, FunctionName, usize),\n) -> Annotated\n{\n Annotated(i, vec![])\n}\n\n#[allow(unused_variables)]\nfn __action108<\n 'input,\n>(\n text: &'input str,\n (_, _, _): (usize, Tok<'input>, usize),\n (_, i, _): (usize, FunctionName, usize),\n (_, _, _): (usize, (), usize),\n (_, _, _): (usize, Tok<'input>, usize),\n) -> Annotated\n{\n Annotated(i, vec![])\n}\n\n#[allow(unused_variables)]\nfn __action109<\n 'input,\n>(\n text: &'input str,\n (_, rules, _): (usize, ::std::vec::Vec<(Atom, Constant)>, usize),\n (_, last, _): (usize, ::std::option::Option<(Atom, Constant)>, usize),\n) -> Vec<(Atom, Constant)>\n{\n {\n let mut rules = rules;\n rules.extend(last);\n rules\n }\n}\n\n#[allow(unused_variables)]\nfn __action110<\n 'input,\n>(\n text: &'input str,\n (_, __0, _): (usize, Atom, usize),\n (_, _, _): (usize, Tok<'input>, usize),\n (_, __1, _): (usize, Constant, usize),\n) -> (Atom, Constant)\n{\n (__0, __1)\n}\n\n#[allow(unused_variables)]\nfn __action111<\n 'input,\n>(\n text: &'input str,\n (_, rules, _): (usize, ::std::vec::Vec, usize),\n (_, last, _): (usize, ::std::option::Option, usize),\n) -> Vec\n{\n {\n let mut rules = rules;\n rules.extend(last);\n rules\n }\n}\n\n#[allow(unused_variables)]\nfn __action112<\n 'input,\n>(\n text: &'input str,\n __lookbehind: &usize,\n __lookahead: &usize,\n) -> ::std::vec::Vec\n{\n vec![]\n}\n\n#[allow(unused_variables)]\nfn __action113<\n 'input,\n>(\n text: &'input str,\n (_, v, _): (usize, ::std::vec::Vec, usize),\n) -> ::std::vec::Vec\n{\n v\n}\n\n#[allow(unused_variables)]\nfn __action114<\n 'input,\n>(\n text: &'input str,\n (_, i, _): (usize, Module, usize),\n) -> Annotated\n{\n Annotated(i, vec![])\n}\n\n#[allow(unused_variables)]\nfn __action115<\n 'input,\n>(\n text: &'input str,\n (_, _, _): (usize, Tok<'input>, usize),\n (_, i, _): (usize, Module, usize),\n (_, _, _): (usize, (), usize),\n (_, _, _): (usize, Tok<'input>, usize),\n) -> Annotated\n{\n Annotated(i, vec![])\n}\n\n#[allow(unused_variables)]\nfn __action116<\n 'input,\n>(\n text: &'input str,\n (_, __0, _): (usize, FunctionDefinition, usize),\n) -> ::std::vec::Vec\n{\n vec![__0]\n}\n\n#[allow(unused_variables)]\nfn __action117<\n 'input,\n>(\n text: &'input str,\n (_, v, _): (usize, ::std::vec::Vec, usize),\n (_, e, _): (usize, FunctionDefinition, usize),\n) -> ::std::vec::Vec\n{\n { let mut v = v; v.push(e); v }\n}\n\n#[allow(unused_variables)]\nfn __action118<\n 'input,\n>(\n text: &'input str,\n (_, __0, _): (usize, FunctionName, usize),\n) -> ::std::option::Option\n{\n Some(__0)\n}\n\n#[allow(unused_variables)]\nfn __action119<\n 'input,\n>(\n text: &'input str,\n __lookbehind: &usize,\n __lookahead: &usize,\n) -> ::std::option::Option\n{\n None\n}\n\n#[allow(unused_variables)]\nfn __action120<\n 'input,\n>(\n text: &'input str,\n __lookbehind: &usize,\n __lookahead: &usize,\n) -> ::std::vec::Vec\n{\n vec![]\n}\n\n#[allow(unused_variables)]\nfn __action121<\n 'input,\n>(\n text: &'input str,\n (_, v, _): (usize, ::std::vec::Vec, usize),\n) -> ::std::vec::Vec\n{\n v\n}\n\n#[allow(unused_variables)]\nfn __action122<\n 'input,\n>(\n text: &'input str,\n (_, __0, _): (usize, FunctionName, usize),\n (_, _, _): (usize, Tok<'input>, usize),\n) -> FunctionName\n{\n (__0)\n}\n\n#[allow(unused_variables)]\nfn __action123<\n 'input,\n>(\n text: &'input str,\n (_, __0, _): (usize, (Atom, Constant), usize),\n) -> ::std::option::Option<(Atom, Constant)>\n{\n Some(__0)\n}\n\n#[allow(unused_variables)]\nfn __action124<\n 'input,\n>(\n text: &'input str,\n __lookbehind: &usize,\n __lookahead: &usize,\n) -> ::std::option::Option<(Atom, Constant)>\n{\n None\n}\n\n#[allow(unused_variables)]\nfn __action125<\n 'input,\n>(\n text: &'input str,\n __lookbehind: &usize,\n __lookahead: &usize,\n) -> ::std::vec::Vec<(Atom, Constant)>\n{\n vec![]\n}\n\n#[allow(unused_variables)]\nfn __action126<\n 'input,\n>(\n text: &'input str,\n (_, v, _): (usize, ::std::vec::Vec<(Atom, Constant)>, usize),\n) -> ::std::vec::Vec<(Atom, Constant)>\n{\n v\n}\n\n#[allow(unused_variables)]\nfn __action127<\n 'input,\n>(\n text: &'input str,\n (_, __0, _): (usize, (Atom, Constant), usize),\n (_, _, _): (usize, Tok<'input>, usize),\n) -> (Atom, Constant)\n{\n (__0)\n}\n\n#[allow(unused_variables)]\nfn __action128<\n 'input,\n>(\n text: &'input str,\n (_, __0, _): (usize, Annotated, usize),\n) -> ::std::option::Option>\n{\n Some(__0)\n}\n\n#[allow(unused_variables)]\nfn __action129<\n 'input,\n>(\n text: &'input str,\n __lookbehind: &usize,\n __lookahead: &usize,\n) -> ::std::option::Option>\n{\n None\n}\n\n#[allow(unused_variables)]\nfn __action130<\n 'input,\n>(\n text: &'input str,\n __lookbehind: &usize,\n __lookahead: &usize,\n) -> ::std::vec::Vec>\n{\n vec![]\n}\n\n#[allow(unused_variables)]\nfn __action131<\n 'input,\n>(\n text: &'input str,\n (_, v, _): (usize, ::std::vec::Vec>, usize),\n) -> ::std::vec::Vec>\n{\n v\n}\n\n#[allow(unused_variables)]\nfn __action132<\n 'input,\n>(\n text: &'input str,\n (_, __0, _): (usize, Annotated, usize),\n (_, _, _): (usize, Tok<'input>, usize),\n) -> Annotated\n{\n (__0)\n}\n\n#[allow(unused_variables)]\nfn __action133<\n 'input,\n>(\n text: &'input str,\n (_, __0, _): (usize, Annotated, usize),\n) -> ::std::option::Option>\n{\n Some(__0)\n}\n\n#[allow(unused_variables)]\nfn __action134<\n 'input,\n>(\n text: &'input str,\n __lookbehind: &usize,\n __lookahead: &usize,\n) -> ::std::option::Option>\n{\n None\n}\n\n#[allow(unused_variables)]\nfn __action135<\n 'input,\n>(\n text: &'input str,\n __lookbehind: &usize,\n __lookahead: &usize,\n) -> ::std::vec::Vec>\n{\n vec![]\n}\n\n#[allow(unused_variables)]\nfn __action136<\n 'input,\n>(\n text: &'input str,\n (_, v, _): (usize, ::std::vec::Vec>, usize),\n) -> ::std::vec::Vec>\n{\n v\n}\n\n#[allow(unused_variables)]\nfn __action137<\n 'input,\n>(\n text: &'input str,\n (_, __0, _): (usize, Annotated, usize),\n (_, _, _): (usize, Tok<'input>, usize),\n) -> Annotated\n{\n (__0)\n}\n\n#[allow(unused_variables)]\nfn __action138<\n 'input,\n>(\n text: &'input str,\n (_, __0, _): (usize, Expression, usize),\n) -> ::std::option::Option\n{\n Some(__0)\n}\n\n#[allow(unused_variables)]\nfn __action139<\n 'input,\n>(\n text: &'input str,\n __lookbehind: &usize,\n __lookahead: &usize,\n) -> ::std::option::Option\n{\n None\n}\n\n#[allow(unused_variables)]\nfn __action140<\n 'input,\n>(\n text: &'input str,\n __lookbehind: &usize,\n __lookahead: &usize,\n) -> ::std::vec::Vec\n{\n vec![]\n}\n\n#[allow(unused_variables)]\nfn __action141<\n 'input,\n>(\n text: &'input str,\n (_, v, _): (usize, ::std::vec::Vec, usize),\n) -> ::std::vec::Vec\n{\n v\n}\n\n#[allow(unused_variables)]\nfn __action142<\n 'input,\n>(\n text: &'input str,\n (_, __0, _): (usize, Expression, usize),\n (_, _, _): (usize, Tok<'input>, usize),\n) -> Expression\n{\n (__0)\n}\n\n#[allow(unused_variables)]\nfn __action143<\n 'input,\n>(\n text: &'input str,\n (_, __0, _): (usize, Annotated<(Expression, MapExactAssoc, Expression)>, usize),\n) -> ::std::option::Option>\n{\n Some(__0)\n}\n\n#[allow(unused_variables)]\nfn __action144<\n 'input,\n>(\n text: &'input str,\n __lookbehind: &usize,\n __lookahead: &usize,\n) -> ::std::option::Option>\n{\n None\n}\n\n#[allow(unused_variables)]\nfn __action145<\n 'input,\n>(\n text: &'input str,\n __lookbehind: &usize,\n __lookahead: &usize,\n) -> ::std::vec::Vec>\n{\n vec![]\n}\n\n#[allow(unused_variables)]\nfn __action146<\n 'input,\n>(\n text: &'input str,\n (_, v, _): (usize, ::std::vec::Vec>, usize),\n) -> ::std::vec::Vec>\n{\n v\n}\n\n#[allow(unused_variables)]\nfn __action147<\n 'input,\n>(\n text: &'input str,\n (_, __0, _): (usize, Annotated<(Expression, MapExactAssoc, Expression)>, usize),\n (_, _, _): (usize, Tok<'input>, usize),\n) -> Annotated<(Expression, MapExactAssoc, Expression)>\n{\n (__0)\n}\n\n#[allow(unused_variables)]\nfn __action148<\n 'input,\n>(\n text: &'input str,\n (_, __0, _): (usize, Annotated, usize),\n) -> ::std::vec::Vec>\n{\n vec![__0]\n}\n\n#[allow(unused_variables)]\nfn __action149<\n 'input,\n>(\n text: &'input str,\n (_, v, _): (usize, ::std::vec::Vec>, usize),\n (_, e, _): (usize, Annotated, usize),\n) -> ::std::vec::Vec>\n{\n { let mut v = v; v.push(e); v }\n}\n\n#[allow(unused_variables)]\nfn __action150<\n 'input,\n>(\n text: &'input str,\n (_, __0, _): (usize, Annotated, usize),\n) -> ::std::option::Option>\n{\n Some(__0)\n}\n\n#[allow(unused_variables)]\nfn __action151<\n 'input,\n>(\n text: &'input str,\n __lookbehind: &usize,\n __lookahead: &usize,\n) -> ::std::option::Option>\n{\n None\n}\n\n#[allow(unused_variables)]\nfn __action152<\n 'input,\n>(\n text: &'input str,\n __lookbehind: &usize,\n __lookahead: &usize,\n) -> ::std::vec::Vec>\n{\n vec![]\n}\n\n#[allow(unused_variables)]\nfn __action153<\n 'input,\n>(\n text: &'input str,\n (_, v, _): (usize, ::std::vec::Vec>, usize),\n) -> ::std::vec::Vec>\n{\n v\n}\n\n#[allow(unused_variables)]\nfn __action154<\n 'input,\n>(\n text: &'input str,\n (_, __0, _): (usize, Annotated, usize),\n (_, _, _): (usize, Tok<'input>, usize),\n) -> Annotated\n{\n (__0)\n}\n\n#[allow(unused_variables)]\nfn __action155<\n 'input,\n>(\n text: &'input str,\n (_, __0, _): (usize, Annotated<(Annotated, Annotated)>, usize),\n) -> ::std::option::Option, Annotated)>>\n{\n Some(__0)\n}\n\n#[allow(unused_variables)]\nfn __action156<\n 'input,\n>(\n text: &'input str,\n __lookbehind: &usize,\n __lookahead: &usize,\n) -> ::std::option::Option, Annotated)>>\n{\n None\n}\n\n#[allow(unused_variables)]\nfn __action157<\n 'input,\n>(\n text: &'input str,\n __lookbehind: &usize,\n __lookahead: &usize,\n) -> ::std::vec::Vec, Annotated)>>\n{\n vec![]\n}\n\n#[allow(unused_variables)]\nfn __action158<\n 'input,\n>(\n text: &'input str,\n (_, v, _): (usize, ::std::vec::Vec, Annotated)>>, usize),\n) -> ::std::vec::Vec, Annotated)>>\n{\n v\n}\n\n#[allow(unused_variables)]\nfn __action159<\n 'input,\n>(\n text: &'input str,\n (_, __0, _): (usize, Annotated<(Annotated, Annotated)>, usize),\n (_, _, _): (usize, Tok<'input>, usize),\n) -> Annotated<(Annotated, Annotated)>\n{\n (__0)\n}\n\n#[allow(unused_variables)]\nfn __action160<\n 'input,\n>(\n text: &'input str,\n (_, __0, _): (usize, (Annotated, Vec>), usize),\n) -> ::std::option::Option<(Annotated, Vec>)>\n{\n Some(__0)\n}\n\n#[allow(unused_variables)]\nfn __action161<\n 'input,\n>(\n text: &'input str,\n __lookbehind: &usize,\n __lookahead: &usize,\n) -> ::std::option::Option<(Annotated, Vec>)>\n{\n None\n}\n\n#[allow(unused_variables)]\nfn __action162<\n 'input,\n>(\n text: &'input str,\n __lookbehind: &usize,\n __lookahead: &usize,\n) -> ::std::vec::Vec<(Annotated, Vec>)>\n{\n vec![]\n}\n\n#[allow(unused_variables)]\nfn __action163<\n 'input,\n>(\n text: &'input str,\n (_, v, _): (usize, ::std::vec::Vec<(Annotated, Vec>)>, usize),\n) -> ::std::vec::Vec<(Annotated, Vec>)>\n{\n v\n}\n\n#[allow(unused_variables)]\nfn __action164<\n 'input,\n>(\n text: &'input str,\n (_, __0, _): (usize, (Annotated, Vec>), usize),\n (_, _, _): (usize, Tok<'input>, usize),\n) -> (Annotated, Vec>)\n{\n (__0)\n}\n\n#[allow(unused_variables)]\nfn __action165<\n 'input,\n>(\n text: &'input str,\n (_, __0, _): (usize, (Expression, Vec), usize),\n) -> ::std::option::Option<(Expression, Vec)>\n{\n Some(__0)\n}\n\n#[allow(unused_variables)]\nfn __action166<\n 'input,\n>(\n text: &'input str,\n __lookbehind: &usize,\n __lookahead: &usize,\n) -> ::std::option::Option<(Expression, Vec)>\n{\n None\n}\n\n#[allow(unused_variables)]\nfn __action167<\n 'input,\n>(\n text: &'input str,\n __lookbehind: &usize,\n __lookahead: &usize,\n) -> ::std::vec::Vec<(Expression, Vec)>\n{\n vec![]\n}\n\n#[allow(unused_variables)]\nfn __action168<\n 'input,\n>(\n text: &'input str,\n (_, v, _): (usize, ::std::vec::Vec<(Expression, Vec)>, usize),\n) -> ::std::vec::Vec<(Expression, Vec)>\n{\n v\n}\n\n#[allow(unused_variables)]\nfn __action169<\n 'input,\n>(\n text: &'input str,\n (_, __0, _): (usize, (Expression, Vec), usize),\n (_, _, _): (usize, Tok<'input>, usize),\n) -> (Expression, Vec)\n{\n (__0)\n}\n\n#[allow(unused_variables)]\nfn __action170<\n 'input,\n>(\n text: &'input str,\n (_, __0, _): (usize, Constant, usize),\n) -> ::std::option::Option\n{\n Some(__0)\n}\n\n#[allow(unused_variables)]\nfn __action171<\n 'input,\n>(\n text: &'input str,\n __lookbehind: &usize,\n __lookahead: &usize,\n) -> ::std::option::Option\n{\n None\n}\n\n#[allow(unused_variables)]\nfn __action172<\n 'input,\n>(\n text: &'input str,\n __lookbehind: &usize,\n __lookahead: &usize,\n) -> ::std::vec::Vec\n{\n vec![]\n}\n\n#[allow(unused_variables)]\nfn __action173<\n 'input,\n>(\n text: &'input str,\n (_, v, _): (usize, ::std::vec::Vec, usize),\n) -> ::std::vec::Vec\n{\n v\n}\n\n#[allow(unused_variables)]\nfn __action174<\n 'input,\n>(\n text: &'input str,\n (_, __0, _): (usize, Constant, usize),\n (_, _, _): (usize, Tok<'input>, usize),\n) -> Constant\n{\n (__0)\n}\n\n#[allow(unused_variables)]\nfn __action175<\n 'input,\n>(\n text: &'input str,\n (_, __0, _): (usize, Constant, usize),\n) -> ::std::vec::Vec\n{\n vec![__0]\n}\n\n#[allow(unused_variables)]\nfn __action176<\n 'input,\n>(\n text: &'input str,\n (_, v, _): (usize, ::std::vec::Vec, usize),\n (_, e, _): (usize, Constant, usize),\n) -> ::std::vec::Vec\n{\n { let mut v = v; v.push(e); v }\n}\n\n#[allow(unused_variables)]\nfn __action177<\n 'input,\n>(\n text: &'input str,\n (_, __0, _): (usize, (Expression, Vec), usize),\n) -> ::std::vec::Vec<(Expression, Vec)>\n{\n vec![__0]\n}\n\n#[allow(unused_variables)]\nfn __action178<\n 'input,\n>(\n text: &'input str,\n (_, v, _): (usize, ::std::vec::Vec<(Expression, Vec)>, usize),\n (_, e, _): (usize, (Expression, Vec), usize),\n) -> ::std::vec::Vec<(Expression, Vec)>\n{\n { let mut v = v; v.push(e); v }\n}\n\n#[allow(unused_variables)]\nfn __action179<\n 'input,\n>(\n text: &'input str,\n (_, __0, _): (usize, (Annotated, Vec>), usize),\n) -> ::std::vec::Vec<(Annotated, Vec>)>\n{\n vec![__0]\n}\n\n#[allow(unused_variables)]\nfn __action180<\n 'input,\n>(\n text: &'input str,\n (_, v, _): (usize, ::std::vec::Vec<(Annotated, Vec>)>, usize),\n (_, e, _): (usize, (Annotated, Vec>), usize),\n) -> ::std::vec::Vec<(Annotated, Vec>)>\n{\n { let mut v = v; v.push(e); v }\n}\n\n#[allow(unused_variables)]\nfn __action181<\n 'input,\n>(\n text: &'input str,\n (_, __0, _): (usize, Annotated<(Annotated, Annotated)>, usize),\n) -> ::std::vec::Vec, Annotated)>>\n{\n vec![__0]\n}\n\n#[allow(unused_variables)]\nfn __action182<\n 'input,\n>(\n text: &'input str,\n (_, v, _): (usize, ::std::vec::Vec, Annotated)>>, usize),\n (_, e, _): (usize, Annotated<(Annotated, Annotated)>, usize),\n) -> ::std::vec::Vec, Annotated)>>\n{\n { let mut v = v; v.push(e); v }\n}\n\n#[allow(unused_variables)]\nfn __action183<\n 'input,\n>(\n text: &'input str,\n (_, __0, _): (usize, Annotated, usize),\n) -> ::std::vec::Vec>\n{\n vec![__0]\n}\n\n#[allow(unused_variables)]\nfn __action184<\n 'input,\n>(\n text: &'input str,\n (_, v, _): (usize, ::std::vec::Vec>, usize),\n (_, e, _): (usize, Annotated, usize),\n) -> ::std::vec::Vec>\n{\n { let mut v = v; v.push(e); v }\n}\n\n#[allow(unused_variables)]\nfn __action185<\n 'input,\n>(\n text: &'input str,\n (_, __0, _): (usize, Annotated<(Expression, MapExactAssoc, Expression)>, usize),\n) -> ::std::vec::Vec>\n{\n vec![__0]\n}\n\n#[allow(unused_variables)]\nfn __action186<\n 'input,\n>(\n text: &'input str,\n (_, v, _): (usize, ::std::vec::Vec>, usize),\n (_, e, _): (usize, Annotated<(Expression, MapExactAssoc, Expression)>, usize),\n) -> ::std::vec::Vec>\n{\n { let mut v = v; v.push(e); v }\n}\n\n#[allow(unused_variables)]\nfn __action187<\n 'input,\n>(\n text: &'input str,\n (_, __0, _): (usize, Expression, usize),\n) -> ::std::vec::Vec\n{\n vec![__0]\n}\n\n#[allow(unused_variables)]\nfn __action188<\n 'input,\n>(\n text: &'input str,\n (_, v, _): (usize, ::std::vec::Vec, usize),\n (_, e, _): (usize, Expression, usize),\n) -> ::std::vec::Vec\n{\n { let mut v = v; v.push(e); v }\n}\n\n#[allow(unused_variables)]\nfn __action189<\n 'input,\n>(\n text: &'input str,\n (_, __0, _): (usize, Annotated, usize),\n) -> ::std::vec::Vec>\n{\n vec![__0]\n}\n\n#[allow(unused_variables)]\nfn __action190<\n 'input,\n>(\n text: &'input str,\n (_, v, _): (usize, ::std::vec::Vec>, usize),\n (_, e, _): (usize, Annotated, usize),\n) -> ::std::vec::Vec>\n{\n { let mut v = v; v.push(e); v }\n}\n\n#[allow(unused_variables)]\nfn __action191<\n 'input,\n>(\n text: &'input str,\n (_, __0, _): (usize, Annotated, usize),\n) -> ::std::vec::Vec>\n{\n vec![__0]\n}\n\n#[allow(unused_variables)]\nfn __action192<\n 'input,\n>(\n text: &'input str,\n (_, v, _): (usize, ::std::vec::Vec>, usize),\n (_, e, _): (usize, Annotated, usize),\n) -> ::std::vec::Vec>\n{\n { let mut v = v; v.push(e); v }\n}\n\n#[allow(unused_variables)]\nfn __action193<\n 'input,\n>(\n text: &'input str,\n (_, __0, _): (usize, (Atom, Constant), usize),\n) -> ::std::vec::Vec<(Atom, Constant)>\n{\n vec![__0]\n}\n\n#[allow(unused_variables)]\nfn __action194<\n 'input,\n>(\n text: &'input str,\n (_, v, _): (usize, ::std::vec::Vec<(Atom, Constant)>, usize),\n (_, e, _): (usize, (Atom, Constant), usize),\n) -> ::std::vec::Vec<(Atom, Constant)>\n{\n { let mut v = v; v.push(e); v }\n}\n\n#[allow(unused_variables)]\nfn __action195<\n 'input,\n>(\n text: &'input str,\n (_, __0, _): (usize, FunctionName, usize),\n) -> ::std::vec::Vec\n{\n vec![__0]\n}\n\n#[allow(unused_variables)]\nfn __action196<\n 'input,\n>(\n text: &'input str,\n (_, v, _): (usize, ::std::vec::Vec, usize),\n (_, e, _): (usize, FunctionName, usize),\n) -> ::std::vec::Vec\n{\n { let mut v = v; v.push(e); v }\n}\n\n#[allow(unused_variables)]\nfn __action197<\n 'input,\n>(\n text: &'input str,\n __0: (usize, Tok<'input>, usize),\n __1: (usize, Annotated, usize),\n) -> ::std::option::Option>\n{\n let __start0 = __0.0.clone();\n let __end0 = __1.2.clone();\n let __temp0 = __action73(\n text,\n __0,\n __1,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action71(\n text,\n __temp0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action198<\n 'input,\n>(\n text: &'input str,\n __0: (usize, Tok<'input>, usize),\n __1: (usize, Vec>, usize),\n __2: (usize, Tok<'input>, usize),\n __3: (usize, Annotated, usize),\n __4: (usize, Tok<'input>, usize),\n) -> Pattern\n{\n let __start0 = __2.0.clone();\n let __end0 = __3.2.clone();\n let __temp0 = __action197(\n text,\n __2,\n __3,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action50(\n text,\n __0,\n __1,\n __temp0,\n __4,\n )\n}\n\n#[allow(unused_variables)]\nfn __action199<\n 'input,\n>(\n text: &'input str,\n __0: (usize, Tok<'input>, usize),\n __1: (usize, Vec>, usize),\n __2: (usize, Tok<'input>, usize),\n) -> Pattern\n{\n let __start0 = __1.2.clone();\n let __end0 = __2.0.clone();\n let __temp0 = __action72(\n text,\n &__start0,\n &__end0,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action50(\n text,\n __0,\n __1,\n __temp0,\n __2,\n )\n}\n\n#[allow(unused_variables)]\nfn __action200<\n 'input,\n>(\n text: &'input str,\n __0: (usize, Tok<'input>, usize),\n __1: (usize, Expression, usize),\n) -> ::std::option::Option\n{\n let __start0 = __0.0.clone();\n let __end0 = __1.2.clone();\n let __temp0 = __action95(\n text,\n __0,\n __1,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action93(\n text,\n __temp0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action201<\n 'input,\n>(\n text: &'input str,\n __0: (usize, Tok<'input>, usize),\n __1: (usize, Vec, usize),\n __2: (usize, Tok<'input>, usize),\n __3: (usize, Expression, usize),\n __4: (usize, Tok<'input>, usize),\n) -> SingleExpression\n{\n let __start0 = __2.0.clone();\n let __end0 = __3.2.clone();\n let __temp0 = __action200(\n text,\n __2,\n __3,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action16(\n text,\n __0,\n __1,\n __temp0,\n __4,\n )\n}\n\n#[allow(unused_variables)]\nfn __action202<\n 'input,\n>(\n text: &'input str,\n __0: (usize, Tok<'input>, usize),\n __1: (usize, Vec, usize),\n __2: (usize, Tok<'input>, usize),\n) -> SingleExpression\n{\n let __start0 = __1.2.clone();\n let __end0 = __2.0.clone();\n let __temp0 = __action94(\n text,\n &__start0,\n &__end0,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action16(\n text,\n __0,\n __1,\n __temp0,\n __2,\n )\n}\n\n#[allow(unused_variables)]\nfn __action203<\n 'input,\n>(\n text: &'input str,\n __0: (usize, Tok<'input>, usize),\n __1: (usize, Vec>, usize),\n __2: (usize, Tok<'input>, usize),\n __3: (usize, Expression, usize),\n __4: (usize, Tok<'input>, usize),\n) -> SingleExpression\n{\n let __start0 = __2.0.clone();\n let __end0 = __3.2.clone();\n let __temp0 = __action200(\n text,\n __2,\n __3,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action23(\n text,\n __0,\n __1,\n __temp0,\n __4,\n )\n}\n\n#[allow(unused_variables)]\nfn __action204<\n 'input,\n>(\n text: &'input str,\n __0: (usize, Tok<'input>, usize),\n __1: (usize, Vec>, usize),\n __2: (usize, Tok<'input>, usize),\n) -> SingleExpression\n{\n let __start0 = __1.2.clone();\n let __end0 = __2.0.clone();\n let __temp0 = __action94(\n text,\n &__start0,\n &__end0,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action23(\n text,\n __0,\n __1,\n __temp0,\n __2,\n )\n}\n\n#[allow(unused_variables)]\nfn __action205<\n 'input,\n>(\n text: &'input str,\n __0: (usize, Tok<'input>, usize),\n __1: (usize, Constant, usize),\n) -> ::std::option::Option<(Tok<'input>, Constant)>\n{\n let __start0 = __0.0.clone();\n let __end0 = __1.2.clone();\n let __temp0 = __action67(\n text,\n __0,\n __1,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action65(\n text,\n __temp0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action206<\n 'input,\n>(\n text: &'input str,\n __0: (usize, Tok<'input>, usize),\n __1: (usize, Vec, usize),\n __2: (usize, Tok<'input>, usize),\n __3: (usize, Constant, usize),\n __4: (usize, Tok<'input>, usize),\n) -> Constant\n{\n let __start0 = __2.0.clone();\n let __end0 = __3.2.clone();\n let __temp0 = __action205(\n text,\n __2,\n __3,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action56(\n text,\n __0,\n __1,\n __temp0,\n __4,\n )\n}\n\n#[allow(unused_variables)]\nfn __action207<\n 'input,\n>(\n text: &'input str,\n __0: (usize, Tok<'input>, usize),\n __1: (usize, Vec, usize),\n __2: (usize, Tok<'input>, usize),\n) -> Constant\n{\n let __start0 = __1.2.clone();\n let __end0 = __2.0.clone();\n let __temp0 = __action66(\n text,\n &__start0,\n &__end0,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action56(\n text,\n __0,\n __1,\n __temp0,\n __2,\n )\n}\n\n#[allow(unused_variables)]\nfn __action208<\n 'input,\n>(\n text: &'input str,\n __0: (usize, Tok<'input>, usize),\n __1: (usize, Vec, usize),\n __2: (usize, Tok<'input>, usize),\n __3: (usize, Constant, usize),\n __4: (usize, Tok<'input>, usize),\n) -> ()\n{\n let __start0 = __2.0.clone();\n let __end0 = __3.2.clone();\n let __temp0 = __action205(\n text,\n __2,\n __3,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action63(\n text,\n __0,\n __1,\n __temp0,\n __4,\n )\n}\n\n#[allow(unused_variables)]\nfn __action209<\n 'input,\n>(\n text: &'input str,\n __0: (usize, Tok<'input>, usize),\n __1: (usize, Vec, usize),\n __2: (usize, Tok<'input>, usize),\n) -> ()\n{\n let __start0 = __1.2.clone();\n let __end0 = __2.0.clone();\n let __temp0 = __action66(\n text,\n &__start0,\n &__end0,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action63(\n text,\n __0,\n __1,\n __temp0,\n __2,\n )\n}\n\n#[allow(unused_variables)]\nfn __action210<\n 'input,\n>(\n text: &'input str,\n __0: (usize, Atom, usize),\n __1: (usize, Tok<'input>, usize),\n __2: (usize, Constant, usize),\n __3: (usize, Tok<'input>, usize),\n) -> (Atom, Constant)\n{\n let __start0 = __0.0.clone();\n let __end0 = __2.2.clone();\n let __temp0 = __action110(\n text,\n __0,\n __1,\n __2,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action127(\n text,\n __temp0,\n __3,\n )\n}\n\n#[allow(unused_variables)]\nfn __action211<\n 'input,\n>(\n text: &'input str,\n __0: (usize, Atom, usize),\n __1: (usize, Tok<'input>, usize),\n __2: (usize, Constant, usize),\n) -> ::std::option::Option<(Atom, Constant)>\n{\n let __start0 = __0.0.clone();\n let __end0 = __2.2.clone();\n let __temp0 = __action110(\n text,\n __0,\n __1,\n __2,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action123(\n text,\n __temp0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action212<\n 'input,\n>(\n text: &'input str,\n __0: (usize, Atom, usize),\n __1: (usize, Tok<'input>, usize),\n __2: (usize, Constant, usize),\n __3: (usize, Tok<'input>, usize),\n) -> ::std::vec::Vec<(Atom, Constant)>\n{\n let __start0 = __0.0.clone();\n let __end0 = __3.2.clone();\n let __temp0 = __action210(\n text,\n __0,\n __1,\n __2,\n __3,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action193(\n text,\n __temp0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action213<\n 'input,\n>(\n text: &'input str,\n __0: (usize, ::std::vec::Vec<(Atom, Constant)>, usize),\n __1: (usize, Atom, usize),\n __2: (usize, Tok<'input>, usize),\n __3: (usize, Constant, usize),\n __4: (usize, Tok<'input>, usize),\n) -> ::std::vec::Vec<(Atom, Constant)>\n{\n let __start0 = __1.0.clone();\n let __end0 = __4.2.clone();\n let __temp0 = __action210(\n text,\n __1,\n __2,\n __3,\n __4,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action194(\n text,\n __0,\n __temp0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action214<\n 'input,\n>(\n text: &'input str,\n __0: (usize, ::std::option::Option<(Atom, Constant)>, usize),\n) -> Vec<(Atom, Constant)>\n{\n let __start0 = __0.0.clone();\n let __end0 = __0.0.clone();\n let __temp0 = __action125(\n text,\n &__start0,\n &__end0,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action109(\n text,\n __temp0,\n __0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action215<\n 'input,\n>(\n text: &'input str,\n __0: (usize, ::std::vec::Vec<(Atom, Constant)>, usize),\n __1: (usize, ::std::option::Option<(Atom, Constant)>, usize),\n) -> Vec<(Atom, Constant)>\n{\n let __start0 = __0.0.clone();\n let __end0 = __0.2.clone();\n let __temp0 = __action126(\n text,\n __0,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action109(\n text,\n __temp0,\n __1,\n )\n}\n\n#[allow(unused_variables)]\nfn __action216<\n 'input,\n>(\n text: &'input str,\n __0: (usize, Annotated<(Expression, MapExactAssoc, Expression)>, usize),\n __1: (usize, Tok<'input>, usize),\n) -> ::std::vec::Vec>\n{\n let __start0 = __0.0.clone();\n let __end0 = __1.2.clone();\n let __temp0 = __action147(\n text,\n __0,\n __1,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action185(\n text,\n __temp0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action217<\n 'input,\n>(\n text: &'input str,\n __0: (usize, ::std::vec::Vec>, usize),\n __1: (usize, Annotated<(Expression, MapExactAssoc, Expression)>, usize),\n __2: (usize, Tok<'input>, usize),\n) -> ::std::vec::Vec>\n{\n let __start0 = __1.0.clone();\n let __end0 = __2.2.clone();\n let __temp0 = __action147(\n text,\n __1,\n __2,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action186(\n text,\n __0,\n __temp0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action218<\n 'input,\n>(\n text: &'input str,\n __0: (usize, ::std::option::Option>, usize),\n) -> Vec>\n{\n let __start0 = __0.0.clone();\n let __end0 = __0.0.clone();\n let __temp0 = __action145(\n text,\n &__start0,\n &__end0,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action89(\n text,\n __temp0,\n __0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action219<\n 'input,\n>(\n text: &'input str,\n __0: (usize, ::std::vec::Vec>, usize),\n __1: (usize, ::std::option::Option>, usize),\n) -> Vec>\n{\n let __start0 = __0.0.clone();\n let __end0 = __0.2.clone();\n let __temp0 = __action146(\n text,\n __0,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action89(\n text,\n __temp0,\n __1,\n )\n}\n\n#[allow(unused_variables)]\nfn __action220<\n 'input,\n>(\n text: &'input str,\n __0: (usize, Annotated, usize),\n __1: (usize, Tok<'input>, usize),\n) -> ::std::vec::Vec>\n{\n let __start0 = __0.0.clone();\n let __end0 = __1.2.clone();\n let __temp0 = __action137(\n text,\n __0,\n __1,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action189(\n text,\n __temp0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action221<\n 'input,\n>(\n text: &'input str,\n __0: (usize, ::std::vec::Vec>, usize),\n __1: (usize, Annotated, usize),\n __2: (usize, Tok<'input>, usize),\n) -> ::std::vec::Vec>\n{\n let __start0 = __1.0.clone();\n let __end0 = __2.2.clone();\n let __temp0 = __action137(\n text,\n __1,\n __2,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action190(\n text,\n __0,\n __temp0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action222<\n 'input,\n>(\n text: &'input str,\n __0: (usize, ::std::option::Option>, usize),\n) -> Vec>\n{\n let __start0 = __0.0.clone();\n let __end0 = __0.0.clone();\n let __temp0 = __action135(\n text,\n &__start0,\n &__end0,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action97(\n text,\n __temp0,\n __0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action223<\n 'input,\n>(\n text: &'input str,\n __0: (usize, ::std::vec::Vec>, usize),\n __1: (usize, ::std::option::Option>, usize),\n) -> Vec>\n{\n let __start0 = __0.0.clone();\n let __end0 = __0.2.clone();\n let __temp0 = __action136(\n text,\n __0,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action97(\n text,\n __temp0,\n __1,\n )\n}\n\n#[allow(unused_variables)]\nfn __action224<\n 'input,\n>(\n text: &'input str,\n __0: (usize, Annotated, usize),\n __1: (usize, Tok<'input>, usize),\n) -> ::std::vec::Vec>\n{\n let __start0 = __0.0.clone();\n let __end0 = __1.2.clone();\n let __temp0 = __action132(\n text,\n __0,\n __1,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action191(\n text,\n __temp0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action225<\n 'input,\n>(\n text: &'input str,\n __0: (usize, ::std::vec::Vec>, usize),\n __1: (usize, Annotated, usize),\n __2: (usize, Tok<'input>, usize),\n) -> ::std::vec::Vec>\n{\n let __start0 = __1.0.clone();\n let __end0 = __2.2.clone();\n let __temp0 = __action132(\n text,\n __1,\n __2,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action192(\n text,\n __0,\n __temp0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action226<\n 'input,\n>(\n text: &'input str,\n __0: (usize, ::std::option::Option>, usize),\n) -> Vec>\n{\n let __start0 = __0.0.clone();\n let __end0 = __0.0.clone();\n let __temp0 = __action130(\n text,\n &__start0,\n &__end0,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action102(\n text,\n __temp0,\n __0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action227<\n 'input,\n>(\n text: &'input str,\n __0: (usize, ::std::vec::Vec>, usize),\n __1: (usize, ::std::option::Option>, usize),\n) -> Vec>\n{\n let __start0 = __0.0.clone();\n let __end0 = __0.2.clone();\n let __temp0 = __action131(\n text,\n __0,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action102(\n text,\n __temp0,\n __1,\n )\n}\n\n#[allow(unused_variables)]\nfn __action228<\n 'input,\n>(\n text: &'input str,\n __0: (usize, Annotated, usize),\n __1: (usize, Tok<'input>, usize),\n) -> ::std::vec::Vec>\n{\n let __start0 = __0.0.clone();\n let __end0 = __1.2.clone();\n let __temp0 = __action154(\n text,\n __0,\n __1,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action183(\n text,\n __temp0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action229<\n 'input,\n>(\n text: &'input str,\n __0: (usize, ::std::vec::Vec>, usize),\n __1: (usize, Annotated, usize),\n __2: (usize, Tok<'input>, usize),\n) -> ::std::vec::Vec>\n{\n let __start0 = __1.0.clone();\n let __end0 = __2.2.clone();\n let __temp0 = __action154(\n text,\n __1,\n __2,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action184(\n text,\n __0,\n __temp0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action230<\n 'input,\n>(\n text: &'input str,\n __0: (usize, ::std::option::Option>, usize),\n) -> Vec>\n{\n let __start0 = __0.0.clone();\n let __end0 = __0.0.clone();\n let __temp0 = __action152(\n text,\n &__start0,\n &__end0,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action79(\n text,\n __temp0,\n __0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action231<\n 'input,\n>(\n text: &'input str,\n __0: (usize, ::std::vec::Vec>, usize),\n __1: (usize, ::std::option::Option>, usize),\n) -> Vec>\n{\n let __start0 = __0.0.clone();\n let __end0 = __0.2.clone();\n let __temp0 = __action153(\n text,\n __0,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action79(\n text,\n __temp0,\n __1,\n )\n}\n\n#[allow(unused_variables)]\nfn __action232<\n 'input,\n>(\n text: &'input str,\n __0: (usize, Annotated<(Annotated, Annotated)>, usize),\n __1: (usize, Tok<'input>, usize),\n) -> ::std::vec::Vec, Annotated)>>\n{\n let __start0 = __0.0.clone();\n let __end0 = __1.2.clone();\n let __temp0 = __action159(\n text,\n __0,\n __1,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action181(\n text,\n __temp0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action233<\n 'input,\n>(\n text: &'input str,\n __0: (usize, ::std::vec::Vec, Annotated)>>, usize),\n __1: (usize, Annotated<(Annotated, Annotated)>, usize),\n __2: (usize, Tok<'input>, usize),\n) -> ::std::vec::Vec, Annotated)>>\n{\n let __start0 = __1.0.clone();\n let __end0 = __2.2.clone();\n let __temp0 = __action159(\n text,\n __1,\n __2,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action182(\n text,\n __0,\n __temp0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action234<\n 'input,\n>(\n text: &'input str,\n __0: (usize, ::std::option::Option, Annotated)>>, usize),\n) -> Vec, Annotated)>>\n{\n let __start0 = __0.0.clone();\n let __end0 = __0.0.clone();\n let __temp0 = __action157(\n text,\n &__start0,\n &__end0,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action74(\n text,\n __temp0,\n __0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action235<\n 'input,\n>(\n text: &'input str,\n __0: (usize, ::std::vec::Vec, Annotated)>>, usize),\n __1: (usize, ::std::option::Option, Annotated)>>, usize),\n) -> Vec, Annotated)>>\n{\n let __start0 = __0.0.clone();\n let __end0 = __0.2.clone();\n let __temp0 = __action158(\n text,\n __0,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action74(\n text,\n __temp0,\n __1,\n )\n}\n\n#[allow(unused_variables)]\nfn __action236<\n 'input,\n>(\n text: &'input str,\n __0: (usize, Atom, usize),\n __1: (usize, Tok<'input>, usize),\n __2: (usize, Constant, usize),\n) -> Vec<(Atom, Constant)>\n{\n let __start0 = __0.0.clone();\n let __end0 = __2.2.clone();\n let __temp0 = __action211(\n text,\n __0,\n __1,\n __2,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action214(\n text,\n __temp0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action237<\n 'input,\n>(\n text: &'input str,\n __lookbehind: &usize,\n __lookahead: &usize,\n) -> Vec<(Atom, Constant)>\n{\n let __start0 = __lookbehind.clone();\n let __end0 = __lookahead.clone();\n let __temp0 = __action124(\n text,\n &__start0,\n &__end0,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action214(\n text,\n __temp0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action238<\n 'input,\n>(\n text: &'input str,\n __0: (usize, ::std::vec::Vec<(Atom, Constant)>, usize),\n __1: (usize, Atom, usize),\n __2: (usize, Tok<'input>, usize),\n __3: (usize, Constant, usize),\n) -> Vec<(Atom, Constant)>\n{\n let __start0 = __1.0.clone();\n let __end0 = __3.2.clone();\n let __temp0 = __action211(\n text,\n __1,\n __2,\n __3,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action215(\n text,\n __0,\n __temp0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action239<\n 'input,\n>(\n text: &'input str,\n __0: (usize, ::std::vec::Vec<(Atom, Constant)>, usize),\n) -> Vec<(Atom, Constant)>\n{\n let __start0 = __0.2.clone();\n let __end0 = __0.2.clone();\n let __temp0 = __action124(\n text,\n &__start0,\n &__end0,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action215(\n text,\n __0,\n __temp0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action240<\n 'input,\n>(\n text: &'input str,\n __0: (usize, (Expression, Vec), usize),\n __1: (usize, Tok<'input>, usize),\n) -> ::std::vec::Vec<(Expression, Vec)>\n{\n let __start0 = __0.0.clone();\n let __end0 = __1.2.clone();\n let __temp0 = __action169(\n text,\n __0,\n __1,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action177(\n text,\n __temp0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action241<\n 'input,\n>(\n text: &'input str,\n __0: (usize, ::std::vec::Vec<(Expression, Vec)>, usize),\n __1: (usize, (Expression, Vec), usize),\n __2: (usize, Tok<'input>, usize),\n) -> ::std::vec::Vec<(Expression, Vec)>\n{\n let __start0 = __1.0.clone();\n let __end0 = __2.2.clone();\n let __temp0 = __action169(\n text,\n __1,\n __2,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action178(\n text,\n __0,\n __temp0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action242<\n 'input,\n>(\n text: &'input str,\n __0: (usize, ::std::option::Option<(Expression, Vec)>, usize),\n) -> Vec<(Expression, Vec)>\n{\n let __start0 = __0.0.clone();\n let __end0 = __0.0.clone();\n let __temp0 = __action167(\n text,\n &__start0,\n &__end0,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action69(\n text,\n __temp0,\n __0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action243<\n 'input,\n>(\n text: &'input str,\n __0: (usize, ::std::vec::Vec<(Expression, Vec)>, usize),\n __1: (usize, ::std::option::Option<(Expression, Vec)>, usize),\n) -> Vec<(Expression, Vec)>\n{\n let __start0 = __0.0.clone();\n let __end0 = __0.2.clone();\n let __temp0 = __action168(\n text,\n __0,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action69(\n text,\n __temp0,\n __1,\n )\n}\n\n#[allow(unused_variables)]\nfn __action244<\n 'input,\n>(\n text: &'input str,\n __0: (usize, Constant, usize),\n __1: (usize, Tok<'input>, usize),\n) -> ::std::vec::Vec\n{\n let __start0 = __0.0.clone();\n let __end0 = __1.2.clone();\n let __temp0 = __action174(\n text,\n __0,\n __1,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action175(\n text,\n __temp0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action245<\n 'input,\n>(\n text: &'input str,\n __0: (usize, ::std::vec::Vec, usize),\n __1: (usize, Constant, usize),\n __2: (usize, Tok<'input>, usize),\n) -> ::std::vec::Vec\n{\n let __start0 = __1.0.clone();\n let __end0 = __2.2.clone();\n let __temp0 = __action174(\n text,\n __1,\n __2,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action176(\n text,\n __0,\n __temp0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action246<\n 'input,\n>(\n text: &'input str,\n __0: (usize, ::std::option::Option, usize),\n) -> Vec\n{\n let __start0 = __0.0.clone();\n let __end0 = __0.0.clone();\n let __temp0 = __action172(\n text,\n &__start0,\n &__end0,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action68(\n text,\n __temp0,\n __0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action247<\n 'input,\n>(\n text: &'input str,\n __0: (usize, ::std::vec::Vec, usize),\n __1: (usize, ::std::option::Option, usize),\n) -> Vec\n{\n let __start0 = __0.0.clone();\n let __end0 = __0.2.clone();\n let __temp0 = __action173(\n text,\n __0,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action68(\n text,\n __temp0,\n __1,\n )\n}\n\n#[allow(unused_variables)]\nfn __action248<\n 'input,\n>(\n text: &'input str,\n __0: (usize, Expression, usize),\n __1: (usize, Tok<'input>, usize),\n) -> ::std::vec::Vec\n{\n let __start0 = __0.0.clone();\n let __end0 = __1.2.clone();\n let __temp0 = __action142(\n text,\n __0,\n __1,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action187(\n text,\n __temp0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action249<\n 'input,\n>(\n text: &'input str,\n __0: (usize, ::std::vec::Vec, usize),\n __1: (usize, Expression, usize),\n __2: (usize, Tok<'input>, usize),\n) -> ::std::vec::Vec\n{\n let __start0 = __1.0.clone();\n let __end0 = __2.2.clone();\n let __temp0 = __action142(\n text,\n __1,\n __2,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action188(\n text,\n __0,\n __temp0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action250<\n 'input,\n>(\n text: &'input str,\n __0: (usize, ::std::option::Option, usize),\n) -> Vec\n{\n let __start0 = __0.0.clone();\n let __end0 = __0.0.clone();\n let __temp0 = __action140(\n text,\n &__start0,\n &__end0,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action96(\n text,\n __temp0,\n __0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action251<\n 'input,\n>(\n text: &'input str,\n __0: (usize, ::std::vec::Vec, usize),\n __1: (usize, ::std::option::Option, usize),\n) -> Vec\n{\n let __start0 = __0.0.clone();\n let __end0 = __0.2.clone();\n let __temp0 = __action141(\n text,\n __0,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action96(\n text,\n __temp0,\n __1,\n )\n}\n\n#[allow(unused_variables)]\nfn __action252<\n 'input,\n>(\n text: &'input str,\n __0: (usize, Expression, usize),\n __1: (usize, MapExactAssoc, usize),\n __2: (usize, Expression, usize),\n) -> Annotated<(Expression, MapExactAssoc, Expression)>\n{\n let __start0 = __0.0.clone();\n let __end0 = __2.2.clone();\n let __temp0 = __action92(\n text,\n __0,\n __1,\n __2,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action90(\n text,\n __temp0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action253<\n 'input,\n>(\n text: &'input str,\n __0: (usize, Tok<'input>, usize),\n __1: (usize, Expression, usize),\n __2: (usize, MapExactAssoc, usize),\n __3: (usize, Expression, usize),\n __4: (usize, (), usize),\n __5: (usize, Tok<'input>, usize),\n) -> Annotated<(Expression, MapExactAssoc, Expression)>\n{\n let __start0 = __1.0.clone();\n let __end0 = __3.2.clone();\n let __temp0 = __action92(\n text,\n __1,\n __2,\n __3,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action91(\n text,\n __0,\n __temp0,\n __4,\n __5,\n )\n}\n\n#[allow(unused_variables)]\nfn __action254<\n 'input,\n>(\n text: &'input str,\n __0: (usize, FunctionName, usize),\n __1: (usize, Tok<'input>, usize),\n) -> ::std::vec::Vec\n{\n let __start0 = __0.0.clone();\n let __end0 = __1.2.clone();\n let __temp0 = __action122(\n text,\n __0,\n __1,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action195(\n text,\n __temp0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action255<\n 'input,\n>(\n text: &'input str,\n __0: (usize, ::std::vec::Vec, usize),\n __1: (usize, FunctionName, usize),\n __2: (usize, Tok<'input>, usize),\n) -> ::std::vec::Vec\n{\n let __start0 = __1.0.clone();\n let __end0 = __2.2.clone();\n let __temp0 = __action122(\n text,\n __1,\n __2,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action196(\n text,\n __0,\n __temp0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action256<\n 'input,\n>(\n text: &'input str,\n __0: (usize, ::std::option::Option, usize),\n) -> Vec\n{\n let __start0 = __0.0.clone();\n let __end0 = __0.0.clone();\n let __temp0 = __action120(\n text,\n &__start0,\n &__end0,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action111(\n text,\n __temp0,\n __0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action257<\n 'input,\n>(\n text: &'input str,\n __0: (usize, ::std::vec::Vec, usize),\n __1: (usize, ::std::option::Option, usize),\n) -> Vec\n{\n let __start0 = __0.0.clone();\n let __end0 = __0.2.clone();\n let __temp0 = __action121(\n text,\n __0,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action111(\n text,\n __temp0,\n __1,\n )\n}\n\n#[allow(unused_variables)]\nfn __action258<\n 'input,\n>(\n text: &'input str,\n __0: (usize, FunctionName, usize),\n __1: (usize, Tok<'input>, usize),\n __2: (usize, Function, usize),\n) -> ::std::vec::Vec<(FunctionName, Function)>\n{\n let __start0 = __0.0.clone();\n let __end0 = __2.2.clone();\n let __temp0 = __action82(\n text,\n __0,\n __1,\n __2,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action80(\n text,\n __temp0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action259<\n 'input,\n>(\n text: &'input str,\n __0: (usize, ::std::vec::Vec<(FunctionName, Function)>, usize),\n __1: (usize, FunctionName, usize),\n __2: (usize, Tok<'input>, usize),\n __3: (usize, Function, usize),\n) -> ::std::vec::Vec<(FunctionName, Function)>\n{\n let __start0 = __1.0.clone();\n let __end0 = __3.2.clone();\n let __temp0 = __action82(\n text,\n __1,\n __2,\n __3,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action81(\n text,\n __0,\n __temp0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action260<\n 'input,\n>(\n text: &'input str,\n __0: (usize, (Annotated, Vec>), usize),\n __1: (usize, Tok<'input>, usize),\n) -> ::std::vec::Vec<(Annotated, Vec>)>\n{\n let __start0 = __0.0.clone();\n let __end0 = __1.2.clone();\n let __temp0 = __action164(\n text,\n __0,\n __1,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action179(\n text,\n __temp0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action261<\n 'input,\n>(\n text: &'input str,\n __0: (usize, ::std::vec::Vec<(Annotated, Vec>)>, usize),\n __1: (usize, (Annotated, Vec>), usize),\n __2: (usize, Tok<'input>, usize),\n) -> ::std::vec::Vec<(Annotated, Vec>)>\n{\n let __start0 = __1.0.clone();\n let __end0 = __2.2.clone();\n let __temp0 = __action164(\n text,\n __1,\n __2,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action180(\n text,\n __0,\n __temp0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action262<\n 'input,\n>(\n text: &'input str,\n __0: (usize, ::std::option::Option<(Annotated, Vec>)>, usize),\n) -> Vec<(Annotated, Vec>)>\n{\n let __start0 = __0.0.clone();\n let __end0 = __0.0.clone();\n let __temp0 = __action162(\n text,\n &__start0,\n &__end0,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action70(\n text,\n __temp0,\n __0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action263<\n 'input,\n>(\n text: &'input str,\n __0: (usize, ::std::vec::Vec<(Annotated, Vec>)>, usize),\n __1: (usize, ::std::option::Option<(Annotated, Vec>)>, usize),\n) -> Vec<(Annotated, Vec>)>\n{\n let __start0 = __0.0.clone();\n let __end0 = __0.2.clone();\n let __temp0 = __action163(\n text,\n __0,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action70(\n text,\n __temp0,\n __1,\n )\n}\n\n#[allow(unused_variables)]\nfn __action264<\n 'input,\n>(\n text: &'input str,\n __0: (usize, Annotated<(Expression, MapExactAssoc, Expression)>, usize),\n) -> Vec>\n{\n let __start0 = __0.0.clone();\n let __end0 = __0.2.clone();\n let __temp0 = __action143(\n text,\n __0,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action218(\n text,\n __temp0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action265<\n 'input,\n>(\n text: &'input str,\n __lookbehind: &usize,\n __lookahead: &usize,\n) -> Vec>\n{\n let __start0 = __lookbehind.clone();\n let __end0 = __lookahead.clone();\n let __temp0 = __action144(\n text,\n &__start0,\n &__end0,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action218(\n text,\n __temp0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action266<\n 'input,\n>(\n text: &'input str,\n __0: (usize, ::std::vec::Vec>, usize),\n __1: (usize, Annotated<(Expression, MapExactAssoc, Expression)>, usize),\n) -> Vec>\n{\n let __start0 = __1.0.clone();\n let __end0 = __1.2.clone();\n let __temp0 = __action143(\n text,\n __1,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action219(\n text,\n __0,\n __temp0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action267<\n 'input,\n>(\n text: &'input str,\n __0: (usize, ::std::vec::Vec>, usize),\n) -> Vec>\n{\n let __start0 = __0.2.clone();\n let __end0 = __0.2.clone();\n let __temp0 = __action144(\n text,\n &__start0,\n &__end0,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action219(\n text,\n __0,\n __temp0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action268<\n 'input,\n>(\n text: &'input str,\n __0: (usize, Tok<'input>, usize),\n __1: (usize, Expression, usize),\n __2: (usize, Tok<'input>, usize),\n __3: (usize, Tok<'input>, usize),\n) -> SingleExpression\n{\n let __start0 = __2.2.clone();\n let __end0 = __3.0.clone();\n let __temp0 = __action85(\n text,\n &__start0,\n &__end0,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action27(\n text,\n __0,\n __1,\n __2,\n __temp0,\n __3,\n )\n}\n\n#[allow(unused_variables)]\nfn __action269<\n 'input,\n>(\n text: &'input str,\n __0: (usize, Tok<'input>, usize),\n __1: (usize, Expression, usize),\n __2: (usize, Tok<'input>, usize),\n __3: (usize, ::std::vec::Vec>, usize),\n __4: (usize, Tok<'input>, usize),\n) -> SingleExpression\n{\n let __start0 = __3.0.clone();\n let __end0 = __3.2.clone();\n let __temp0 = __action86(\n text,\n __3,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action27(\n text,\n __0,\n __1,\n __2,\n __temp0,\n __4,\n )\n}\n\n#[allow(unused_variables)]\nfn __action270<\n 'input,\n>(\n text: &'input str,\n __0: (usize, Tok<'input>, usize),\n __1: (usize, Tok<'input>, usize),\n __2: (usize, Expression, usize),\n __3: (usize, Tok<'input>, usize),\n __4: (usize, Expression, usize),\n) -> SingleExpression\n{\n let __start0 = __0.2.clone();\n let __end0 = __1.0.clone();\n let __temp0 = __action85(\n text,\n &__start0,\n &__end0,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action32(\n text,\n __0,\n __temp0,\n __1,\n __2,\n __3,\n __4,\n )\n}\n\n#[allow(unused_variables)]\nfn __action271<\n 'input,\n>(\n text: &'input str,\n __0: (usize, Tok<'input>, usize),\n __1: (usize, ::std::vec::Vec>, usize),\n __2: (usize, Tok<'input>, usize),\n __3: (usize, Expression, usize),\n __4: (usize, Tok<'input>, usize),\n __5: (usize, Expression, usize),\n) -> SingleExpression\n{\n let __start0 = __1.0.clone();\n let __end0 = __1.2.clone();\n let __temp0 = __action86(\n text,\n __1,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action32(\n text,\n __0,\n __temp0,\n __2,\n __3,\n __4,\n __5,\n )\n}\n\n#[allow(unused_variables)]\nfn __action272<\n 'input,\n>(\n text: &'input str,\n __0: (usize, Annotated, usize),\n) -> Vec>\n{\n let __start0 = __0.0.clone();\n let __end0 = __0.2.clone();\n let __temp0 = __action133(\n text,\n __0,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action222(\n text,\n __temp0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action273<\n 'input,\n>(\n text: &'input str,\n __lookbehind: &usize,\n __lookahead: &usize,\n) -> Vec>\n{\n let __start0 = __lookbehind.clone();\n let __end0 = __lookahead.clone();\n let __temp0 = __action134(\n text,\n &__start0,\n &__end0,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action222(\n text,\n __temp0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action274<\n 'input,\n>(\n text: &'input str,\n __0: (usize, ::std::vec::Vec>, usize),\n __1: (usize, Annotated, usize),\n) -> Vec>\n{\n let __start0 = __1.0.clone();\n let __end0 = __1.2.clone();\n let __temp0 = __action133(\n text,\n __1,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action223(\n text,\n __0,\n __temp0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action275<\n 'input,\n>(\n text: &'input str,\n __0: (usize, ::std::vec::Vec>, usize),\n) -> Vec>\n{\n let __start0 = __0.2.clone();\n let __end0 = __0.2.clone();\n let __temp0 = __action134(\n text,\n &__start0,\n &__end0,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action223(\n text,\n __0,\n __temp0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action276<\n 'input,\n>(\n text: &'input str,\n __0: (usize, Annotated, usize),\n) -> Vec>\n{\n let __start0 = __0.0.clone();\n let __end0 = __0.2.clone();\n let __temp0 = __action128(\n text,\n __0,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action226(\n text,\n __temp0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action277<\n 'input,\n>(\n text: &'input str,\n __lookbehind: &usize,\n __lookahead: &usize,\n) -> Vec>\n{\n let __start0 = __lookbehind.clone();\n let __end0 = __lookahead.clone();\n let __temp0 = __action129(\n text,\n &__start0,\n &__end0,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action226(\n text,\n __temp0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action278<\n 'input,\n>(\n text: &'input str,\n __0: (usize, ::std::vec::Vec>, usize),\n __1: (usize, Annotated, usize),\n) -> Vec>\n{\n let __start0 = __1.0.clone();\n let __end0 = __1.2.clone();\n let __temp0 = __action128(\n text,\n __1,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action227(\n text,\n __0,\n __temp0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action279<\n 'input,\n>(\n text: &'input str,\n __0: (usize, ::std::vec::Vec>, usize),\n) -> Vec>\n{\n let __start0 = __0.2.clone();\n let __end0 = __0.2.clone();\n let __temp0 = __action129(\n text,\n &__start0,\n &__end0,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action227(\n text,\n __0,\n __temp0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action280<\n 'input,\n>(\n text: &'input str,\n __0: (usize, Annotated, usize),\n) -> Vec>\n{\n let __start0 = __0.0.clone();\n let __end0 = __0.2.clone();\n let __temp0 = __action150(\n text,\n __0,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action230(\n text,\n __temp0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action281<\n 'input,\n>(\n text: &'input str,\n __lookbehind: &usize,\n __lookahead: &usize,\n) -> Vec>\n{\n let __start0 = __lookbehind.clone();\n let __end0 = __lookahead.clone();\n let __temp0 = __action151(\n text,\n &__start0,\n &__end0,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action230(\n text,\n __temp0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action282<\n 'input,\n>(\n text: &'input str,\n __0: (usize, ::std::vec::Vec>, usize),\n __1: (usize, Annotated, usize),\n) -> Vec>\n{\n let __start0 = __1.0.clone();\n let __end0 = __1.2.clone();\n let __temp0 = __action150(\n text,\n __1,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action231(\n text,\n __0,\n __temp0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action283<\n 'input,\n>(\n text: &'input str,\n __0: (usize, ::std::vec::Vec>, usize),\n) -> Vec>\n{\n let __start0 = __0.2.clone();\n let __end0 = __0.2.clone();\n let __temp0 = __action151(\n text,\n &__start0,\n &__end0,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action231(\n text,\n __0,\n __temp0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action284<\n 'input,\n>(\n text: &'input str,\n __0: (usize, Annotated<(Annotated, Annotated)>, usize),\n) -> Vec, Annotated)>>\n{\n let __start0 = __0.0.clone();\n let __end0 = __0.2.clone();\n let __temp0 = __action155(\n text,\n __0,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action234(\n text,\n __temp0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action285<\n 'input,\n>(\n text: &'input str,\n __lookbehind: &usize,\n __lookahead: &usize,\n) -> Vec, Annotated)>>\n{\n let __start0 = __lookbehind.clone();\n let __end0 = __lookahead.clone();\n let __temp0 = __action156(\n text,\n &__start0,\n &__end0,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action234(\n text,\n __temp0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action286<\n 'input,\n>(\n text: &'input str,\n __0: (usize, ::std::vec::Vec, Annotated)>>, usize),\n __1: (usize, Annotated<(Annotated, Annotated)>, usize),\n) -> Vec, Annotated)>>\n{\n let __start0 = __1.0.clone();\n let __end0 = __1.2.clone();\n let __temp0 = __action155(\n text,\n __1,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action235(\n text,\n __0,\n __temp0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action287<\n 'input,\n>(\n text: &'input str,\n __0: (usize, ::std::vec::Vec, Annotated)>>, usize),\n) -> Vec, Annotated)>>\n{\n let __start0 = __0.2.clone();\n let __end0 = __0.2.clone();\n let __temp0 = __action156(\n text,\n &__start0,\n &__end0,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action235(\n text,\n __0,\n __temp0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action288<\n 'input,\n>(\n text: &'input str,\n __0: (usize, (Expression, Vec), usize),\n) -> Vec<(Expression, Vec)>\n{\n let __start0 = __0.0.clone();\n let __end0 = __0.2.clone();\n let __temp0 = __action165(\n text,\n __0,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action242(\n text,\n __temp0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action289<\n 'input,\n>(\n text: &'input str,\n __lookbehind: &usize,\n __lookahead: &usize,\n) -> Vec<(Expression, Vec)>\n{\n let __start0 = __lookbehind.clone();\n let __end0 = __lookahead.clone();\n let __temp0 = __action166(\n text,\n &__start0,\n &__end0,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action242(\n text,\n __temp0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action290<\n 'input,\n>(\n text: &'input str,\n __0: (usize, ::std::vec::Vec<(Expression, Vec)>, usize),\n __1: (usize, (Expression, Vec), usize),\n) -> Vec<(Expression, Vec)>\n{\n let __start0 = __1.0.clone();\n let __end0 = __1.2.clone();\n let __temp0 = __action165(\n text,\n __1,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action243(\n text,\n __0,\n __temp0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action291<\n 'input,\n>(\n text: &'input str,\n __0: (usize, ::std::vec::Vec<(Expression, Vec)>, usize),\n) -> Vec<(Expression, Vec)>\n{\n let __start0 = __0.2.clone();\n let __end0 = __0.2.clone();\n let __temp0 = __action166(\n text,\n &__start0,\n &__end0,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action243(\n text,\n __0,\n __temp0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action292<\n 'input,\n>(\n text: &'input str,\n __0: (usize, Constant, usize),\n) -> Vec\n{\n let __start0 = __0.0.clone();\n let __end0 = __0.2.clone();\n let __temp0 = __action170(\n text,\n __0,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action246(\n text,\n __temp0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action293<\n 'input,\n>(\n text: &'input str,\n __lookbehind: &usize,\n __lookahead: &usize,\n) -> Vec\n{\n let __start0 = __lookbehind.clone();\n let __end0 = __lookahead.clone();\n let __temp0 = __action171(\n text,\n &__start0,\n &__end0,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action246(\n text,\n __temp0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action294<\n 'input,\n>(\n text: &'input str,\n __0: (usize, ::std::vec::Vec, usize),\n __1: (usize, Constant, usize),\n) -> Vec\n{\n let __start0 = __1.0.clone();\n let __end0 = __1.2.clone();\n let __temp0 = __action170(\n text,\n __1,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action247(\n text,\n __0,\n __temp0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action295<\n 'input,\n>(\n text: &'input str,\n __0: (usize, ::std::vec::Vec, usize),\n) -> Vec\n{\n let __start0 = __0.2.clone();\n let __end0 = __0.2.clone();\n let __temp0 = __action171(\n text,\n &__start0,\n &__end0,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action247(\n text,\n __0,\n __temp0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action296<\n 'input,\n>(\n text: &'input str,\n __0: (usize, Expression, usize),\n) -> Vec\n{\n let __start0 = __0.0.clone();\n let __end0 = __0.2.clone();\n let __temp0 = __action138(\n text,\n __0,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action250(\n text,\n __temp0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action297<\n 'input,\n>(\n text: &'input str,\n __lookbehind: &usize,\n __lookahead: &usize,\n) -> Vec\n{\n let __start0 = __lookbehind.clone();\n let __end0 = __lookahead.clone();\n let __temp0 = __action139(\n text,\n &__start0,\n &__end0,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action250(\n text,\n __temp0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action298<\n 'input,\n>(\n text: &'input str,\n __0: (usize, ::std::vec::Vec, usize),\n __1: (usize, Expression, usize),\n) -> Vec\n{\n let __start0 = __1.0.clone();\n let __end0 = __1.2.clone();\n let __temp0 = __action138(\n text,\n __1,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action251(\n text,\n __0,\n __temp0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action299<\n 'input,\n>(\n text: &'input str,\n __0: (usize, ::std::vec::Vec, usize),\n) -> Vec\n{\n let __start0 = __0.2.clone();\n let __end0 = __0.2.clone();\n let __temp0 = __action139(\n text,\n &__start0,\n &__end0,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action251(\n text,\n __0,\n __temp0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action300<\n 'input,\n>(\n text: &'input str,\n __0: (usize, Tok<'input>, usize),\n __1: (usize, Atom, usize),\n __2: (usize, Vec, usize),\n __3: (usize, Tok<'input>, usize),\n __4: (usize, Vec<(Atom, Constant)>, usize),\n __5: (usize, Tok<'input>, usize),\n) -> Module\n{\n let __start0 = __4.2.clone();\n let __end0 = __5.0.clone();\n let __temp0 = __action112(\n text,\n &__start0,\n &__end0,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action5(\n text,\n __0,\n __1,\n __2,\n __3,\n __4,\n __temp0,\n __5,\n )\n}\n\n#[allow(unused_variables)]\nfn __action301<\n 'input,\n>(\n text: &'input str,\n __0: (usize, Tok<'input>, usize),\n __1: (usize, Atom, usize),\n __2: (usize, Vec, usize),\n __3: (usize, Tok<'input>, usize),\n __4: (usize, Vec<(Atom, Constant)>, usize),\n __5: (usize, ::std::vec::Vec, usize),\n __6: (usize, Tok<'input>, usize),\n) -> Module\n{\n let __start0 = __5.0.clone();\n let __end0 = __5.2.clone();\n let __temp0 = __action113(\n text,\n __5,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action5(\n text,\n __0,\n __1,\n __2,\n __3,\n __4,\n __temp0,\n __6,\n )\n}\n\n#[allow(unused_variables)]\nfn __action302<\n 'input,\n>(\n text: &'input str,\n __0: (usize, FunctionName, usize),\n) -> Vec\n{\n let __start0 = __0.0.clone();\n let __end0 = __0.2.clone();\n let __temp0 = __action118(\n text,\n __0,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action256(\n text,\n __temp0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action303<\n 'input,\n>(\n text: &'input str,\n __lookbehind: &usize,\n __lookahead: &usize,\n) -> Vec\n{\n let __start0 = __lookbehind.clone();\n let __end0 = __lookahead.clone();\n let __temp0 = __action119(\n text,\n &__start0,\n &__end0,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action256(\n text,\n __temp0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action304<\n 'input,\n>(\n text: &'input str,\n __0: (usize, ::std::vec::Vec, usize),\n __1: (usize, FunctionName, usize),\n) -> Vec\n{\n let __start0 = __1.0.clone();\n let __end0 = __1.2.clone();\n let __temp0 = __action118(\n text,\n __1,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action257(\n text,\n __0,\n __temp0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action305<\n 'input,\n>(\n text: &'input str,\n __0: (usize, ::std::vec::Vec, usize),\n) -> Vec\n{\n let __start0 = __0.2.clone();\n let __end0 = __0.2.clone();\n let __temp0 = __action119(\n text,\n &__start0,\n &__end0,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action257(\n text,\n __0,\n __temp0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action306<\n 'input,\n>(\n text: &'input str,\n __0: (usize, Annotated, usize),\n __1: (usize, Tok<'input>, usize),\n __2: (usize, Annotated, usize),\n) -> Annotated\n{\n let __start0 = __0.0.clone();\n let __end0 = __2.2.clone();\n let __temp0 = __action44(\n text,\n __0,\n __1,\n __2,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action77(\n text,\n __temp0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action307<\n 'input,\n>(\n text: &'input str,\n __0: (usize, Atom, usize),\n) -> Annotated\n{\n let __start0 = __0.0.clone();\n let __end0 = __0.2.clone();\n let __temp0 = __action45(\n text,\n __0,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action77(\n text,\n __temp0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action308<\n 'input,\n>(\n text: &'input str,\n __0: (usize, AtomicTerm, usize),\n) -> Annotated\n{\n let __start0 = __0.0.clone();\n let __end0 = __0.2.clone();\n let __temp0 = __action46(\n text,\n __0,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action77(\n text,\n __temp0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action309<\n 'input,\n>(\n text: &'input str,\n __0: (usize, Vec<(Annotated, Vec>)>, usize),\n) -> Annotated\n{\n let __start0 = __0.0.clone();\n let __end0 = __0.2.clone();\n let __temp0 = __action47(\n text,\n __0,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action77(\n text,\n __temp0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action310<\n 'input,\n>(\n text: &'input str,\n __0: (usize, Tok<'input>, usize),\n __1: (usize, Vec>, usize),\n __2: (usize, Tok<'input>, usize),\n) -> Annotated\n{\n let __start0 = __0.0.clone();\n let __end0 = __2.2.clone();\n let __temp0 = __action48(\n text,\n __0,\n __1,\n __2,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action77(\n text,\n __temp0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action311<\n 'input,\n>(\n text: &'input str,\n __0: (usize, Tok<'input>, usize),\n __1: (usize, Vec, Annotated)>>, usize),\n __2: (usize, Tok<'input>, usize),\n) -> Annotated\n{\n let __start0 = __0.0.clone();\n let __end0 = __2.2.clone();\n let __temp0 = __action49(\n text,\n __0,\n __1,\n __2,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action77(\n text,\n __temp0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action312<\n 'input,\n>(\n text: &'input str,\n __0: (usize, Tok<'input>, usize),\n __1: (usize, Vec>, usize),\n __2: (usize, Tok<'input>, usize),\n __3: (usize, Annotated, usize),\n __4: (usize, Tok<'input>, usize),\n) -> Annotated\n{\n let __start0 = __0.0.clone();\n let __end0 = __4.2.clone();\n let __temp0 = __action198(\n text,\n __0,\n __1,\n __2,\n __3,\n __4,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action77(\n text,\n __temp0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action313<\n 'input,\n>(\n text: &'input str,\n __0: (usize, Tok<'input>, usize),\n __1: (usize, Vec>, usize),\n __2: (usize, Tok<'input>, usize),\n) -> Annotated\n{\n let __start0 = __0.0.clone();\n let __end0 = __2.2.clone();\n let __temp0 = __action199(\n text,\n __0,\n __1,\n __2,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action77(\n text,\n __temp0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action314<\n 'input,\n>(\n text: &'input str,\n __0: (usize, Tok<'input>, usize),\n __1: (usize, Annotated, usize),\n __2: (usize, Tok<'input>, usize),\n __3: (usize, Annotated, usize),\n __4: (usize, (), usize),\n __5: (usize, Tok<'input>, usize),\n) -> Annotated\n{\n let __start0 = __1.0.clone();\n let __end0 = __3.2.clone();\n let __temp0 = __action44(\n text,\n __1,\n __2,\n __3,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action78(\n text,\n __0,\n __temp0,\n __4,\n __5,\n )\n}\n\n#[allow(unused_variables)]\nfn __action315<\n 'input,\n>(\n text: &'input str,\n __0: (usize, Tok<'input>, usize),\n __1: (usize, Atom, usize),\n __2: (usize, (), usize),\n __3: (usize, Tok<'input>, usize),\n) -> Annotated\n{\n let __start0 = __1.0.clone();\n let __end0 = __1.2.clone();\n let __temp0 = __action45(\n text,\n __1,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action78(\n text,\n __0,\n __temp0,\n __2,\n __3,\n )\n}\n\n#[allow(unused_variables)]\nfn __action316<\n 'input,\n>(\n text: &'input str,\n __0: (usize, Tok<'input>, usize),\n __1: (usize, AtomicTerm, usize),\n __2: (usize, (), usize),\n __3: (usize, Tok<'input>, usize),\n) -> Annotated\n{\n let __start0 = __1.0.clone();\n let __end0 = __1.2.clone();\n let __temp0 = __action46(\n text,\n __1,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action78(\n text,\n __0,\n __temp0,\n __2,\n __3,\n )\n}\n\n#[allow(unused_variables)]\nfn __action317<\n 'input,\n>(\n text: &'input str,\n __0: (usize, Tok<'input>, usize),\n __1: (usize, Vec<(Annotated, Vec>)>, usize),\n __2: (usize, (), usize),\n __3: (usize, Tok<'input>, usize),\n) -> Annotated\n{\n let __start0 = __1.0.clone();\n let __end0 = __1.2.clone();\n let __temp0 = __action47(\n text,\n __1,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action78(\n text,\n __0,\n __temp0,\n __2,\n __3,\n )\n}\n\n#[allow(unused_variables)]\nfn __action318<\n 'input,\n>(\n text: &'input str,\n __0: (usize, Tok<'input>, usize),\n __1: (usize, Tok<'input>, usize),\n __2: (usize, Vec>, usize),\n __3: (usize, Tok<'input>, usize),\n __4: (usize, (), usize),\n __5: (usize, Tok<'input>, usize),\n) -> Annotated\n{\n let __start0 = __1.0.clone();\n let __end0 = __3.2.clone();\n let __temp0 = __action48(\n text,\n __1,\n __2,\n __3,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action78(\n text,\n __0,\n __temp0,\n __4,\n __5,\n )\n}\n\n#[allow(unused_variables)]\nfn __action319<\n 'input,\n>(\n text: &'input str,\n __0: (usize, Tok<'input>, usize),\n __1: (usize, Tok<'input>, usize),\n __2: (usize, Vec, Annotated)>>, usize),\n __3: (usize, Tok<'input>, usize),\n __4: (usize, (), usize),\n __5: (usize, Tok<'input>, usize),\n) -> Annotated\n{\n let __start0 = __1.0.clone();\n let __end0 = __3.2.clone();\n let __temp0 = __action49(\n text,\n __1,\n __2,\n __3,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action78(\n text,\n __0,\n __temp0,\n __4,\n __5,\n )\n}\n\n#[allow(unused_variables)]\nfn __action320<\n 'input,\n>(\n text: &'input str,\n __0: (usize, Tok<'input>, usize),\n __1: (usize, Tok<'input>, usize),\n __2: (usize, Vec>, usize),\n __3: (usize, Tok<'input>, usize),\n __4: (usize, Annotated, usize),\n __5: (usize, Tok<'input>, usize),\n __6: (usize, (), usize),\n __7: (usize, Tok<'input>, usize),\n) -> Annotated\n{\n let __start0 = __1.0.clone();\n let __end0 = __5.2.clone();\n let __temp0 = __action198(\n text,\n __1,\n __2,\n __3,\n __4,\n __5,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action78(\n text,\n __0,\n __temp0,\n __6,\n __7,\n )\n}\n\n#[allow(unused_variables)]\nfn __action321<\n 'input,\n>(\n text: &'input str,\n __0: (usize, Tok<'input>, usize),\n __1: (usize, Tok<'input>, usize),\n __2: (usize, Vec>, usize),\n __3: (usize, Tok<'input>, usize),\n __4: (usize, (), usize),\n __5: (usize, Tok<'input>, usize),\n) -> Annotated\n{\n let __start0 = __1.0.clone();\n let __end0 = __3.2.clone();\n let __temp0 = __action199(\n text,\n __1,\n __2,\n __3,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action78(\n text,\n __0,\n __temp0,\n __4,\n __5,\n )\n}\n\n#[allow(unused_variables)]\nfn __action322<\n 'input,\n>(\n text: &'input str,\n __0: (usize, (Annotated, Vec>), usize),\n) -> Vec<(Annotated, Vec>)>\n{\n let __start0 = __0.0.clone();\n let __end0 = __0.2.clone();\n let __temp0 = __action160(\n text,\n __0,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action262(\n text,\n __temp0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action323<\n 'input,\n>(\n text: &'input str,\n __lookbehind: &usize,\n __lookahead: &usize,\n) -> Vec<(Annotated, Vec>)>\n{\n let __start0 = __lookbehind.clone();\n let __end0 = __lookahead.clone();\n let __temp0 = __action161(\n text,\n &__start0,\n &__end0,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action262(\n text,\n __temp0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action324<\n 'input,\n>(\n text: &'input str,\n __0: (usize, ::std::vec::Vec<(Annotated, Vec>)>, usize),\n __1: (usize, (Annotated, Vec>), usize),\n) -> Vec<(Annotated, Vec>)>\n{\n let __start0 = __1.0.clone();\n let __end0 = __1.2.clone();\n let __temp0 = __action160(\n text,\n __1,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action263(\n text,\n __0,\n __temp0,\n )\n}\n\n#[allow(unused_variables)]\nfn __action325<\n 'input,\n>(\n text: &'input str,\n __0: (usize, ::std::vec::Vec<(Annotated, Vec>)>, usize),\n) -> Vec<(Annotated, Vec>)>\n{\n let __start0 = __0.2.clone();\n let __end0 = __0.2.clone();\n let __temp0 = __action161(\n text,\n &__start0,\n &__end0,\n );\n let __temp0 = (__start0, __temp0, __end0);\n __action263(\n text,\n __0,\n __temp0,\n )\n}\n\npub trait __ToTriple<'input, > {\n fn to_triple(value: Self) -> Result<(usize,Tok<'input>,usize), __lalrpop_util::ParseError, ()>>;\n}\n\nimpl<'input, > __ToTriple<'input, > for (usize, Tok<'input>, usize) {\n fn to_triple(value: Self) -> Result<(usize,Tok<'input>,usize), __lalrpop_util::ParseError, ()>> {\n Ok(value)\n }\n}\nimpl<'input, > __ToTriple<'input, > for Result<(usize, Tok<'input>, usize), ()> {\n fn to_triple(value: Self) -> Result<(usize,Tok<'input>,usize), __lalrpop_util::ParseError, ()>> {\n match value {\n Ok(v) => Ok(v),\n Err(error) => Err(__lalrpop_util::ParseError::User { error }),\n }\n }\n}\n" }, { "path": "libeir_syntax_core/src/parser/mod.rs", "content": "use crate::ast::{ Annotated, Module };\nuse crate::lexer::{ Tokenizer, Tok };\n\nmod grammar;\n\npub fn parse<'input>(text: &'input str) -> Result,\n ::lalrpop_util::ParseError, ()>> {\n\n let tokenizer = Tokenizer::new(text);\n let parser = grammar::AnnotatedModuleParser::new();\n parser.parse(text, tokenizer)\n}\n" }, { "path": "libeir_syntax_erl/.gitignore", "content": "/target\n**/*.rs.bk\nCargo.lock\n" }, { "path": "libeir_syntax_erl/Cargo.toml", "content": "[package]\nname = \"libeir_syntax_erl\"\nversion = \"0.1.0\"\nauthors = [\"Paul Schoenfelder \", \"Luke Imhoff \"]\nreadme = \"README.md\"\npublish = false\nedition = \"2018\"\nlicense = \"MIT OR Apache-2.0\"\n\nbuild = \"build.rs\"\n\n[dependencies]\nlibeir_diagnostics = { path = \"../libeir_diagnostics\" }\nlibeir_ir = { path = \"../libeir_ir\" }\nlibeir_intern = { path = \"../libeir_intern\" }\nlibeir_util_datastructures = { path = \"../util/libeir_util_datastructures\" }\nlibeir_util_number = { path = \"../util/libeir_util_number\" }\nlibeir_util_binary = { path = \"../util/libeir_util_binary\" }\nlibeir_util_parse = { path = \"../util/libeir_util_parse\" }\nlibeir_util_parse_listing = { path = \"../util/libeir_util_parse_listing\" }\n\ncodespan-reporting = \"0.9\"\ncranelift-entity = \"0.56.0\"\nrustc-hash = \"1.0\"\nlalrpop-util = \"0.17\"\nglob = \"0.2\"\ntermcolor = \"0.3\"\nsnafu = \"0.5\"\nitertools = \"0.8\"\nlazy_static = \"1.2\"\neither = \"1.5\"\n\nbumpalo = { git = \"https://github.com/hansihe/bumpalo\", features = [\"nightly\"] }\n\n# [dependencies.rug]\n# version = \"1.2\"\n# default-features = false\n# features = [\"integer\", \"float\", \"rand\"]\n\n[dev-dependencies]\npretty_assertions = \"0.5\"\n\n[build-dependencies]\nlalrpop = \"0.17\"\n" }, { "path": "libeir_syntax_erl/build.rs", "content": "extern crate lalrpop;\n\nfn main() {\n lalrpop::Configuration::new()\n .use_cargo_dir_conventions()\n .process_file(\"src/parser/grammar.lalrpop\")\n .unwrap();\n println!(\"cargo:rerun-if-changed=src/parser/grammar.lalrpop\");\n}\n" }, { "path": "libeir_syntax_erl/src/abstr/lower.rs", "content": "use libeir_diagnostics::SourceSpan;\nuse libeir_intern::Ident;\nuse libeir_ir::ToPrimitive;\nuse libeir_ir::binary::BinaryEntrySpecifier;\nuse libeir_util_number::Float;\nuse libeir_util_parse::MessageIgnore;\n\nuse std::convert::TryInto;\n\nuse crate::ast::Name;\nuse crate::parser::ast;\nuse libeir_util_parse_listing::ast as aast;\n\nfn to_list_expr(\n id_gen: &mut ast::NodeIdGenerator,\n span: SourceSpan,\n mut list: Vec,\n) -> ast::Expr {\n let mut acc = ast::Expr::Nil(ast::Nil(span, id_gen.next()));\n for elem in list.drain(..).rev() {\n acc = ast::Expr::Cons(ast::Cons {\n id: id_gen.next(),\n span,\n head: Box::new(elem),\n tail: Box::new(acc),\n });\n }\n acc\n}\n\npub fn lower(root: &aast::Root) -> ast::Module {\n let mut toplevel: Vec = Vec::new();\n\n let mut id_gen = ast::NodeIdGenerator::new();\n\n let module_span = root.span();\n let mut module_name = None;\n let mut eof = false;\n\n for item in root.items.iter() {\n let tuple = item.tuple().unwrap();\n let name_ident = tuple.entries[0].atom().unwrap();\n let name = name_ident.as_str();\n\n let _line = tuple.entries[1].integer().unwrap();\n\n assert!(!eof);\n\n match &*name {\n \"attribute\" => {\n let attr_ident = tuple.entries[2].atom().unwrap();\n let attr = attr_ident.as_str();\n\n match &*attr {\n \"file\" => (),\n \"module\" => {\n module_name = Some(tuple.entries[3].atom().unwrap());\n }\n \"export\" => {\n let exports = tuple.entries[3]\n .list_iter()\n .unwrap()\n .map(|item| {\n let item_tup = item.tuple().unwrap();\n let name = item_tup.entries[0].atom().unwrap();\n let arity = item_tup.entries[1].integer().unwrap();\n ast::PartiallyResolvedFunctionName {\n span: item_tup.span,\n id: id_gen.next(),\n function: name,\n arity: arity.integer.to_usize().unwrap(),\n }\n })\n .collect();\n toplevel.push(ast::TopLevel::Attribute(ast::Attribute::Export(\n tuple.span, exports,\n )));\n }\n \"compile\" => {\n let opts = tuple.entries[3]\n .list_iter()\n .unwrap()\n .map(|item| match item {\n aast::Item::Atom(ident) => {\n ast::Expr::Literal(ast::Literal::Atom(id_gen.next(), *ident))\n }\n _ => unimplemented!(\"{:?}\", item),\n })\n .collect();\n toplevel.push(ast::TopLevel::Attribute(ast::Attribute::Compile(\n tuple.span,\n to_list_expr(&mut id_gen, tuple.span, opts),\n )))\n }\n \"spec\" => {\n continue;\n }\n \"dialyzer\" => {\n continue;\n }\n \"export_type\" => {\n continue;\n }\n \"type\" => {\n continue;\n }\n \"opaque\" => {\n continue;\n //let inner_tup = tuple.entries[3].tuple().unwrap();\n //let def = ast::TypeDef {\n // span,\n // opaque: true,\n // name: inner_tup.entries[0].atom().unwrap(),\n\n //};\n //toplevel.push(ast::TopLevel::Attribute(\n // ast::Attribute::Type(def)));\n }\n \"record\" => {\n let rec_tup = tuple.entries[3].tuple().unwrap();\n\n let name = rec_tup.entries[0].atom().unwrap();\n let fields = rec_tup.entries[1]\n .list_iter()\n .unwrap()\n .map(|v| lower_record_field(&mut id_gen, v))\n .collect();\n\n let record = ast::Record {\n span: rec_tup.span,\n id: id_gen.next(),\n name,\n fields,\n };\n toplevel.push(ast::TopLevel::Record(record));\n }\n \"behaviour\" => toplevel.push(ast::TopLevel::Attribute(\n ast::Attribute::Behaviour(tuple.span, tuple.entries[3].atom().unwrap()),\n )),\n n => unimplemented!(\"attribute {} {:?}\", n, tuple),\n }\n }\n \"function\" => {\n let fun_name = tuple.entries[2].atom().unwrap();\n let fun_arity = tuple.entries[3]\n .integer()\n .unwrap()\n .integer\n .to_usize()\n .unwrap();\n\n let clauses = tuple.entries[4]\n .list_iter()\n .unwrap()\n .map(|clause| lower_function_clause(&mut id_gen, clause))\n .collect();\n\n toplevel.push(ast::TopLevel::Function(ast::NamedFunction {\n span: tuple.span,\n id: id_gen.next(),\n name: Name::Atom(fun_name),\n arity: fun_arity,\n clauses,\n spec: None,\n }));\n }\n \"eof\" => {\n eof = true;\n }\n n => unimplemented!(\"{}\", n),\n }\n }\n\n let mut errors = MessageIgnore::new();\n let module = ast::Module::new(\n &mut errors,\n module_span,\n &mut id_gen,\n module_name.unwrap(),\n toplevel,\n );\n assert!(!errors.failed());\n module\n}\n\nfn lower_record_field(gen: &mut ast::NodeIdGenerator, tup_item: &aast::Item) -> ast::RecordField {\n let tup = tup_item.tuple().unwrap();\n\n assert!(&*tup.entries[0].atom().unwrap().as_str() == \"record_field\");\n assert!(tup.entries.len() == 3 || tup.entries.len() == 4);\n\n let name = atom(&tup.entries[2]);\n\n let value = tup.entries.get(3).map(|v| lower_expr(gen, v));\n\n ast::RecordField {\n span: tup.span,\n id: gen.next(),\n name,\n value,\n ty: None,\n }\n}\n\nfn lower_function_clause(\n gen: &mut ast::NodeIdGenerator,\n clause: &aast::Item,\n) -> ast::FunctionClause {\n let tup = clause.tuple().unwrap();\n\n assert!(tup.entries[0].atom().unwrap().as_str() == \"clause\");\n let _line = tup.entries[1].integer().unwrap();\n\n let params = &tup.entries[2];\n let guard = &tup.entries[3];\n let body = &tup.entries[4];\n\n let params_n: Vec<_> = params\n .list_iter()\n .unwrap()\n .map(|param| lower_expr(gen, param))\n .collect();\n\n let guard_n = lower_guards(gen, guard);\n\n let body_n = lower_body(gen, body);\n\n ast::FunctionClause {\n span: clause.span(),\n name: None,\n params: params_n,\n guard: guard_n,\n body: body_n,\n }\n}\n\nfn lower_clause(gen: &mut ast::NodeIdGenerator, clause: &aast::Item) -> ast::Clause {\n let tup = clause.tuple().unwrap();\n\n assert!(tup.entries[0].atom().unwrap().as_str() == \"clause\");\n let _line = tup.entries[1].integer().unwrap();\n\n let pattern = &tup.entries[2];\n let guard = &tup.entries[3];\n let body = &tup.entries[4];\n\n let mut patterns = pattern.list_iter().unwrap();\n let pattern_n = lower_expr(gen, patterns.next().unwrap());\n assert!(patterns.next().is_none());\n\n let guard_n = lower_guards(gen, guard);\n\n let body_n = lower_body(gen, body);\n\n ast::Clause {\n span: clause.span(),\n id: gen.next(),\n pattern: pattern_n,\n guard: guard_n,\n body: body_n,\n }\n}\n\nfn lower_if_clause(gen: &mut ast::NodeIdGenerator, clause: &aast::Item) -> ast::IfClause {\n let tup = clause.tuple().unwrap();\n\n assert!(tup.entries[0].atom().unwrap().as_str() == \"clause\");\n let _line = tup.entries[1].integer().unwrap();\n\n assert!(tup.entries[2].list_iter().unwrap().count() == 0);\n let guard = &tup.entries[3];\n let body = &tup.entries[4];\n\n let guard_n = lower_guards(gen, guard);\n let body_n = lower_body(gen, body);\n\n ast::IfClause {\n span: clause.span(),\n id: gen.next(),\n guards: guard_n.unwrap(),\n body: body_n,\n }\n}\n\nfn lower_try_clause(gen: &mut ast::NodeIdGenerator, clause: &aast::Item) -> ast::TryClause {\n let tup = clause.tuple().unwrap();\n\n assert!(tup.entries[0].atom().unwrap().as_str() == \"clause\");\n let _line = tup.entries[1].integer().unwrap();\n\n let pattern = &tup.entries[2];\n let guard = &tup.entries[3];\n let body = &tup.entries[4];\n\n let mut patterns = pattern.list_iter().unwrap();\n let pattern = patterns.next().unwrap();\n assert!(patterns.next().is_none());\n\n let patterns_tup_cont = pattern.tuple().unwrap();\n assert!(patterns_tup_cont.entries.len() == 3);\n assert!(patterns_tup_cont.entries[0].atom().unwrap().as_str() == \"tuple\");\n\n let mut patterns_tup = patterns_tup_cont.entries[2].list_iter().unwrap();\n let err_kind = patterns_tup.next().unwrap();\n let err_error = patterns_tup.next().unwrap();\n let err_trace = patterns_tup.next().unwrap();\n assert!(patterns_tup.next().is_none());\n\n let err_kind_tup = err_kind.tuple().unwrap();\n let err_kind_name = match &*err_kind_tup.entries[0].atom().unwrap().as_str() {\n \"var\" => ast::Name::Var(err_kind_tup.entries[2].atom().unwrap()),\n \"atom\" => ast::Name::Atom(err_kind_tup.entries[2].atom().unwrap()),\n _ => panic!(),\n };\n\n let err_trace_tup = err_trace.tuple().unwrap();\n assert!(&*err_trace_tup.entries[0].atom().unwrap().as_str() == \"var\");\n let err_trace_ident = err_trace_tup.entries[2].atom().unwrap();\n\n let guard_n = lower_guards(gen, guard);\n\n let body_n = lower_body(gen, body);\n\n ast::TryClause {\n span: clause.span(),\n id: gen.next(),\n kind: err_kind_name,\n error: lower_expr(gen, err_error),\n trace: err_trace_ident,\n guard: guard_n,\n body: body_n,\n }\n}\n\nfn lower_guards(gen: &mut ast::NodeIdGenerator, guard: &aast::Item) -> Option> {\n let guard_n: Vec<_> = guard\n .list_iter()\n .unwrap()\n .map(|guard| ast::Guard {\n span: guard.span(),\n conditions: guard\n .list_iter()\n .unwrap()\n .map(|v| lower_expr(gen, v))\n .collect(),\n })\n .collect();\n if guard_n.len() == 0 {\n None\n } else {\n Some(guard_n)\n }\n}\n\nfn lower_body(gen: &mut ast::NodeIdGenerator, body: &aast::Item) -> Vec {\n let body_n: Vec<_> = body\n .list_iter()\n .unwrap()\n .map(|expr| lower_expr(gen, expr))\n .collect();\n body_n\n}\n\nfn lower_expr(gen: &mut ast::NodeIdGenerator, expr: &aast::Item) -> ast::Expr {\n let tup = expr.tuple().unwrap();\n\n let name = tup.entries[0].atom().unwrap().as_str();\n let _line = tup.entries[1].integer().unwrap();\n\n let span = tup.span;\n\n match &*name {\n \"var\" => ast::Expr::Var(ast::Var(gen.next(), tup.entries[2].atom().unwrap())),\n \"op\" => {\n let tup_len = tup.entries.len();\n let op = tup.entries[2].atom().unwrap().as_str();\n\n enum ExprKind {\n Unary(ast::UnaryOp),\n Binary(ast::BinaryOp),\n }\n\n let expr_kind = match (&*op, tup_len) {\n (\"+\", 5) => ExprKind::Binary(ast::BinaryOp::Add),\n (\"-\", 5) => ExprKind::Binary(ast::BinaryOp::Sub),\n (\"*\", 5) => ExprKind::Binary(ast::BinaryOp::Multiply),\n (\"==\", 5) => ExprKind::Binary(ast::BinaryOp::Equal),\n (\"=:=\", 5) => ExprKind::Binary(ast::BinaryOp::StrictEqual),\n (\"=/=\", 5) => ExprKind::Binary(ast::BinaryOp::StrictNotEqual),\n (\"andalso\", 5) => ExprKind::Binary(ast::BinaryOp::AndAlso),\n (\"++\", 5) => ExprKind::Binary(ast::BinaryOp::Append),\n (\">\", 5) => ExprKind::Binary(ast::BinaryOp::Gt),\n (\"<\", 5) => ExprKind::Binary(ast::BinaryOp::Lt),\n (\"rem\", 5) => ExprKind::Binary(ast::BinaryOp::Rem),\n\n (\"+\", 4) => ExprKind::Unary(ast::UnaryOp::Plus),\n (\"-\", 4) => ExprKind::Unary(ast::UnaryOp::Minus),\n (\"bnot\", 4) => ExprKind::Unary(ast::UnaryOp::Bnot),\n (\"not\", 4) => ExprKind::Unary(ast::UnaryOp::Not),\n\n (n, a) => unimplemented!(\"{} {}\", n, a),\n };\n\n match expr_kind {\n ExprKind::Unary(op) => ast::Expr::UnaryExpr(ast::UnaryExpr {\n span,\n id: gen.next(),\n op: op,\n operand: Box::new(lower_expr(gen, &tup.entries[3])),\n }),\n ExprKind::Binary(op) => ast::Expr::BinaryExpr(ast::BinaryExpr {\n span,\n id: gen.next(),\n op: op,\n lhs: Box::new(lower_expr(gen, &tup.entries[3])),\n rhs: Box::new(lower_expr(gen, &tup.entries[4])),\n }),\n }\n }\n \"integer\" => {\n let int = tup.entries[2].integer().unwrap();\n let lit = ast::Literal::Integer(span, gen.next(), int.integer.clone());\n ast::Expr::Literal(lit)\n }\n \"string\" => {\n if let Some(string) = tup.entries[2].string() {\n ast::Expr::Literal(ast::Literal::String(gen.next(), string))\n } else {\n let elems: Vec<_> = tup.entries[2].list_iter().unwrap().collect();\n let mut acc = ast::Expr::Nil(ast::Nil(tup.span, gen.next()));\n for elem in elems.iter().rev() {\n acc = ast::Expr::Cons(ast::Cons {\n span: elem.span(),\n id: gen.next(),\n head: Box::new(lower_expr(gen, elem)),\n tail: Box::new(acc),\n });\n }\n acc\n }\n }\n \"atom\" => {\n let atom = tup.entries[2].atom().unwrap();\n ast::Expr::Literal(ast::Literal::Atom(gen.next(), atom))\n }\n \"nil\" => ast::Expr::Nil(ast::Nil(span, gen.next())),\n \"tuple\" => ast::Expr::Tuple(ast::Tuple {\n span,\n id: gen.next(),\n elements: tup.entries[2]\n .list_iter()\n .unwrap()\n .map(|e| lower_expr(gen, e))\n .collect(),\n }),\n \"cons\" => {\n let head = lower_expr(gen, &tup.entries[2]);\n let tail = lower_expr(gen, &tup.entries[3]);\n ast::Expr::Cons(ast::Cons {\n span,\n id: gen.next(),\n head: Box::new(head),\n tail: Box::new(tail),\n })\n }\n \"map\" => {\n let tup_len = tup.entries.len();\n\n let fields = tup.entries[tup_len - 1]\n .list_iter()\n .unwrap()\n .map(|field| {\n let field_tup = field.tuple().unwrap();\n let span = field_tup.span;\n\n let op_name = field_tup.entries[0].atom().unwrap().as_str();\n\n let key = lower_expr(gen, &field_tup.entries[2]);\n let value = lower_expr(gen, &field_tup.entries[3]);\n\n match &*op_name {\n \"map_field_exact\" => ast::MapField::Exact {\n span,\n id: gen.next(),\n key,\n value,\n },\n \"map_field_assoc\" => ast::MapField::Assoc {\n span,\n id: gen.next(),\n key,\n value,\n },\n r => panic!(\"{}\", r),\n }\n })\n .collect();\n\n match tup_len {\n 3 => ast::Expr::Map(ast::Map {\n span,\n id: gen.next(),\n fields,\n }),\n 4 => ast::Expr::MapUpdate(ast::MapUpdate {\n span,\n id: gen.next(),\n map: Box::new(lower_expr(gen, &tup.entries[2])),\n updates: fields,\n }),\n _ => panic!(),\n }\n }\n \"case\" => {\n let expr = lower_expr(gen, &tup.entries[2]);\n let clauses = tup.entries[3]\n .list_iter()\n .unwrap()\n .map(|c| lower_clause(gen, c))\n .collect();\n ast::Expr::Case(ast::Case {\n span,\n id: gen.next(),\n expr: Box::new(expr),\n clauses,\n })\n }\n \"call\" => {\n let target = lower_expr(gen, &tup.entries[2]);\n\n let args = tup.entries[3]\n .list_iter()\n .unwrap()\n .map(|v| lower_expr(gen, v))\n .collect();\n\n ast::Expr::Apply(ast::Apply {\n span,\n id: gen.next(),\n callee: Box::new(target),\n args,\n })\n }\n \"remote\" => ast::Expr::Remote(ast::Remote {\n span,\n id: gen.next(),\n module: Box::new(lower_expr(gen, &tup.entries[2])),\n function: Box::new(lower_expr(gen, &tup.entries[3])),\n }),\n \"bin\" => {\n let elements = tup.entries[2]\n .list_iter()\n .unwrap()\n .map(|elem| {\n let tup = elem.tuple().unwrap();\n assert!(tup.entries[0].atom().unwrap().as_str() == \"bin_element\");\n\n let bit_expr = lower_expr(gen, &tup.entries[2]);\n\n let bit_size_v = &tup.entries[3];\n let bit_size = if let Some(atom) = bit_size_v.atom() {\n assert!(&*atom.as_str() == \"default\");\n None\n } else {\n Some(lower_expr(gen, bit_size_v))\n };\n\n let bit_type_v = &tup.entries[4];\n let specifier = if let Some(atom) = bit_type_v.atom() {\n assert!(&*atom.as_str() == \"default\");\n None\n } else {\n let list: Vec<_> = bit_type_v\n .list_iter()\n .unwrap()\n .map(|item| {\n if let Some(atom) = item.atom() {\n ast::BitType::Name(span, gen.next(), atom)\n } else {\n unimplemented!()\n }\n })\n .collect();\n Some(crate::parser::binary::specifier_from_parsed(&list, bit_size.is_some()).unwrap())\n };\n\n ast::BinaryElement {\n span: elem.span(),\n id: gen.next(),\n bit_expr,\n bit_size,\n specifier,\n }\n })\n .collect();\n ast::Expr::Binary(ast::Binary {\n span,\n id: gen.next(),\n elements,\n })\n }\n \"fun\" => {\n // We expect either a M:F/A or a function definition.\n let inner = tup.entries[2].tuple().unwrap();\n let inner_name = inner.entries[0].atom().unwrap();\n match &*inner_name.as_str() {\n \"function\" => {\n let module = atom(&inner.entries[1]);\n let function = atom(&inner.entries[2]);\n let arity = integer(&inner.entries[3]);\n ast::Expr::FunctionName(ast::FunctionName::Resolved(\n ast::ResolvedFunctionName {\n span: inner.span,\n id: gen.next(),\n module,\n function,\n arity: arity.integer.to_usize().unwrap(),\n },\n ))\n }\n \"clauses\" => {\n let clauses: Vec<_> = inner.entries[1]\n .list_iter()\n .unwrap()\n .map(|v| lower_function_clause(gen, v))\n .collect();\n let arity = clauses[0].params.len();\n for clause in clauses.iter() {\n assert!(clause.params.len() == arity);\n }\n ast::Expr::Fun(ast::Function::Unnamed(ast::Lambda {\n span: inner.span,\n id: gen.next(),\n arity: arity,\n clauses,\n }))\n }\n v => unimplemented!(\"{}\", v),\n }\n }\n \"match\" => {\n let pattern = lower_expr(gen, &tup.entries[2]);\n let expr = lower_expr(gen, &tup.entries[3]);\n ast::Expr::Match(ast::Match {\n span,\n id: gen.next(),\n pattern: Box::new(pattern),\n expr: Box::new(expr),\n })\n }\n \"char\" => {\n let int = tup.entries[2].integer().unwrap();\n ast::Expr::Literal(ast::Literal::Char(\n span,\n gen.next(),\n int.integer.to_u32().unwrap().try_into().unwrap(),\n ))\n }\n \"float\" => {\n let float = tup.entries[2].float().unwrap();\n ast::Expr::Literal(ast::Literal::Float(\n span,\n gen.next(),\n Float::new(float.float).unwrap(),\n ))\n }\n \"catch\" => ast::Expr::Catch(ast::Catch {\n span,\n id: gen.next(),\n expr: Box::new(lower_expr(gen, &tup.entries[2])),\n }),\n \"generate\" => ast::Expr::Generator(ast::Generator {\n span,\n id: gen.next(),\n pattern: Box::new(lower_expr(gen, &tup.entries[2])),\n expr: Box::new(lower_expr(gen, &tup.entries[3])),\n }),\n \"lc\" => ast::Expr::ListComprehension(ast::ListComprehension {\n span,\n id: gen.next(),\n body: Box::new(lower_expr(gen, &tup.entries[2])),\n qualifiers: tup.entries[3]\n .list_iter()\n .unwrap()\n .map(|v| lower_expr(gen, v))\n .collect(),\n }),\n \"receive\" => {\n let mut clauses = Vec::new();\n let after = None;\n for clause in tup.entries[2].list_iter().unwrap() {\n let clause_tup = clause.tuple().unwrap();\n match &*clause_tup.entries[0].atom().unwrap().as_str() {\n \"clause\" => {\n let mut arg_iter = clause_tup.entries[2].list_iter().unwrap();\n let arg = arg_iter.next().unwrap();\n assert!(arg_iter.next().is_none());\n\n let pattern = lower_expr(gen, arg);\n let guard = lower_guards(gen, &clause_tup.entries[3]);\n let body = lower_body(gen, &clause_tup.entries[4]);\n\n clauses.push(ast::Clause {\n span: clause_tup.span,\n id: gen.next(),\n pattern,\n guard: guard,\n body,\n });\n }\n _ => unimplemented!(),\n }\n }\n ast::Expr::Receive(ast::Receive {\n span,\n id: gen.next(),\n clauses: if clauses.len() == 0 {\n None\n } else {\n Some(clauses)\n },\n after: after,\n })\n }\n \"block\" => {\n let body = lower_body(gen, &tup.entries[2]);\n ast::Expr::Begin(ast::Begin {\n span,\n id: gen.next(),\n body,\n })\n }\n \"if\" => {\n let clauses = tup.entries[2]\n .list_iter()\n .unwrap()\n .map(|v| lower_if_clause(gen, v))\n .collect();\n ast::Expr::If(ast::If {\n span,\n id: gen.next(),\n clauses,\n })\n }\n \"record\" => match tup.entries.len() {\n 4 => {\n let name = tup.entries[2].atom().unwrap();\n let fields = tup.entries[3]\n .list_iter()\n .unwrap()\n .map(|v| lower_record_field(gen, v))\n .collect();\n ast::Expr::Record(ast::Record {\n span,\n id: gen.next(),\n name,\n fields,\n })\n }\n 5 => {\n let old = lower_expr(gen, &tup.entries[2]);\n let name = tup.entries[3].atom().unwrap();\n let fields = tup.entries[4]\n .list_iter()\n .unwrap()\n .map(|v| lower_record_field(gen, v))\n .collect();\n ast::Expr::RecordUpdate(ast::RecordUpdate {\n span,\n id: gen.next(),\n record: Box::new(old),\n name,\n updates: fields,\n })\n }\n _ => unimplemented!(),\n },\n \"try\" => {\n let exprs = lower_body(gen, &tup.entries[2]);\n let clauses: Vec<_> = tup.entries[3]\n .list_iter()\n .unwrap()\n .map(|v| lower_clause(gen, v))\n .collect();\n let catch_clauses: Vec<_> = tup.entries[4]\n .list_iter()\n .unwrap()\n .map(|v| lower_try_clause(gen, v))\n .collect();\n let after = lower_body(gen, &tup.entries[5]);\n ast::Expr::Try(ast::Try {\n span,\n id: gen.next(),\n exprs,\n clauses: if clauses.len() == 0 {\n None\n } else {\n Some(clauses)\n },\n catch_clauses: if catch_clauses.len() == 0 {\n None\n } else {\n Some(catch_clauses)\n },\n after: if after.len() == 0 { None } else { Some(after) },\n })\n }\n v => unimplemented!(\"{}\", v),\n }\n}\n\nfn atom(item: &aast::Item) -> Ident {\n let tup = item.tuple().unwrap();\n assert!(&*tup.entries[0].atom().unwrap().as_str() == \"atom\");\n tup.entries[2].atom().unwrap()\n}\n\nfn integer(item: &aast::Item) -> &aast::Int {\n let tup = item.tuple().unwrap();\n assert!(&*tup.entries[0].atom().unwrap().as_str() == \"integer\");\n tup.entries[2].integer().unwrap()\n}\n\n#[cfg(test)]\nmod test {\n use libeir_diagnostics::{CodeMap, Diagnostic, ToDiagnostic};\n use libeir_util_parse::{error_tee, Errors, Parse, Parser};\n use libeir_util_parse_listing::ast::Root;\n use libeir_util_parse_listing::parser::ParseError;\n use std::path::Path;\n use std::sync::Arc;\n\n use crate::LowerError;\n\n enum ParseOrLowerError {\n Parse(ParseError),\n Lower(LowerError),\n }\n impl ToDiagnostic for ParseOrLowerError {\n fn to_diagnostic(&self) -> Diagnostic {\n match self {\n ParseOrLowerError::Parse(err) => err.to_diagnostic(),\n ParseOrLowerError::Lower(err) => err.to_diagnostic(),\n }\n }\n }\n impl From for ParseOrLowerError {\n fn from(e: ParseError) -> Self {\n Self::Parse(e)\n }\n }\n impl From for ParseOrLowerError {\n fn from(e: LowerError) -> Self {\n Self::Lower(e)\n }\n }\n\n fn parse(input: S) -> T\n where\n T: Parse,\n S: AsRef,\n {\n let parser = Parser::new((), Arc::new(CodeMap::new()));\n\n let mut errors = Errors::new();\n\n match parser.parse_string::(&mut errors, input) {\n Ok(ast) => return ast,\n Err(()) => {\n errors.print(&parser.codemap);\n panic!()\n }\n };\n }\n\n fn parse_file(path: S) -> T\n where\n T: Parse,\n S: AsRef,\n {\n let parser = Parser::new((), Arc::new(CodeMap::new()));\n\n let mut errors = Errors::new();\n\n match parser.parse_file::(&mut errors, path) {\n Ok(ast) => return ast,\n Err(()) => {\n errors.print(&parser.codemap);\n panic!()\n }\n };\n }\n\n #[test]\n fn basic_ast() {\n let root: Root = parse(\n \"\n{attribute,1,file,{\\\"woo.erl\\\",1}}.\n{attribute,1,module,woo}.\n{attribute,3,export,[{foo,2},{bar,1},{barr,1}]}.\n{function,5,foo,2,\n [{clause,5,\n [{var,5,'A'},{var,5,'B'}],\n [],\n [{op,5,'+',{var,5,'A'},{var,5,'B'}}]}]}.\n{function,7,bar,1,\n [{clause,7,[{integer,7,1}],[],[{integer,7,2}]},\n {clause,8,[{integer,8,2}],[],[{integer,8,4}]},\n {clause,9,[{var,9,'N'}],[],[{var,9,'N'}]}]}.\n{function,11,barr,1,\n [{clause,11,[{integer,11,1}],[],[{integer,11,2}]},\n {clause,12,[{integer,12,2}],[],[{integer,12,4}]}]}.\n{function,14,binary,0,\n [{clause,14,[],[],\n [{bin,14,[{bin_element,14,{string,14,\\\"woo\\\"},default,default}]}]}]}.\n{function,16,string,0,[{clause,16,[],[],[{string,16,\\\"woo\\\"}]}]}.\n{eof,17}.\n\",\n );\n super::lower(&root);\n }\n\n #[test]\n fn maps() {\n let root: Root = parse_file(\"../test_data/maps.abstr\");\n super::lower(&root);\n }\n\n #[test]\n fn match_suite() {\n let parser = Parser::new((), Arc::new(CodeMap::new()));\n\n let mut errors: Errors = Errors::new();\n let res = error_tee(&mut errors, |mut errors| {\n match parser.parse_file::(\n &mut errors.make_into_adapter(),\n \"../test_data/match_SUITE.abstr\",\n ) {\n Ok(ast) => {\n let module = super::lower(&ast);\n crate::lower_module(\n &mut errors.make_into_adapter(),\n parser.codemap.clone(),\n &module,\n )\n }\n Err(()) => Err(()),\n }\n });\n\n match res {\n Ok(_res) => (),\n Err(()) => {\n errors.print(&parser.codemap);\n panic!();\n }\n }\n }\n}\n" }, { "path": "libeir_syntax_erl/src/abstr/mod.rs", "content": "mod lower;\npub use lower::lower;\n\n#[cfg(test)]\nmod test {}\n" }, { "path": "libeir_syntax_erl/src/evaluator.rs", "content": "use std::cmp::Ordering;\nuse std::collections::BTreeMap;\nuse std::hash::{Hash, Hasher};\n\nuse snafu::{ResultExt, Snafu};\n\nuse crate::lexer::symbols;\nuse crate::parser::ast::{BinaryOp, Expr, Literal, UnaryOp};\n\nuse libeir_diagnostics::{Diagnostic, Label, SourceSpan, ToDiagnostic};\nuse libeir_intern::{Ident, Symbol};\nuse libeir_ir::ToPrimitive;\nuse libeir_util_number::{Float, Integer, Number};\n\n#[derive(Debug, Snafu)]\npub enum EvalError {\n #[snafu(display(\"invalid const expression\"))]\n InvalidConstExpression { span: SourceSpan },\n\n #[snafu(display(\"floating point error\"))]\n FloatError {\n source: libeir_util_number::FloatError,\n span: SourceSpan,\n },\n\n #[snafu(display(\"integer division requires both operands to be integers\"))]\n InvalidDivOperand { span: SourceSpan },\n\n #[snafu(display(\"expression evaluated to division by zero\"))]\n DivisionByZero { span: SourceSpan },\n\n #[snafu(display(\"bitwise operators requires all operands to be integers\"))]\n InvalidBitwiseOperand { span: SourceSpan },\n\n #[snafu(display(\"attempted too large bitshift\"))]\n TooLargeShift { span: SourceSpan },\n\n #[snafu(display(\"no record with name\"))]\n NoRecord { span: SourceSpan },\n\n #[snafu(display(\"field doesn't exist in record\"))]\n NoRecordField { span: SourceSpan },\n}\n\nimpl ToDiagnostic for EvalError {\n fn to_diagnostic(&self) -> Diagnostic {\n let msg = self.to_string();\n match self {\n EvalError::InvalidConstExpression { span } => Diagnostic::error()\n .with_message(msg)\n .with_labels(vec![Label::primary(span.source_id(), *span)\n .with_message(\"expression not evaluable to constant\")]),\n EvalError::FloatError { span, .. } => Diagnostic::error()\n .with_message(msg)\n .with_labels(vec![Label::primary(span.source_id(), *span)]),\n EvalError::InvalidDivOperand { span } => Diagnostic::error()\n .with_message(msg)\n .with_labels(vec![Label::primary(span.source_id(), *span)]),\n EvalError::DivisionByZero { span } => Diagnostic::error()\n .with_message(msg)\n .with_labels(vec![Label::primary(span.source_id(), *span)]),\n EvalError::InvalidBitwiseOperand { span } => Diagnostic::error()\n .with_message(msg)\n .with_labels(vec![Label::primary(span.source_id(), *span)]),\n EvalError::TooLargeShift { span } => Diagnostic::error()\n .with_message(msg)\n .with_labels(vec![Label::primary(span.source_id(), *span)]),\n EvalError::NoRecord { span } => Diagnostic::error()\n .with_message(msg)\n .with_labels(vec![Label::primary(span.source_id(), *span)]),\n EvalError::NoRecordField { span } => Diagnostic::error()\n .with_message(msg)\n .with_labels(vec![Label::primary(span.source_id(), *span)]),\n }\n }\n}\n\n#[derive(Clone, Hash)]\npub enum Term {\n Cons(Box, Box),\n Nil,\n Map(BTreeMap),\n Tuple(Vec),\n Atom(Symbol),\n Number(Number),\n}\n\nimpl PartialEq for Term {\n fn eq(&self, other: &Term) -> bool {\n self.equals(other, false)\n }\n}\nimpl Eq for Term {}\n\nimpl Ord for Term {\n // number < atom < reference < fun < port < pid < tuple < map < nil < list < bit string\n fn cmp(&self, other: &Term) -> Ordering {\n match (self, other) {\n (Term::Number(l), Term::Number(r)) => l.cmp(r),\n (Term::Number(_), _) => Ordering::Less,\n\n (Term::Atom(_), Term::Number(_)) => Ordering::Greater,\n (Term::Atom(l), Term::Atom(r)) => l.cmp(r),\n (Term::Atom(_), _) => Ordering::Less,\n\n (Term::Tuple(_), Term::Number(_) | Term::Atom(_)) => Ordering::Greater,\n (Term::Tuple(l), Term::Tuple(r)) => l.cmp(r),\n (Term::Tuple(_), _) => Ordering::Less,\n\n (Term::Map(_), Term::Number(_) | Term::Atom(_) | Term::Tuple(_)) => Ordering::Greater,\n (Term::Map(l), Term::Map(r)) => l.cmp(r),\n (Term::Map(_), _) => Ordering::Less,\n\n (Term::Nil, Term::Number(_) | Term::Atom(_) | Term::Tuple(_) | Term::Map(_)) => {\n Ordering::Greater\n }\n (Term::Nil, Term::Nil) => Ordering::Equal,\n (Term::Nil, _) => Ordering::Less,\n\n (\n Term::Cons(_, _),\n Term::Number(_) | Term::Atom(_) | Term::Tuple(_) | Term::Map(_) | Term::Nil,\n ) => Ordering::Greater,\n (Term::Cons(lh, lt), Term::Cons(rh, rt)) => (lh, lt).cmp(&(rh, rt)),\n (Term::Cons(_, _), _) => Ordering::Less,\n }\n }\n}\nimpl PartialOrd for Term {\n fn partial_cmp(&self, other: &Term) -> Option {\n Some(self.cmp(other))\n }\n}\n\nimpl From for Term {\n fn from(num: Number) -> Term {\n Term::Number(num)\n }\n}\nimpl From for Term {\n fn from(cond: bool) -> Term {\n if cond {\n Term::Atom(symbols::True)\n } else {\n Term::Atom(symbols::False)\n }\n }\n}\n\nimpl Term {\n pub fn equals(&self, rhs: &Term, exact: bool) -> bool {\n match (self, rhs) {\n (Term::Atom(l), Term::Atom(r)) => l == r,\n (Term::Number(l), Term::Number(r)) => l.equals(r, exact),\n (Term::Tuple(l), Term::Tuple(r)) => l == r,\n (Term::Map(l), Term::Map(r)) => l == r,\n (Term::Nil, Term::Nil) => true,\n (Term::Cons(lh, lt), Term::Cons(rh, rt)) => lh == rh && lt == rt,\n _ => false,\n }\n }\n}\n\npub enum ResolveRecordIndexError {\n NoRecord,\n NoField,\n}\n\npub fn eval_expr(\n expr: &Expr,\n resolve_record_index: Option<&dyn Fn(Ident, Ident) -> Result>,\n) -> Result {\n let span = expr.span();\n let invalid_expr = InvalidConstExpression { span };\n let float_err = FloatError { span };\n\n let res = match expr {\n Expr::Literal(lit) => match lit {\n Literal::Integer(_span, _id, int) => Term::Number(int.clone().into()),\n Literal::Float(_span, _id, float) => Term::Number((*float).into()),\n Literal::Atom(_id, atom) => Term::Atom(atom.name),\n\n lit => return Err(EvalError::InvalidConstExpression { span: lit.span() }),\n },\n\n Expr::Nil(_) => Term::Nil,\n Expr::Cons(cons) => {\n let head = eval_expr(&cons.head, resolve_record_index)?;\n let tail = eval_expr(&cons.tail, resolve_record_index)?;\n Term::Cons(Box::new(head), Box::new(tail))\n }\n\n Expr::Tuple(tup) => Term::Tuple(\n tup.elements\n .iter()\n .map(|e| eval_expr(e, resolve_record_index))\n .collect::, _>>()?,\n ),\n Expr::Map(_) => unimplemented!(),\n Expr::Binary(_) => unimplemented!(),\n Expr::Record(_) => unimplemented!(),\n Expr::RecordIndex(rec_idx) if resolve_record_index.is_some() => {\n match resolve_record_index.unwrap()(rec_idx.name, rec_idx.field) {\n Ok(index) => Term::Number(index.into()),\n Err(ResolveRecordIndexError::NoRecord) => {\n Err(EvalError::NoRecord { span: rec_idx.span })?\n }\n Err(ResolveRecordIndexError::NoField) => {\n Err(EvalError::NoRecordField { span: rec_idx.span })?\n }\n }\n }\n\n Expr::BinaryExpr(bin_expr) => {\n use BinaryOp as B;\n\n let lhs = eval_expr(&bin_expr.lhs, resolve_record_index)?;\n let rhs = eval_expr(&bin_expr.rhs, resolve_record_index)?;\n\n match (bin_expr.op, lhs, rhs) {\n (B::Add, Term::Number(l), Term::Number(r)) => (&l + &r).context(float_err)?.into(),\n (B::Sub, Term::Number(l), Term::Number(r)) => (&l - &r).context(float_err)?.into(),\n (B::Multiply, Term::Number(l), Term::Number(r)) => {\n (&l * &r).context(float_err)?.into()\n }\n (B::Divide, Term::Number(l), Term::Number(r)) => {\n if r.is_zero() {\n Err(EvalError::DivisionByZero { span })?\n }\n (&l / &r).context(float_err)?.into()\n }\n\n (B::Div, Term::Number(Number::Integer(l)), Term::Number(Number::Integer(r))) => {\n if r.is_zero() {\n Err(EvalError::DivisionByZero { span })?\n }\n Number::Integer((l / &r).unwrap()).into()\n }\n (B::Div, _, _) => Err(EvalError::InvalidDivOperand { span })?,\n\n (B::Bor, Term::Number(Number::Integer(l)), Term::Number(Number::Integer(r))) => {\n Number::Integer(l | &r).into()\n }\n (B::Band, Term::Number(Number::Integer(l)), Term::Number(Number::Integer(r))) => {\n Number::Integer(l & &r).into()\n }\n (B::Bxor, Term::Number(Number::Integer(l)), Term::Number(Number::Integer(r))) => {\n Number::Integer(l ^ &r).into()\n }\n (B::Bsl, Term::Number(Number::Integer(l)), Term::Number(Number::Integer(r))) => {\n let shift = r.to_u32().ok_or(EvalError::TooLargeShift { span })?;\n Number::Integer(l << shift).into()\n }\n (B::Bsr, Term::Number(Number::Integer(l)), Term::Number(Number::Integer(r))) => {\n let shift = r.to_u32().ok_or(EvalError::TooLargeShift { span })?;\n Number::Integer(l >> shift).into()\n }\n (B::Bor | B::Band | B::Bxor | B::Bsl | B::Bsr, _, _) => {\n Err(EvalError::InvalidBitwiseOperand { span })?\n }\n\n (B::Lt, l, r) => (l < r).into(),\n (B::Lte, l, r) => (l <= r).into(),\n (B::Gt, l, r) => (l > r).into(),\n (B::Gte, l, r) => (l >= r).into(),\n\n (B::Equal, l, r) => l.equals(&r, false).into(),\n (B::NotEqual, l, r) => (!l.equals(&r, false)).into(),\n (B::StrictEqual, l, r) => l.equals(&r, true).into(),\n (B::StrictNotEqual, l, r) => (!l.equals(&r, true)).into(),\n\n (B::Append, _, _) => unimplemented!(),\n (B::Remove, _, _) => unimplemented!(),\n\n _ => Err(EvalError::InvalidConstExpression { span })?,\n }\n }\n\n Expr::UnaryExpr(un_expr) => {\n use UnaryOp as U;\n\n let operand = eval_expr(&un_expr.operand, resolve_record_index)?;\n\n match (un_expr.op, operand) {\n (UnaryOp::Plus, Term::Number(o)) => o.plus().into(),\n (UnaryOp::Minus, Term::Number(o)) => (-o).into(),\n\n (UnaryOp::Bnot, Term::Number(Number::Integer(i))) => Number::Integer(!&i).into(),\n (UnaryOp::Bnot, _) => Err(EvalError::InvalidBitwiseOperand { span })?,\n\n (UnaryOp::Not, Term::Atom(sym)) if sym == symbols::True => false.into(),\n (UnaryOp::Not, Term::Atom(sym)) if sym == symbols::False => true.into(),\n\n //(UnaryOp::Not, Term::Atom)\n _ => Err(EvalError::InvalidConstExpression { span })?,\n }\n }\n\n _ => Err(EvalError::InvalidConstExpression { span })?,\n };\n Ok(res)\n}\n" }, { "path": "libeir_syntax_erl/src/lexer/errors.rs", "content": "use std::hash::{Hash, Hasher};\n\nuse snafu::Snafu;\n\nuse libeir_diagnostics::{Diagnostic, Label, SourceIndex, SourceSpan, ToDiagnostic};\n\nuse super::token::{Token, TokenType};\nuse crate::util::escape_stm::EscapeStmError;\n\n/// An enum of possible errors that can occur during lexing.\n#[derive(Clone, Debug, PartialEq, Snafu)]\npub enum LexicalError {\n #[snafu(display(\"{}\", reason))]\n InvalidFloat { span: SourceSpan, reason: String },\n\n #[snafu(display(\"{}\", reason))]\n InvalidRadix { span: SourceSpan, reason: String },\n\n /// Occurs when a string literal is not closed (e.g. `\"this is an unclosed string`)\n /// It is also implicit that hitting this error means we've reached EOF, as we'll scan the\n /// entire input looking for the closing quote\n #[snafu(display(\"Unclosed string literal\"))]\n UnclosedString { span: SourceSpan },\n\n /// Like UnclosedStringLiteral, but for quoted atoms\n #[snafu(display(\"Unclosed atom literal\"))]\n UnclosedAtom { span: SourceSpan },\n\n #[snafu(display(\"{}\", source))]\n EscapeError { source: EscapeStmError },\n\n /// Occurs when we encounter an unexpected character\n #[snafu(display(\"Encountered unexpected character '{}'\", found))]\n UnexpectedCharacter { start: SourceIndex, found: char },\n}\nimpl Hash for LexicalError {\n fn hash(&self, state: &mut H) {\n let id = match *self {\n LexicalError::InvalidFloat { .. } => 0,\n LexicalError::InvalidRadix { .. } => 1,\n LexicalError::UnclosedString { .. } => 2,\n LexicalError::UnclosedAtom { .. } => 3,\n LexicalError::EscapeError { .. } => 4,\n LexicalError::UnexpectedCharacter { .. } => 5,\n };\n id.hash(state);\n }\n}\nimpl ToDiagnostic for LexicalError {\n fn to_diagnostic(&self) -> Diagnostic {\n let span = self.span();\n let msg = self.to_string();\n match self {\n LexicalError::InvalidFloat { .. } => Diagnostic::error()\n .with_message(\"invalid float literal\")\n .with_labels(vec![\n Label::primary(span.source_id(), span).with_message(msg)\n ]),\n LexicalError::InvalidRadix { .. } => Diagnostic::error()\n .with_message(\"invalid radix value for integer literal\")\n .with_labels(vec![\n Label::primary(span.source_id(), span).with_message(msg)\n ]),\n LexicalError::EscapeError { source } => source.to_diagnostic(),\n LexicalError::UnexpectedCharacter { .. } => Diagnostic::error()\n .with_message(\"unexpected character\")\n .with_labels(vec![\n Label::primary(span.source_id(), span).with_message(msg)\n ]),\n _ => Diagnostic::error()\n .with_message(msg)\n .with_labels(vec![Label::primary(span.source_id(), span)]),\n }\n }\n}\nimpl LexicalError {\n /// Return the source span for this error\n pub fn span(&self) -> SourceSpan {\n match self {\n LexicalError::InvalidFloat { span, .. } => *span,\n LexicalError::InvalidRadix { span, .. } => *span,\n LexicalError::UnclosedString { span, .. } => *span,\n LexicalError::UnclosedAtom { span, .. } => *span,\n LexicalError::EscapeError { source } => source.span(),\n LexicalError::UnexpectedCharacter { start, .. } => SourceSpan::new(*start, *start),\n }\n }\n}\n\n// Produced when converting from LexicalToken to {Atom,Ident,String,Symbol}Token\n#[derive(Debug, Clone)]\npub struct TokenConvertError {\n pub span: SourceSpan,\n pub token: Token,\n pub expected: TokenType,\n}\n" }, { "path": "libeir_syntax_erl/src/lexer/lexer.rs", "content": "use std::ops::Range;\nuse std::str::FromStr;\n\nuse libeir_diagnostics::{ByteOffset, SourceIndex, SourceSpan};\n\nuse libeir_util_number::{Float, FloatError, Integer, ToPrimitive};\nuse libeir_util_parse::{Scanner, Source};\n\nuse crate::util::escape_stm::{EscapeStm, EscapeStmAction};\n\nuse super::errors::LexicalError;\nuse super::token::*;\nuse super::{Lexed, Symbol};\n\nmacro_rules! pop {\n ($lex:ident) => {{\n $lex.skip();\n }};\n ($lex:ident, $code:expr) => {{\n $lex.skip();\n $code\n }};\n}\n\nmacro_rules! pop2 {\n ($lex:ident) => {{\n $lex.skip();\n $lex.skip();\n }};\n ($lex:ident, $code:expr) => {{\n $lex.skip();\n $lex.skip();\n $code\n }};\n}\n\nmacro_rules! pop3 {\n ($lex:ident) => {{\n $lex.skip();\n $lex.skip();\n $lex.skip()\n }};\n ($lex:ident, $code:expr) => {{\n $lex.skip();\n $lex.skip();\n $lex.skip();\n $code\n }};\n}\n\n/// The lexer that is used to perform lexical analysis on the Erlang grammar. The lexer implements\n/// the `Iterator` trait, so in order to retrieve the tokens, you simply have to iterate over it.\n///\n/// # Errors\n///\n/// Because the lexer is implemented as an iterator over tokens, this means that you can continue\n/// to get tokens even if a lexical error occurs. The lexer will attempt to recover from an error\n/// by injecting tokens it expects.\n///\n/// If an error is unrecoverable, the lexer will continue to produce tokens, but there is no\n/// guarantee that parsing them will produce meaningful results, it is primarily to assist in\n/// gathering as many errors as possible.\npub struct Lexer {\n /// The scanner produces a sequence of chars + location, and can be controlled\n /// The location produces is a SourceIndex\n scanner: Scanner,\n\n /// Escape sequence state machine.\n escape: EscapeStm,\n\n /// The most recent token to be lexed.\n /// At the start and end, this should be Token::EOF\n token: Token,\n\n /// The position in the input where the current token starts\n /// At the start this will be the byte index of the beginning of the input\n token_start: SourceIndex,\n\n /// The position in the input where the current token ends\n /// At the start this will be the byte index of the beginning of the input\n token_end: SourceIndex,\n\n /// When we have reached true EOF, this gets set to true, and the only token\n /// produced after that point is Token::EOF, or None, depending on how you are\n /// consuming the lexer\n eof: bool,\n}\n\nimpl Lexer\nwhere\n S: Source,\n{\n /// Produces an instance of the lexer with the lexical analysis to be performed on the `input`\n /// string. Note that no lexical analysis occurs until the lexer has been iterated over.\n pub fn new(scanner: Scanner) -> Self {\n let start = scanner.start();\n let mut lexer = Lexer {\n scanner,\n escape: EscapeStm::new(),\n token: Token::EOF,\n token_start: start + ByteOffset(0),\n token_end: start + ByteOffset(0),\n eof: false,\n };\n lexer.advance();\n lexer\n }\n\n pub fn lex(&mut self) -> Option<::Item> {\n if self.eof && self.token == Token::EOF {\n return None;\n }\n\n let token = std::mem::replace(&mut self.token, Token::EOF);\n let result = if let Token::Error(err) = token {\n Some(Err(err))\n } else {\n Some(Ok(LexicalToken(\n self.token_start.clone(),\n token,\n self.token_end.clone(),\n )))\n };\n\n self.advance();\n\n result\n }\n\n fn advance(&mut self) {\n self.advance_start();\n self.token = self.tokenize();\n }\n\n #[inline]\n fn advance_start(&mut self) {\n let mut position: SourceIndex;\n loop {\n let (pos, c) = self.scanner.read();\n\n position = pos;\n\n if c == '\\0' {\n self.eof = true;\n return;\n }\n\n if c.is_whitespace() {\n self.scanner.advance();\n continue;\n }\n\n break;\n }\n\n self.token_start = position;\n }\n\n #[inline]\n fn pop(&mut self) -> char {\n let (pos, c) = self.scanner.pop();\n self.token_end = pos + ByteOffset::from_char_len(c);\n c\n }\n\n #[inline]\n fn peek(&mut self) -> char {\n let (_, c) = self.scanner.peek();\n c\n }\n\n #[inline]\n fn peek_next(&mut self) -> char {\n let (_, c) = self.scanner.peek_next();\n c\n }\n\n #[inline]\n fn read(&mut self) -> char {\n let (_, c) = self.scanner.read();\n c\n }\n\n #[inline]\n fn index(&mut self) -> SourceIndex {\n self.scanner.read().0\n }\n\n #[inline]\n fn skip(&mut self) {\n self.pop();\n }\n\n /// Get the span for the current token in `Source`.\n #[inline]\n pub fn span(&self) -> SourceSpan {\n SourceSpan::new(self.token_start, self.token_end)\n }\n\n /// Get a string slice of the current token.\n #[inline]\n fn slice(&self) -> &str {\n self.scanner.slice(self.span())\n }\n\n #[inline]\n fn slice_span(&self, span: impl Into>) -> &str {\n self.scanner.slice(span)\n }\n\n #[inline]\n fn skip_whitespace(&mut self) {\n let mut c: char;\n loop {\n c = self.read();\n\n if !c.is_whitespace() {\n break;\n }\n\n self.skip();\n }\n }\n\n fn tokenize(&mut self) -> Token {\n let c = self.read();\n\n if c == '%' {\n self.skip();\n return self.lex_comment();\n }\n\n if c == '\\0' {\n self.eof = true;\n return Token::EOF;\n }\n\n if c.is_whitespace() {\n self.skip_whitespace();\n }\n\n match self.read() {\n ',' => pop!(self, Token::Comma),\n ';' => pop!(self, Token::Semicolon),\n '_' => self.lex_identifier(),\n '0'..='9' => self.lex_number(),\n 'a'..='z' => self.lex_bare_atom(),\n 'A'..='Z' => self.lex_identifier(),\n '#' => pop!(self, Token::Pound),\n '*' => pop!(self, Token::Star),\n '!' => pop!(self, Token::Bang),\n '[' => pop!(self, Token::LBracket),\n ']' => pop!(self, Token::RBracket),\n '(' => pop!(self, Token::LParen),\n ')' => pop!(self, Token::RParen),\n '{' => pop!(self, Token::LBrace),\n '}' => pop!(self, Token::RBrace),\n '?' => match self.peek() {\n '?' => pop2!(self, Token::DoubleQuestion),\n _ => pop!(self, Token::Question),\n },\n '-' => match self.peek() {\n '-' => pop2!(self, Token::MinusMinus),\n '>' => pop2!(self, Token::RightStab),\n _ => pop!(self, Token::Minus),\n },\n '$' => {\n self.skip();\n if self.read() == '\\\\' {\n return match self.lex_escape_sequence() {\n Ok(num) => match std::char::from_u32(num as u32) {\n Some(c) => Token::Char(c),\n None => Token::Integer((num as i64).into()),\n },\n Err(err) => Token::Error(err),\n };\n }\n Token::Char(self.pop())\n }\n '\"' => self.lex_string(),\n '\\'' => match self.lex_string() {\n Token::String(s) => Token::Atom(s),\n other => other,\n },\n ':' => match self.peek() {\n '=' => pop2!(self, Token::ColonEqual),\n ':' => pop2!(self, Token::ColonColon),\n _ => pop!(self, Token::Colon),\n },\n '+' => {\n if self.peek() == '+' {\n pop2!(self, Token::PlusPlus)\n } else {\n pop!(self, Token::Plus)\n }\n }\n '/' => {\n if self.peek() == '=' {\n pop2!(self, Token::IsNotEqual)\n } else {\n pop!(self, Token::Slash)\n }\n }\n '=' => match self.peek() {\n '=' => pop2!(self, Token::IsEqual),\n '>' => pop2!(self, Token::RightArrow),\n '<' => pop2!(self, Token::IsLessThanOrEqual),\n ':' => {\n if self.peek_next() == '=' {\n pop3!(self, Token::IsExactlyEqual)\n } else {\n Token::Error(LexicalError::UnexpectedCharacter {\n start: self.span().start(),\n found: self.peek_next(),\n })\n }\n }\n '/' => {\n if self.peek_next() == '=' {\n pop3!(self, Token::IsExactlyNotEqual)\n } else {\n Token::Error(LexicalError::UnexpectedCharacter {\n start: self.span().start(),\n found: self.peek_next(),\n })\n }\n }\n _ => pop!(self, Token::Equals),\n },\n '<' => match self.peek() {\n '<' => pop2!(self, Token::BinaryStart),\n '-' => pop2!(self, Token::LeftStab),\n '=' => pop2!(self, Token::LeftArrow),\n _ => pop!(self, Token::IsLessThan),\n },\n '>' => match self.peek() {\n '>' => pop2!(self, Token::BinaryEnd),\n '=' => pop2!(self, Token::IsGreaterThanOrEqual),\n _ => pop!(self, Token::IsGreaterThan),\n },\n '|' => {\n if self.peek() == '|' {\n pop2!(self, Token::BarBar)\n } else {\n pop!(self, Token::Bar)\n }\n }\n '.' => {\n if self.peek() == '.' {\n if self.peek_next() == '.' {\n pop3!(self, Token::DotDotDot)\n } else {\n pop2!(self, Token::DotDot)\n }\n } else {\n pop!(self, Token::Dot)\n }\n }\n '\\\\' => {\n // Allow escaping newlines\n let c = self.peek();\n if c == '\\n' {\n pop2!(self);\n return self.tokenize();\n }\n return match self.lex_escape_sequence() {\n Ok(t) => Token::Integer((t as i64).into()),\n Err(e) => Token::Error(e),\n };\n }\n c => Token::Error(LexicalError::UnexpectedCharacter {\n start: self.span().start(),\n found: c,\n }),\n }\n }\n\n fn lex_comment(&mut self) -> Token {\n let mut c = self.read();\n // If there is another '%', then this is a regular comment line\n if c == '%' {\n self.skip();\n\n loop {\n c = self.read();\n\n if c == '\\n' {\n break;\n }\n\n if c == '\\0' {\n self.eof = true;\n break;\n }\n\n self.skip();\n }\n\n return Token::Comment;\n }\n\n // If no '%', then we should check for an Edoc tag, first skip all whitespace and advance\n // the token start\n self.skip_whitespace();\n\n // See if this is an Edoc tag\n c = self.read();\n if c == '@' {\n if self.peek().is_ascii_alphabetic() {\n self.skip();\n\n // Get the tag identifier\n self.lex_identifier();\n // Skip any leading whitespace in the value\n self.skip_whitespace();\n // Get value\n loop {\n c = self.read();\n\n if c == '\\n' {\n break;\n }\n\n if c == '\\0' {\n self.eof = true;\n break;\n }\n\n self.skip();\n }\n return Token::Edoc;\n }\n }\n\n // If we reach here, its a normal comment\n loop {\n if c == '\\n' {\n break;\n }\n\n if c == '\\0' {\n self.eof = true;\n break;\n }\n\n self.skip();\n c = self.read();\n }\n\n return Token::Comment;\n }\n\n #[inline]\n fn lex_escape_sequence(&mut self) -> Result {\n let start_idx = self.index();\n\n let mut c = self.read();\n debug_assert_eq!(c, '\\\\');\n\n self.escape.reset();\n\n let mut byte_idx = 0;\n\n loop {\n let c = self.read();\n let idx = start_idx + byte_idx;\n\n let c = if c == '\\0' { None } else { Some(c) };\n let res = self.escape.transition(c, idx);\n\n match res {\n Ok((action, result)) => {\n if let EscapeStmAction::Next = action {\n byte_idx += c.map(|c| c.len_utf8()).unwrap_or(0);\n self.pop();\n }\n\n if let Some(result) = result {\n return Ok(result.cp);\n }\n }\n Err(err) => Err(LexicalError::EscapeError { source: err })?,\n }\n }\n }\n\n #[inline]\n fn lex_string(&mut self) -> Token {\n let quote = self.pop();\n debug_assert!(quote == '\"' || quote == '\\'');\n let mut buf = None;\n loop {\n match self.read() {\n '\\\\' => match self.lex_escape_sequence() {\n Ok(_c) => (),\n Err(err) => return Token::Error(err),\n },\n '\\0' if quote == '\"' => {\n return Token::Error(LexicalError::UnclosedString { span: self.span() });\n }\n '\\0' if quote == '\\'' => {\n return Token::Error(LexicalError::UnclosedAtom { span: self.span() });\n }\n c if c == quote => {\n let span = self.span().shrink_front(ByteOffset(1));\n\n self.skip();\n self.advance_start();\n if self.read() == quote {\n self.skip();\n\n buf = Some(self.slice_span(span).to_string());\n continue;\n }\n\n let symbol = if let Some(mut buf) = buf {\n buf.push_str(self.slice_span(span));\n Symbol::intern(&buf)\n } else {\n Symbol::intern(self.slice_span(span))\n };\n\n let token = Token::String(symbol);\n return token;\n }\n _ => {\n self.skip();\n continue;\n }\n }\n }\n }\n\n #[inline]\n fn lex_identifier(&mut self) -> Token {\n let c = self.pop();\n debug_assert!(c == '_' || c.is_ascii_alphabetic());\n\n loop {\n match self.read() {\n '_' => self.skip(),\n '@' => self.skip(),\n '0'..='9' => self.skip(),\n c if c.is_alphabetic() => self.skip(),\n _ => break,\n }\n }\n Token::Ident(Symbol::intern(self.slice()))\n }\n\n #[inline]\n fn lex_bare_atom(&mut self) -> Token {\n let c = self.pop();\n debug_assert!(c.is_ascii_lowercase());\n\n loop {\n match self.read() {\n '_' => self.skip(),\n '@' => self.skip(),\n '0'..='9' => self.skip(),\n c if c.is_alphabetic() => self.skip(),\n _ => break,\n }\n }\n Token::from_bare_atom(self.slice())\n }\n\n #[inline]\n fn lex_digits(\n &mut self,\n radix: u32,\n allow_leading_underscore: bool,\n num: &mut String,\n ) -> Result<(), LexicalError> {\n let mut last_underscore = !allow_leading_underscore;\n let mut c = self.read();\n loop {\n match c {\n c if c.is_digit(radix) => {\n last_underscore = false;\n num.push(self.pop());\n }\n '_' if last_underscore => {\n return Err(LexicalError::UnexpectedCharacter {\n start: self.span().start(),\n found: c,\n });\n }\n '_' if self.peek().is_digit(radix) => {\n last_underscore = true;\n self.pop();\n }\n _ => break,\n }\n c = self.read();\n }\n\n Ok(())\n }\n\n #[inline]\n fn lex_number(&mut self) -> Token {\n let mut num = String::new();\n let mut c;\n\n // Expect the first character to be either a sign on digit\n c = self.read();\n debug_assert!(c == '-' || c == '+' || c.is_digit(10), \"got {}\", c);\n\n // If sign, consume it\n //\n // -10\n // ^\n //\n let negative = c == '-';\n if c == '-' || c == '+' {\n num.push(self.pop());\n }\n\n // Consume leading digits\n //\n // -10.0\n // ^^\n //\n // 10e10\n // ^^\n //\n if let Err(err) = self.lex_digits(10, false, &mut num) {\n return Token::Error(err);\n }\n\n // If we have a dot with a trailing number, we lex a float.\n // Otherwise we return consumed digits as an integer token.\n //\n // 10.0\n // ^ lex_float()\n //\n // fn() -> 10 + 10.\n // ^ return integer token\n //\n c = self.read();\n if c == '.' {\n if self.peek().is_digit(10) {\n // Pushes .\n num.push(self.pop());\n return self.lex_float(num, false);\n }\n return to_integer_literal(&num, 10);\n }\n\n // Consume exponent marker\n //\n // 10e10\n // ^ lex_float()\n //\n // 10e-10\n // ^^ lex_float()\n if c == 'e' || c == 'E' {\n let c2 = self.peek();\n if c2 == '-' || c2 == '+' {\n num.push(self.pop());\n num.push(self.pop());\n return self.lex_float(num, true);\n } else if c2.is_digit(10) {\n num.push(self.pop());\n return self.lex_float(num, true);\n }\n }\n\n // If followed by '#', the leading digits were the radix\n //\n // 10#16\n // ^ interpret leading as radix\n if c == '#' {\n self.skip();\n // Parse in the given radix\n let radix = match num[..].parse::() {\n Ok(r) => r,\n Err(e) => {\n return Token::Error(LexicalError::InvalidRadix {\n span: self.span(),\n reason: e.to_string(),\n });\n }\n };\n if radix >= 2 && radix <= 32 {\n let mut num = String::new();\n\n // If we have a sign, push that to the new integer string\n c = self.read();\n if c.is_digit(radix) {\n if negative {\n num.push('-');\n }\n }\n\n // Lex the digits themselves\n if let Err(err) = self.lex_digits(radix, false, &mut num) {\n return Token::Error(err);\n }\n\n return to_integer_literal(&num, radix);\n } else {\n Token::Error(LexicalError::InvalidRadix {\n span: self.span(),\n reason: \"invalid radix (must be in 2..32)\".to_string(),\n })\n }\n } else {\n to_integer_literal(&num, 10)\n }\n }\n\n // Called after consuming a number up to and including the '.'\n #[inline]\n fn lex_float(&mut self, num: String, seen_e: bool) -> Token {\n let mut num = num;\n\n let mut c = self.pop();\n debug_assert!(c.is_digit(10), \"got {}\", c);\n num.push(c);\n\n if let Err(err) = self.lex_digits(10, true, &mut num) {\n return Token::Error(err);\n }\n\n c = self.read();\n\n // If we've already seen e|E, then we're done\n if seen_e {\n return self.to_float_literal(num);\n }\n\n if c == 'E' || c == 'e' {\n num.push(self.pop());\n c = self.read();\n if c == '-' || c == '+' {\n num.push(self.pop());\n c = self.read();\n }\n\n if !c.is_digit(10) {\n return Token::Error(LexicalError::InvalidFloat {\n span: self.span(),\n reason: \"expected digits after scientific notation\".to_string(),\n });\n }\n\n if let Err(err) = self.lex_digits(10, false, &mut num) {\n return Token::Error(err);\n }\n }\n\n self.to_float_literal(num)\n }\n\n fn to_float_literal(&self, num: String) -> Token {\n let reason = match f64::from_str(&num) {\n Ok(f) => match Float::new(f) {\n Ok(f) => return Token::Float(f),\n Err(FloatError::Nan) => \"float cannot be NaN\".to_string(),\n Err(FloatError::Infinite) => \"float cannot be -Inf or Inf\".to_string(),\n },\n Err(e) => e.to_string(),\n };\n\n Token::Error(LexicalError::InvalidFloat {\n span: self.span(),\n reason,\n })\n }\n}\n\nimpl Iterator for Lexer\nwhere\n S: Source,\n{\n type Item = Lexed;\n\n fn next(&mut self) -> Option {\n let mut res = self.lex();\n loop {\n match res {\n Some(Ok(LexicalToken(_, Token::Comment, _))) => {\n res = self.lex();\n }\n _ => break,\n }\n }\n res\n }\n}\n\n// Converts the string literal into either a `i64` or arbitrary precision integer, preferring `i64`.\n//\n// This function panics if the literal is unparseable due to being invalid for the given radix,\n// or containing non-ASCII digits.\nfn to_integer_literal(literal: &str, radix: u32) -> Token {\n let int = Integer::from_string_radix(literal, radix).unwrap();\n Token::Integer(int)\n}\n\n#[cfg(test)]\nmod test {\n use libeir_diagnostics::{ByteIndex, CodeMap, SourceId, SourceIndex, SourceSpan};\n use libeir_util_number::Float;\n use libeir_util_parse::{FileMapSource, Scanner, Source};\n use pretty_assertions::assert_eq;\n\n use crate::lexer::*;\n\n macro_rules! symbol {\n ($sym:expr) => {\n Symbol::intern($sym)\n };\n }\n\n macro_rules! assert_lex(\n ($input:expr, $expected:expr) => ({\n let codemap = CodeMap::new();\n let id = codemap.add(\"nofile\", $input.to_string());\n let file = codemap.get(id).unwrap();\n let source = FileMapSource::new(file);\n let scanner = Scanner::new(source);\n let lexer = Lexer::new(scanner);\n let results = lexer.map(|result| {\n match result {\n Ok(LexicalToken(_start, token, _end)) => {\n Ok(token)\n }\n Err(err) => {\n Err(err)\n }\n }\n }).collect::>();\n assert_eq!(results, $expected(id));\n })\n );\n\n #[test]\n fn lex_symbols() {\n assert_lex!(\":\", |_| vec![Ok(Token::Colon)]);\n assert_lex!(\",\", |_| vec![Ok(Token::Comma)]);\n assert_lex!(\"=\", |_| vec![Ok(Token::Equals)]);\n }\n\n #[test]\n fn lex_comment() {\n assert_lex!(\"% this is a comment\", |_| vec![]);\n assert_lex!(\"% @author Paul\", |_| vec![Ok(Token::Edoc)]);\n }\n\n macro_rules! f {\n ($float:expr) => {\n Token::Float(Float::new($float).unwrap())\n };\n }\n\n #[test]\n fn lex_float_literal() {\n // With leading 0\n assert_lex!(\"0.0\", |_| vec![Ok(f!(0.0))]);\n assert_lex!(\"000051.0\", |_| vec![Ok(f!(51.0))]);\n assert_lex!(\"05162.0\", |_| vec![Ok(f!(5162.0))]);\n assert_lex!(\"099.0\", |_| vec![Ok(f!(99.0))]);\n assert_lex!(\"04624.51235\", |_| vec![Ok(f!(4624.51235))]);\n assert_lex!(\"0.987\", |_| vec![Ok(f!(0.987))]);\n assert_lex!(\"0.55e10\", |_| vec![Ok(f!(0.55e10))]);\n assert_lex!(\"612.0e61\", |_| vec![Ok(f!(612e61))]);\n assert_lex!(\"0.0e-1\", |_| vec![Ok(f!(0e-1))]);\n assert_lex!(\"41.0e+9\", |_| vec![Ok(f!(41e+9))]);\n\n // Without leading 0\n assert_lex!(\"5162.0\", |_| vec![Ok(f!(5162.0))]);\n assert_lex!(\"99.0\", |_| vec![Ok(f!(99.0))]);\n assert_lex!(\"4624.51235\", |_| vec![Ok(f!(4624.51235))]);\n assert_lex!(\"612.0e61\", |_| vec![Ok(f!(612e61))]);\n assert_lex!(\"41.0e+9\", |_| vec![Ok(f!(41e+9))]);\n\n // With leading negative sign\n assert_lex!(\"-700.5\", |_| vec![Ok(Token::Minus), Ok(f!(700.5))]);\n assert_lex!(\"-9.0e2\", |_| vec![Ok(Token::Minus), Ok(f!(9.0e2))]);\n assert_lex!(\"-0.5e1\", |_| vec![Ok(Token::Minus), Ok(f!(0.5e1))]);\n assert_lex!(\"-0.0\", |_| vec![Ok(Token::Minus), Ok(f!(0.0))]);\n\n // Underscores\n assert_lex!(\"12_3.45_6\", |_| vec![Ok(f!(123.456))]);\n assert_lex!(\"1e1_0\", |_| vec![Ok(f!(1e10))]);\n\n assert_lex!(\"123_.456\", |_| vec![\n Ok(Token::Integer(123.into())),\n Ok(Token::Ident(symbol!(\"_\"))),\n Ok(Token::Dot),\n Ok(Token::Integer(456.into())),\n ]);\n }\n\n #[test]\n fn lex_identifier_or_atom() {\n assert_lex!(\"_identifier\", |_| vec![Ok(Token::Ident(symbol!(\n \"_identifier\"\n )))]);\n assert_lex!(\"_Identifier\", |_| vec![Ok(Token::Ident(symbol!(\n \"_Identifier\"\n )))]);\n assert_lex!(\"identifier\", |_| vec![Ok(Token::Atom(symbol!(\n \"identifier\"\n )))]);\n assert_lex!(\"Identifier\", |_| vec![Ok(Token::Ident(symbol!(\n \"Identifier\"\n )))]);\n assert_lex!(\"z0123\", |_| vec![Ok(Token::Atom(symbol!(\"z0123\")))]);\n assert_lex!(\"i_d@e_t0123\", |_| vec![Ok(Token::Atom(symbol!(\n \"i_d@e_t0123\"\n )))]);\n }\n\n #[test]\n fn lex_integer_literal() {\n // Decimal\n assert_lex!(\"1\", |_| vec![Ok(Token::Integer(1.into()))]);\n assert_lex!(\"9624\", |_| vec![Ok(Token::Integer(9624.into()))]);\n assert_lex!(\"-1\", |_| vec![\n Ok(Token::Minus),\n Ok(Token::Integer(1.into()))\n ]);\n assert_lex!(\"-9624\", |_| vec![\n Ok(Token::Minus),\n Ok(Token::Integer(9624.into()))\n ]);\n\n // Hexadecimal\n assert_lex!(r#\"\\x00\"#, |_| vec![Ok(Token::Integer(0x0.into()))]);\n assert_lex!(r#\"\\x{1234FF}\"#, |_| vec![Ok(Token::Integer(\n 0x1234FF.into()\n ))]);\n assert_lex!(\"-16#0\", |_| vec![\n Ok(Token::Minus),\n Ok(Token::Integer(0x0.into()))\n ]);\n assert_lex!(\"-16#1234FF\", |_| vec![\n Ok(Token::Minus),\n Ok(Token::Integer(0x1234FF.into()))\n ]);\n\n // Octal\n assert_lex!(r#\"\\0\"#, |_| vec![Ok(Token::Integer(0.into()))]);\n assert_lex!(r#\"\\624\"#, |_| vec![Ok(Token::Integer(0o624.into()))]);\n assert_lex!(r#\"\\6244\"#, |_| vec![\n Ok(Token::Integer(0o624.into())),\n Ok(Token::Integer(4.into()))\n ]);\n\n // Octal integer literal followed by non-octal digits.\n assert_lex!(r#\"\\008\"#, |_| vec![\n Ok(Token::Integer(0.into())),\n Ok(Token::Integer(8.into()))\n ]);\n assert_lex!(r#\"\\1238\"#, |_| vec![\n Ok(Token::Integer(0o123.into())),\n Ok(Token::Integer(8.into()))\n ]);\n\n // Underscores\n assert_lex!(\"123_456\", |_| vec![Ok(Token::Integer(123456.into()))]);\n assert_lex!(\"123_456_789\", |_| vec![Ok(Token::Integer(\n 123456789.into()\n ))]);\n assert_lex!(\"1_2\", |_| vec![Ok(Token::Integer(12.into()))]);\n assert_lex!(\"16#123_abc\", |_| vec![Ok(Token::Integer(0x123abc.into()))]);\n assert_lex!(\"10#123_abc\", |_| vec![\n Ok(Token::Integer(123.into())),\n Ok(Token::Ident(Symbol::intern(\"_abc\")))\n ]);\n assert_lex!(\"1_6#abc\", |_| vec![Ok(Token::Integer(0xabc.into()))]);\n assert_lex!(\"1__0\", |_| vec![\n Ok(Token::Integer(1.into())),\n Ok(Token::Ident(Symbol::intern(\"__0\")))\n ]);\n assert_lex!(\"123_\", |_| vec![\n Ok(Token::Integer(123.into())),\n Ok(Token::Ident(Symbol::intern(\"_\"))),\n ]);\n assert_lex!(\"123__\", |_| vec![\n Ok(Token::Integer(123.into())),\n Ok(Token::Ident(Symbol::intern(\"__\"))),\n ]);\n }\n\n #[test]\n fn lex_string() {\n assert_lex!(r#\"\"this is a string\"\"#, |_| vec![Ok(Token::String(\n symbol!(\"this is a string\")\n ))]);\n\n assert_lex!(r#\"\"this is a string\"#, |source_id| vec![Err(\n LexicalError::UnclosedString {\n span: SourceSpan::new(\n SourceIndex::new(source_id, ByteIndex(0)),\n SourceIndex::new(source_id, ByteIndex(17))\n )\n }\n )]);\n }\n\n #[test]\n fn lex_whitespace() {\n assert_lex!(\" \\n \\t\", |_| vec![]);\n assert_lex!(\"\\r\\n\", |_| vec![]);\n }\n}\n" }, { "path": "libeir_syntax_erl/src/lexer/mod.rs", "content": "//! A fairly basic lexer for Erlang\n\npub use libeir_intern::symbol::{symbols, SYMBOL_TABLE};\npub use libeir_intern::symbol::{Ident, InternedString, LocalInternedString, Symbol};\n\nmod errors;\nmod lexer;\nmod token;\n\npub use self::errors::{LexicalError, TokenConvertError};\npub use self::lexer::Lexer;\npub use self::token::{AtomToken, IdentToken, IntegerToken, StringToken, SymbolToken, TokenType};\npub use self::token::{DelayedSubstitution, LexicalToken, Token};\n\n/// The type that serves as an `Item` for the lexer iterator.\npub type Lexed = Result;\n\n/// The result type produced by TryFrom\npub type TokenConvertResult = Result;\n" }, { "path": "libeir_syntax_erl/src/lexer/token.rs", "content": "use std::convert::TryFrom;\nuse std::fmt;\nuse std::hash::{Hash, Hasher};\nuse std::mem;\n\nuse libeir_diagnostics::{SourceIndex, SourceSpan};\nuse libeir_util_number::{Float, Integer, ToPrimitive};\n\nuse super::{LexicalError, Symbol, TokenConvertError, TokenConvertResult};\n\n#[derive(Debug, Clone, PartialEq, Eq)]\npub struct LexicalToken(pub SourceIndex, pub Token, pub SourceIndex);\nimpl LexicalToken {\n #[inline]\n pub fn token(&self) -> Token {\n self.1.clone()\n }\n\n #[inline]\n pub fn span(&self) -> SourceSpan {\n SourceSpan::new(self.0, self.2)\n }\n}\nimpl fmt::Display for LexicalToken {\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n write!(f, \"{}\", self.token())\n }\n}\nimpl std::convert::Into<(SourceIndex, Token, SourceIndex)> for LexicalToken {\n fn into(self) -> (SourceIndex, Token, SourceIndex) {\n (self.0, self.1, self.2)\n }\n}\nimpl std::convert::From<(SourceIndex, Token, SourceIndex)> for LexicalToken {\n fn from(triple: (SourceIndex, Token, SourceIndex)) -> LexicalToken {\n LexicalToken(triple.0, triple.1, triple.2)\n }\n}\n\n/// Used to identify the type of token expected in a TokenConvertError\n#[derive(Debug, Clone, PartialEq, Eq, Hash)]\npub enum TokenType {\n Atom,\n Ident,\n String,\n Integer,\n Symbol,\n}\nimpl fmt::Display for TokenType {\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n match *self {\n TokenType::Atom => write!(f, \"ATOM\"),\n TokenType::Ident => write!(f, \"IDENT\"),\n TokenType::String => write!(f, \"STRING\"),\n TokenType::Integer => write!(f, \"INTEGER\"),\n TokenType::Symbol => write!(f, \"SYMBOL\"),\n }\n }\n}\n\n#[derive(Debug, Clone, PartialEq, Eq, Hash)]\npub struct AtomToken(pub SourceIndex, pub Token, pub SourceIndex);\nimpl AtomToken {\n pub fn token(&self) -> Token {\n self.1.clone()\n }\n pub fn span(&self) -> SourceSpan {\n SourceSpan::new(self.0, self.2)\n }\n pub fn symbol(&self) -> Symbol {\n match self.token() {\n Token::Atom(a) => a,\n _ => unreachable!(),\n }\n }\n}\nimpl TryFrom for AtomToken {\n type Error = TokenConvertError;\n\n fn try_from(t: LexicalToken) -> TokenConvertResult {\n use libeir_intern::symbol::symbols;\n\n match t {\n LexicalToken(start, tok @ Token::Atom(_), end) => {\n return Ok(AtomToken(start, tok, end))\n }\n LexicalToken(start, Token::If, end) => {\n return Ok(AtomToken(start, Token::Atom(symbols::If), end));\n }\n t => Err(TokenConvertError {\n span: t.span(),\n token: t.token(),\n expected: TokenType::Atom,\n }),\n }\n }\n}\nimpl Into for AtomToken {\n fn into(self) -> LexicalToken {\n LexicalToken(self.0, self.1, self.2)\n }\n}\nimpl fmt::Display for AtomToken {\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n self.1.fmt(f)\n }\n}\n\n#[derive(Debug, Clone, PartialEq, Eq, Hash)]\npub struct IdentToken(pub SourceIndex, pub Token, pub SourceIndex);\nimpl IdentToken {\n pub fn token(&self) -> Token {\n self.1.clone()\n }\n pub fn span(&self) -> SourceSpan {\n SourceSpan::new(self.0, self.2)\n }\n pub fn symbol(&self) -> Symbol {\n match self.token() {\n Token::Ident(a) => a,\n _ => unreachable!(),\n }\n }\n}\nimpl TryFrom for IdentToken {\n type Error = TokenConvertError;\n\n fn try_from(t: LexicalToken) -> TokenConvertResult {\n if let LexicalToken(start, tok @ Token::Ident(_), end) = t {\n return Ok(IdentToken(start, tok, end));\n }\n Err(TokenConvertError {\n span: t.span(),\n token: t.token(),\n expected: TokenType::Ident,\n })\n }\n}\nimpl Into for IdentToken {\n fn into(self) -> LexicalToken {\n LexicalToken(self.0, self.1, self.2)\n }\n}\nimpl fmt::Display for IdentToken {\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n self.1.fmt(f)\n }\n}\n\n#[derive(Debug, Clone, PartialEq, Eq, Hash)]\npub struct StringToken(pub SourceIndex, pub Token, pub SourceIndex);\nimpl StringToken {\n pub fn token(&self) -> Token {\n self.1.clone()\n }\n pub fn span(&self) -> SourceSpan {\n SourceSpan::new(self.0, self.2)\n }\n pub fn symbol(&self) -> Symbol {\n match self.token() {\n Token::String(a) => a,\n _ => unreachable!(),\n }\n }\n}\nimpl TryFrom for StringToken {\n type Error = TokenConvertError;\n\n fn try_from(t: LexicalToken) -> TokenConvertResult {\n if let LexicalToken(start, tok @ Token::String(_), end) = t {\n return Ok(StringToken(start, tok, end));\n }\n Err(TokenConvertError {\n span: t.span(),\n token: t.token(),\n expected: TokenType::String,\n })\n }\n}\nimpl Into for StringToken {\n fn into(self) -> LexicalToken {\n LexicalToken(self.0, self.1, self.2)\n }\n}\nimpl fmt::Display for StringToken {\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n self.1.fmt(f)\n }\n}\n\n#[derive(Debug, Clone, PartialEq, Eq, Hash)]\npub struct IntegerToken(pub SourceIndex, pub Token, pub SourceIndex);\nimpl IntegerToken {\n pub fn token(&self) -> Token {\n self.1.clone()\n }\n pub fn span(&self) -> SourceSpan {\n SourceSpan::new(self.0, self.2)\n }\n pub fn small_integer(&self) -> Option {\n match self.token() {\n Token::Integer(a) => a.to_i64(),\n _ => unreachable!(),\n }\n }\n}\nimpl TryFrom for IntegerToken {\n type Error = TokenConvertError;\n\n fn try_from(t: LexicalToken) -> TokenConvertResult {\n if let LexicalToken(start, tok @ Token::Integer(_), end) = t {\n return Ok(IntegerToken(start, tok, end));\n }\n Err(TokenConvertError {\n span: t.span(),\n token: t.token(),\n expected: TokenType::Integer,\n })\n }\n}\nimpl Into for IntegerToken {\n fn into(self) -> LexicalToken {\n LexicalToken(self.0, self.1, self.2)\n }\n}\nimpl fmt::Display for IntegerToken {\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n self.1.fmt(f)\n }\n}\n\n#[derive(Debug, Clone, PartialEq, Eq, Hash)]\npub struct SymbolToken(pub SourceIndex, pub Token, pub SourceIndex);\nimpl SymbolToken {\n pub fn token(&self) -> Token {\n self.1.clone()\n }\n pub fn span(&self) -> SourceSpan {\n SourceSpan::new(self.0, self.2)\n }\n}\nimpl TryFrom for SymbolToken {\n type Error = TokenConvertError;\n\n fn try_from(t: LexicalToken) -> TokenConvertResult {\n match t {\n LexicalToken(_, Token::Atom(_), _) => (),\n LexicalToken(_, Token::Ident(_), _) => (),\n LexicalToken(_, Token::String(_), _) => (),\n LexicalToken(start, token, end) => return Ok(SymbolToken(start, token, end)),\n }\n Err(TokenConvertError {\n span: t.span(),\n token: t.token(),\n expected: TokenType::Symbol,\n })\n }\n}\nimpl Into for SymbolToken {\n fn into(self) -> LexicalToken {\n LexicalToken(self.0, self.1, self.2)\n }\n}\nimpl fmt::Display for SymbolToken {\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n self.1.fmt(f)\n }\n}\n\n#[derive(Debug, Copy, Clone, PartialEq, Eq)]\npub enum DelayedSubstitution {\n FunctionName,\n FunctionArity,\n}\n\n/// This enum contains tokens produced by the lexer\n#[derive(Debug, Clone)]\npub enum Token {\n // Signifies end of input\n EOF,\n // A tokenization error which may be recovered from\n Error(LexicalError),\n DelayedSubstitution(DelayedSubstitution),\n // Docs\n Comment,\n Edoc,\n // Literals\n Char(char),\n Integer(Integer),\n Float(Float),\n Atom(Symbol),\n String(Symbol),\n Ident(Symbol),\n // Keywords and Symbols\n LParen,\n RParen,\n Comma,\n RightStab,\n LBrace,\n RBrace,\n LBracket,\n RBracket,\n Bar,\n BarBar,\n LeftStab,\n Semicolon,\n Colon,\n Pound,\n Dot,\n // Keywords\n After,\n Begin,\n Case,\n Try,\n Catch,\n End,\n Fun,\n If,\n Of,\n Receive,\n When,\n // Attributes\n Record,\n Spec,\n Callback,\n OptionalCallback,\n Import,\n Export,\n ExportType,\n Removed,\n Module,\n Compile,\n Vsn,\n Author,\n OnLoad,\n Behaviour,\n Deprecated,\n Type,\n Opaque,\n File,\n // Operators\n AndAlso,\n OrElse,\n Bnot,\n Not,\n Star,\n Slash,\n Div,\n Rem,\n Band,\n And,\n Plus,\n Minus,\n Bor,\n Bxor,\n Bsl,\n Bsr,\n Or,\n Xor,\n PlusPlus,\n MinusMinus,\n // ==\n IsEqual,\n // /=\n IsNotEqual,\n // =<\n IsLessThanOrEqual,\n // <\n IsLessThan,\n // >=\n IsGreaterThanOrEqual,\n // >\n IsGreaterThan,\n // =:=\n IsExactlyEqual,\n // =/=\n IsExactlyNotEqual,\n // <=\n LeftArrow,\n // =>\n RightArrow,\n // :=\n ColonEqual,\n // <<\n BinaryStart,\n // >>\n BinaryEnd,\n Bang,\n // =\n Equals,\n ColonColon,\n DotDot,\n DotDotDot,\n Question,\n DoubleQuestion,\n}\nimpl PartialEq for Token {\n fn eq(&self, other: &Token) -> bool {\n match self {\n Token::Char(c) => {\n if let Token::Char(c2) = other {\n return *c == *c2;\n }\n }\n Token::Integer(i) => {\n if let Token::Integer(i2) = other {\n return *i == *i2;\n }\n }\n Token::Float(n) => {\n if let Token::Float(n2) = other {\n return *n == *n2;\n }\n }\n Token::Error(_) => {\n if let Token::Error(_) = other {\n return true;\n }\n }\n Token::Atom(ref a) => {\n if let Token::Atom(a2) = other {\n return *a == *a2;\n }\n }\n Token::Ident(ref i) => {\n if let Token::Ident(i2) = other {\n return *i == *i2;\n }\n }\n Token::String(ref s) => {\n if let Token::String(s2) = other {\n return *s == *s2;\n }\n }\n _ => return mem::discriminant(self) == mem::discriminant(other),\n }\n return false;\n }\n}\nimpl Eq for Token {}\nimpl Hash for Token {\n fn hash(&self, state: &mut H) {\n match *self {\n Token::Float(n) => n.raw().hash(state),\n Token::Error(ref e) => e.hash(state),\n Token::Atom(ref a) => a.hash(state),\n Token::Ident(ref i) => i.hash(state),\n Token::String(ref s) => s.hash(state),\n Token::Char(c) => c.hash(state),\n ref token => token.to_string().hash(state),\n }\n }\n}\n\nimpl Token {\n pub fn from_bare_atom<'input>(atom: &'input str) -> Self {\n match atom.as_ref() {\n // Reserved words\n \"after\" => Token::After,\n \"begin\" => Token::Begin,\n \"case\" => Token::Case,\n \"try\" => Token::Try,\n \"catch\" => Token::Catch,\n \"end\" => Token::End,\n \"fun\" => Token::Fun,\n \"if\" => Token::If,\n \"of\" => Token::Of,\n \"receive\" => Token::Receive,\n \"when\" => Token::When,\n \"andalso\" => Token::AndAlso,\n \"orelse\" => Token::OrElse,\n \"bnot\" => Token::Bnot,\n \"not\" => Token::Not,\n \"div\" => Token::Div,\n \"rem\" => Token::Rem,\n \"band\" => Token::Band,\n \"and\" => Token::And,\n \"bor\" => Token::Bor,\n \"bxor\" => Token::Bxor,\n \"bsl\" => Token::Bsl,\n \"bsr\" => Token::Bsr,\n \"or\" => Token::Or,\n \"xor\" => Token::Xor,\n _ => Token::Atom(Symbol::intern(atom)),\n }\n }\n\n /// For opening tokens like `(` and `[`, get the corresponding\n /// closing token.\n pub fn get_closing_token(&self) -> Self {\n match self {\n Token::LParen => Token::RParen,\n Token::LBrace => Token::RBrace,\n Token::LBracket => Token::RBracket,\n Token::BinaryStart => Token::BinaryEnd,\n _ => panic!(\"{} has no closing token\", self),\n }\n }\n}\n\nimpl fmt::Display for Token {\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n match self {\n Token::EOF => write!(f, \"EOF\"),\n Token::Error(_) => write!(f, \"ERROR\"),\n Token::Comment => write!(f, \"COMMENT\"),\n Token::Edoc => write!(f, \"EDOC\"),\n Token::DelayedSubstitution(DelayedSubstitution::FunctionName) => write!(f, \"STRING\"),\n Token::DelayedSubstitution(DelayedSubstitution::FunctionArity) => write!(f, \"INTEGER\"),\n // Literals\n Token::Char(ref c) => write!(f, \"{}\", c),\n Token::Integer(ref i) => write!(f, \"{}\", i),\n Token::Float(ref n) => write!(f, \"{}\", n),\n Token::Atom(ref s) => write!(f, \"'{}'\", s),\n Token::String(ref s) => write!(f, \"\\\"{}\\\"\", s),\n Token::Ident(ref s) => write!(f, \"{}\", s),\n Token::LParen => write!(f, \"(\"),\n Token::RParen => write!(f, \")\"),\n Token::Comma => write!(f, \",\"),\n Token::RightStab => write!(f, \"->\"),\n Token::LBrace => write!(f, \"{{\"),\n Token::RBrace => write!(f, \"}}\"),\n Token::LBracket => write!(f, \"[\"),\n Token::RBracket => write!(f, \"]\"),\n Token::Bar => write!(f, \"|\"),\n Token::BarBar => write!(f, \"||\"),\n Token::LeftStab => write!(f, \"<-\"),\n Token::Semicolon => write!(f, \";\"),\n Token::Colon => write!(f, \":\"),\n Token::Pound => write!(f, \"#\"),\n Token::Dot => write!(f, \".\"),\n Token::After => write!(f, \"after\"),\n Token::Begin => write!(f, \"begin\"),\n Token::Case => write!(f, \"case\"),\n Token::Try => write!(f, \"try\"),\n Token::Catch => write!(f, \"catch\"),\n Token::End => write!(f, \"end\"),\n Token::Fun => write!(f, \"fun\"),\n Token::If => write!(f, \"if\"),\n Token::Of => write!(f, \"of\"),\n Token::Receive => write!(f, \"receive\"),\n Token::When => write!(f, \"when\"),\n Token::Record => write!(f, \"record\"),\n Token::Spec => write!(f, \"spec\"),\n Token::Callback => write!(f, \"callback\"),\n Token::OptionalCallback => write!(f, \"optional_callback\"),\n Token::Import => write!(f, \"import\"),\n Token::Export => write!(f, \"export\"),\n Token::ExportType => write!(f, \"export_type\"),\n Token::Removed => write!(f, \"removed\"),\n Token::Module => write!(f, \"module\"),\n Token::Compile => write!(f, \"compile\"),\n Token::Vsn => write!(f, \"vsn\"),\n Token::Author => write!(f, \"author\"),\n Token::OnLoad => write!(f, \"on_load\"),\n Token::Behaviour => write!(f, \"behaviour\"),\n Token::Deprecated => write!(f, \"deprecated\"),\n Token::Type => write!(f, \"type\"),\n Token::Opaque => write!(f, \"opaque\"),\n Token::File => write!(f, \"file\"),\n Token::AndAlso => write!(f, \"andalso\"),\n Token::OrElse => write!(f, \"orelse\"),\n Token::Bnot => write!(f, \"bnot\"),\n Token::Not => write!(f, \"not\"),\n Token::Star => write!(f, \"*\"),\n Token::Slash => write!(f, \"/\"),\n Token::Div => write!(f, \"div\"),\n Token::Rem => write!(f, \"rem\"),\n Token::Band => write!(f, \"band\"),\n Token::And => write!(f, \"and\"),\n Token::Plus => write!(f, \"+\"),\n Token::Minus => write!(f, \"-\"),\n Token::Bor => write!(f, \"bor\"),\n Token::Bxor => write!(f, \"bxor\"),\n Token::Bsl => write!(f, \"bsl\"),\n Token::Bsr => write!(f, \"bsr\"),\n Token::Or => write!(f, \"or\"),\n Token::Xor => write!(f, \"xor\"),\n Token::PlusPlus => write!(f, \"++\"),\n Token::MinusMinus => write!(f, \"--\"),\n Token::IsEqual => write!(f, \"==\"),\n Token::IsNotEqual => write!(f, \"/=\"),\n Token::IsLessThanOrEqual => write!(f, \"=<\"),\n Token::IsLessThan => write!(f, \"<\"),\n Token::IsGreaterThanOrEqual => write!(f, \">=\"),\n Token::IsGreaterThan => write!(f, \">\"),\n Token::IsExactlyEqual => write!(f, \"=:=\"),\n Token::IsExactlyNotEqual => write!(f, \"=/=\"),\n Token::LeftArrow => write!(f, \"<=\"),\n Token::RightArrow => write!(f, \"=>\"),\n Token::ColonEqual => write!(f, \":=\"),\n Token::BinaryStart => write!(f, \"<<\"),\n Token::BinaryEnd => write!(f, \">>\"),\n Token::Bang => write!(f, \"!\"),\n Token::Equals => write!(f, \"=\"),\n Token::ColonColon => write!(f, \"::\"),\n Token::DotDot => write!(f, \"..\"),\n Token::DotDotDot => write!(f, \"...\"),\n Token::Question => write!(f, \"?\"),\n Token::DoubleQuestion => write!(f, \"??\"),\n }\n }\n}\n" }, { "path": "libeir_syntax_erl/src/lib.rs", "content": "//#![deny(warnings)]\n#![feature(trait_alias, or_patterns, never_type)]\n\nmod abstr;\nmod evaluator;\nmod lexer;\nmod lower;\nmod parser;\nmod preprocessor;\nmod util;\n\npub use self::abstr::lower as lower_abstr;\npub use self::lexer::*;\npub use self::lower::{lower_module, LowerError};\npub use self::parser::*;\npub use self::preprocessor::*;\n\npub enum ErlangError {\n Parser(ParserError),\n Lower(LowerError),\n}\nimpl From for ErlangError {\n fn from(e: ParserError) -> Self {\n ErlangError::Parser(e)\n }\n}\nimpl From for ErlangError {\n fn from(e: LowerError) -> Self {\n ErlangError::Lower(e)\n }\n}\nimpl libeir_diagnostics::ToDiagnostic for ErlangError {\n fn to_diagnostic(&self) -> libeir_diagnostics::Diagnostic {\n match self {\n ErlangError::Parser(err) => err.to_diagnostic(),\n ErlangError::Lower(err) => err.to_diagnostic(),\n }\n }\n}\n" }, { "path": "libeir_syntax_erl/src/lower/errors.rs", "content": "use libeir_diagnostics::{Diagnostic, Label, SourceIndex, SourceSpan, ToDiagnostic};\n\nuse crate::parser::binary::TypeName as BinaryTypeName;\nuse crate::util::encoding::StringError;\n\nuse snafu::Snafu;\n\n#[derive(Debug, Snafu)]\n#[snafu(visibility = \"pub(crate)\")]\npub enum LowerError {\n #[snafu(display(\"illegal expression\"))]\n IllegalExpression {\n span: SourceSpan,\n },\n\n /// An invalid expression occurred in a pattern\n #[snafu(display(\"an invalid expression occurred in a pattern\"))]\n NotAllowedInPattern {\n span: SourceSpan,\n },\n\n /// Equality in a pattern caused two nodes to be merged.\n /// It has been shown to be unmatchable.\n #[snafu(display(\"patterns are fully disjoint and can never be matched\"))]\n DisjointPatternUnionWarning {\n left: Option,\n right: Option,\n },\n /// Pattern is constrained by two different constant\n /// values, or is matched against an unmatchable value\n #[snafu(display(\"pattern can never be matched\"))]\n UnmatchablePatternWarning {\n pat: Option,\n reason: Option,\n },\n\n /// Equality in a pattern caused two nodes to be merged,\n /// but merging these two nodes is not supported.\n /// Happens when trying to merge two binary patterns.\n #[snafu(display(\"patterns cannot be merged\"))]\n UnsupportedPatternUnion {\n left: Option,\n right: SourceSpan,\n },\n\n #[snafu(display(\"invalid const expression in pattern\"))]\n PatternConst {\n source: crate::evaluator::EvalError,\n span: SourceSpan,\n },\n\n StringTokenizeError {\n source: crate::util::string_tokenizer::StringTokenizeError,\n },\n\n /// Unable to resolve a variable in scope.\n #[snafu(display(\"could not resolve variable\"))]\n UnresolvedVariable {\n span: SourceSpan,\n },\n\n /// Unable to bind a variable in a scope, it is already bound.\n #[snafu(display(\"variable was already bound in scope\"))]\n AlreadyBound {\n new: SourceSpan,\n old: SourceSpan,\n },\n /// Variable binding shadowed other binding\n #[snafu(display(\"binding shadowed previously bound variable\"))]\n ShadowingBind {\n new: SourceSpan,\n old: SourceSpan,\n },\n\n // Binary specifier parsing\n #[snafu(display(\"{} does not support size in binary entry\", typ))]\n BinaryInvalidSize {\n span: SourceSpan,\n typ: BinaryTypeName,\n },\n #[snafu(display(\"binary construction can never succeed\"))]\n BinaryConstructEntryTypeWarning {\n span: SourceSpan,\n },\n\n String {\n source: StringError,\n },\n\n // Records\n #[snafu(display(\"record field specified more than once\"))]\n DuplicateRecordField {\n new: SourceSpan,\n old: SourceSpan,\n },\n #[snafu(display(\"record is not defined\"))]\n UndefinedRecord {\n span: SourceSpan,\n },\n\n // Maps\n #[snafu(display(\"only map put (=>) allowed in map construction\"))]\n MapUpdateInConstruction {\n map: SourceSpan,\n field: SourceSpan,\n },\n #[snafu(display(\"map update performed on a non map\"))]\n MapUpdateOnNonMap {\n map: SourceSpan,\n },\n}\n\nimpl From for LowerError {\n fn from(err: crate::util::string_tokenizer::StringTokenizeError) -> Self {\n LowerError::StringTokenizeError { source: err }\n }\n}\nimpl From for LowerError {\n fn from(err: StringError) -> LowerError {\n LowerError::String { source: err }\n }\n}\n\nimpl ToDiagnostic for LowerError {\n fn to_diagnostic(&self) -> Diagnostic {\n let msg = self.to_string();\n match self {\n LowerError::IllegalExpression { span } => Diagnostic::error()\n .with_message(msg)\n .with_labels(vec![\n Label::primary(span.source_id(), *span).with_message(\"illegal expression\")\n ]),\n LowerError::NotAllowedInPattern { span } => Diagnostic::error()\n .with_message(msg)\n .with_labels(vec![Label::primary(span.source_id(), *span)\n .with_message(\"disallowed expression in pattern\")]),\n LowerError::DisjointPatternUnionWarning { left, right } => {\n let dig = Diagnostic::warning().with_message(msg);\n let mut labels = vec![];\n if let Some(left) = left {\n labels\n .push(Label::primary(left.source_id(), *left).with_message(\"left pattern\"));\n }\n if let Some(right) = right {\n labels.push(\n Label::primary(right.source_id(), *right).with_message(\"right pattern\"),\n );\n }\n dig.with_labels(labels)\n }\n LowerError::UnmatchablePatternWarning { pat, reason } => {\n let dig = Diagnostic::warning().with_message(msg);\n let mut labels = vec![];\n if let Some(pat) = pat {\n labels.push(\n Label::primary(pat.source_id(), *pat)\n .with_message(\"pattern can never be matched\"),\n );\n }\n if let Some(reason) = reason {\n labels.push(\n Label::primary(reason.source_id(), *reason)\n .with_message(\"matched against this\"),\n );\n }\n dig.with_labels(labels)\n }\n LowerError::UnsupportedPatternUnion { left, right } => {\n let dig = Diagnostic::warning().with_message(msg);\n let mut labels = vec![];\n if let Some(left) = left {\n labels\n .push(Label::primary(left.source_id(), *left).with_message(\"left pattern\"));\n }\n labels\n .push(Label::primary(right.source_id(), *right).with_message(\"right pattern\"));\n dig.with_labels(labels)\n }\n LowerError::PatternConst { source, .. } => source.to_diagnostic(),\n LowerError::StringTokenizeError { source } => source.to_diagnostic(),\n LowerError::UnresolvedVariable { span } => Diagnostic::error()\n .with_message(msg)\n .with_labels(vec![\n Label::primary(span.source_id(), *span).with_message(\"not bound in scope\")\n ]),\n LowerError::AlreadyBound { new, old } => {\n Diagnostic::error().with_message(msg).with_labels(vec![\n Label::primary(new.source_id(), *new)\n .with_message(\"variable was already bound in scope\"),\n Label::secondary(old.source_id(), *old).with_message(\"previously bound here\"),\n ])\n }\n LowerError::ShadowingBind { new, old } => {\n Diagnostic::warning().with_message(msg).with_labels(vec![\n Label::primary(new.source_id(), *new)\n .with_message(\"variable was already bound in scope\"),\n Label::secondary(old.source_id(), *old).with_message(\"previously bound here\"),\n ])\n }\n LowerError::BinaryInvalidSize { span, typ } => Diagnostic::error()\n .with_message(msg)\n .with_labels(vec![Label::primary(span.source_id(), *span).with_message(\n format!(\"size specifier not valid for {} binary entries\", typ),\n )]),\n LowerError::BinaryConstructEntryTypeWarning { span } => Diagnostic::warning()\n .with_message(msg)\n .with_labels(vec![\n Label::primary(span.source_id(), *span).with_message(\"can never succeed\")\n ]),\n LowerError::String { source } => source.to_diagnostic(),\n LowerError::DuplicateRecordField { new, old } => {\n Diagnostic::error().with_message(msg).with_labels(vec![\n Label::primary(new.source_id(), *old)\n .with_message(\"duplicate field definition in record\"),\n Label::secondary(old.source_id(), *old).with_message(\"previously defined here\"),\n ])\n }\n LowerError::UndefinedRecord { span } => Diagnostic::error()\n .with_message(msg)\n .with_labels(vec![Label::primary(span.source_id(), *span)]),\n LowerError::MapUpdateInConstruction { map, field } => {\n Diagnostic::error().with_message(msg).with_labels(vec![\n Label::primary(field.source_id(), *field)\n .with_message(\"map update (:=) attempted\"),\n Label::secondary(map.source_id(), *map)\n .with_message(\"expression is map construction\"),\n ])\n }\n LowerError::MapUpdateOnNonMap { map } => Diagnostic::warning()\n .with_message(msg)\n .with_labels(vec![Label::primary(map.source_id(), *map).with_message(\n \"updated value is not a map, this will fail at runtime\",\n )]),\n }\n }\n}\n" }, { "path": "libeir_syntax_erl/src/lower/exception_handler_stack.rs", "content": "use libeir_diagnostics::SourceSpan;\nuse libeir_ir::{Block, FunctionBuilder, Value};\n\npub struct ExceptionHandlerStack {\n stack: Vec<(Value, bool)>,\n}\nimpl ExceptionHandlerStack {\n pub fn new() -> Self {\n ExceptionHandlerStack { stack: vec![] }\n }\n\n pub fn push_handler(&mut self, handler: Value) {\n self.stack.push((handler, true));\n }\n\n pub fn pop_handler(&mut self) {\n self.stack.pop();\n }\n\n pub fn make_error_jump_trace(\n &self,\n b: &mut FunctionBuilder,\n block: Block,\n typ: Value,\n error: Value,\n trace: Value,\n ) {\n let (handler, has_arg) = self.stack.last().unwrap();\n if *has_arg {\n b.op_call_flow(block, *handler, &[typ, error, trace])\n } else {\n b.op_call_flow(block, *handler, &[])\n }\n }\n\n pub fn make_error_jump(\n &self,\n b: &mut FunctionBuilder,\n span: SourceSpan,\n block: Block,\n typ: Value,\n error: Value,\n ) {\n let loc = b.fun().block_location(block);\n\n let cont = b.op_trace_capture_raw(span, block);\n b.block_set_location(cont, loc);\n\n let trace = b.block_args(cont)[0];\n self.make_error_jump_trace(b, cont, typ, error, trace);\n }\n\n pub fn finish(&self) {\n assert!(self.stack.len() == 0);\n }\n\n pub fn len(&self) -> usize {\n self.stack.len()\n }\n}\n" }, { "path": "libeir_syntax_erl/src/lower/expr/binary.rs", "content": "pub use libeir_ir::binary::{BinaryEntrySpecifier, Endianness};\nuse libeir_ir::{\n operation::binary_construct::{\n BinaryConstructFinish, BinaryConstructPush, BinaryConstructStart,\n },\n Block as IrBlock, FunctionBuilder, Value as IrValue,\n};\n\nuse libeir_util_binary::BitVec;\n\nuse crate::parser::binary::{TypeName, specifier_to_typename, specifier_can_have_size, default_specifier};\nuse crate::parser::ast::{Binary, BinaryElement, Expr, Literal};\n\nuse crate::lower::{LowerCtx, LowerError};\nuse crate::lower::expr::lower_single_same_scope;\n\nuse crate::util::string_tokenizer::StringTokenizer;\n\nfn make_size(\n ctx: &mut LowerCtx,\n b: &mut FunctionBuilder,\n block: &mut IrBlock,\n bit_size: &Option,\n spec: BinaryEntrySpecifier,\n) -> Option {\n let spec_typ = specifier_to_typename(&spec);\n\n if let Some(size_expr) = bit_size {\n if !specifier_can_have_size(&spec) {\n ctx.error(LowerError::BinaryInvalidSize {\n span: size_expr.span(),\n typ: spec_typ,\n });\n None\n } else {\n Some(map_block!(\n *block,\n lower_single_same_scope(ctx, b, *block, size_expr)\n ))\n }\n } else {\n match spec_typ {\n TypeName::Integer => Some(b.value(8)),\n TypeName::Float => Some(b.value(64)),\n _ => None,\n }\n }\n}\n\n/// Lowers a single entry of a binary construction element.\n///\n/// A couple of gotchas with the syntax:\n/// - `<<\"abc\">>.`: obviously valid, creates a binary of the ascii characters\n/// - `<<\"™\">>.`: also valid, encodes each CODEPOINT in the string as a byte,\n/// truncated. This evaluates to `<<34>>`.\n/// - `<<[97, 98, 99]>>.` not valid, while a string binary element is handled\n/// as a special case, this does not apply to char lists.\n/// - `<<\"abc\":10/integer>>` valid! a string literal is desugared to a list of\n/// individual integers in the binary entry, each with the specifier on it.\npub(crate) fn lower_binary_elem(\n ctx: &mut LowerCtx,\n b: &mut FunctionBuilder,\n mut block: IrBlock,\n bin_ref: &mut IrValue,\n elem: &BinaryElement,\n) -> IrBlock {\n let spec = elem.specifier.unwrap_or(default_specifier());\n\n let size_val = make_size(ctx, b, &mut block, &elem.bit_size, spec);\n\n let elem_val = match &elem.bit_expr {\n Expr::Literal(Literal::String(_id, string)) if !spec.is_native_endian() => {\n\n let tokenizer = StringTokenizer::new(*string);\n for elem in tokenizer {\n match elem {\n Ok((cp, span)) => {\n let elem_val = b.value(cp);\n let (ok_cont, err_cont) = BinaryConstructPush::build(\n b, block, *bin_ref, elem_val, spec, size_val,\n );\n *bin_ref = b.block_args(ok_cont)[0];\n block = ok_cont;\n\n // TODO: Proper error\n b.op_unreachable(span, err_cont);\n },\n Err(err) => {\n ctx.error(err.into());\n },\n }\n }\n\n None\n }\n _ => Some(map_block!(\n block,\n lower_single_same_scope(ctx, b, block, &elem.bit_expr)\n )),\n };\n\n if let Some(elem_val) = elem_val {\n let (ok_cont, err_cont) =\n BinaryConstructPush::build(b, block, *bin_ref, elem_val, spec, size_val);\n *bin_ref = b.block_args(ok_cont)[0];\n block = ok_cont;\n\n // TODO: Proper error\n b.op_unreachable(elem.span, err_cont);\n }\n\n block\n}\n\npub(super) fn lower_binary_expr(\n ctx: &mut LowerCtx,\n b: &mut FunctionBuilder,\n mut block: IrBlock,\n bin: Option,\n binary: &Binary,\n) -> (IrBlock, IrValue) {\n block = BinaryConstructStart::build(b, block);\n let mut bin_ref = b.block_args(block)[0];\n\n if let Some(bin) = bin {\n let spec = BinaryEntrySpecifier::Bytes { unit: 1 };\n let (ok_cont, err_cont) = BinaryConstructPush::build(b, block, bin_ref, bin, spec, None);\n block = ok_cont;\n b.op_unreachable(binary.span, err_cont);\n\n bin_ref = b.block_args(ok_cont)[0];\n }\n\n let mut bitvec = BitVec::new();\n\n for elem in binary.elements.iter() {\n let resolve_rec_idx = |name, field| ctx.resolve_rec_idx(name, field);\n match crate::util::binary::append_static_binary_element(elem, &mut bitvec, Some(&resolve_rec_idx)) {\n // This means the binary element was fully static, and the data has\n // been appended to the BitVec.\n Ok(()) => (),\n // Element was dynamic, we need to generate binary construction\n // operations.\n Err(_) => {\n // If we have static data before this dynamic element, we\n // need to append that first.\n if !bitvec.empty() {\n let bin = b.value(bitvec);\n let spec = BinaryEntrySpecifier::Bits { unit: 1 };\n\n let (ok_cont, err_cont) = BinaryConstructPush::build(b, block, bin_ref, bin, spec, None);\n bin_ref = b.block_args(ok_cont)[0];\n block = ok_cont;\n\n // We know the value we appended is a BitVec, this can never\n // fail.\n b.op_unreachable(binary.span, err_cont);\n\n bitvec = BitVec::new();\n }\n\n block = lower_binary_elem(ctx, b, block, &mut bin_ref, elem);\n },\n }\n }\n\n if !bitvec.empty() {\n let bin = b.value(bitvec);\n let spec = BinaryEntrySpecifier::Bits { unit: 1 };\n\n let (ok_cont, err_cont) = BinaryConstructPush::build(b, block, bin_ref, bin, spec, None);\n bin_ref = b.block_args(ok_cont)[0];\n block = ok_cont;\n\n // We know the value we appended is a BitVec, this can never\n // fail.\n b.op_unreachable(binary.span, err_cont);\n }\n\n block = BinaryConstructFinish::build(b, block, bin_ref);\n let res_arg = b.block_args(block)[0];\n\n (block, res_arg)\n}\n" }, { "path": "libeir_syntax_erl/src/lower/expr/binary_expr.rs", "content": "use libeir_ir::{Block as IrBlock, FunctionBuilder, Value as IrValue};\n\nuse libeir_intern::{Ident, Symbol};\n\nuse crate::parser::ast::BinaryExpr;\nuse crate::parser::ast::BinaryOp;\n\nuse crate::lower::expr::{lower_single, lower_single_same_scope};\nuse crate::lower::LowerCtx;\n\npub(super) fn lower_binary_expr(\n ctx: &mut LowerCtx,\n b: &mut FunctionBuilder,\n mut block: IrBlock,\n expr: &BinaryExpr,\n) -> (IrBlock, IrValue) {\n let BinaryExpr {\n lhs,\n rhs,\n op,\n id: _,\n span,\n } = expr;\n let span = *span;\n\n match op {\n BinaryOp::AndAlso => {\n let loc = ctx.current_location(b, span);\n\n let (l1_block, lhs_val) = lower_single(ctx, b, block, lhs);\n\n let ret_block = b.block_insert();\n let ret_val = b.block_arg_insert(ret_block);\n\n let (true1_block, false1_block, non1_block) = b.op_if_bool(span, l1_block, lhs_val);\n\n // True branch\n let (l2_block, rhs_val) = lower_single(ctx, b, true1_block, rhs);\n b.op_call_flow(l2_block, ret_block, &[rhs_val]);\n\n // False branch\n let false_val = b.value(false);\n b.op_call_flow(false1_block, ret_block, &[false_val]);\n\n // Nonbool branch\n {\n let block = non1_block;\n\n let typ_val = b.value(Symbol::intern(\"error\"));\n let err_atom = b.value(Symbol::intern(\"badarg\"));\n let err_val = b.prim_tuple(span, &[err_atom, lhs_val]);\n\n b.block_set_location(block, loc);\n ctx.exc_stack\n .make_error_jump(b, span, block, typ_val, err_val);\n }\n\n (ret_block, ret_val)\n }\n BinaryOp::OrElse => {\n let loc = ctx.current_location(b, span);\n\n let (l1_block, lhs_val) = lower_single(ctx, b, block, lhs);\n\n let ret_block = b.block_insert();\n let ret_val = b.block_arg_insert(ret_block);\n\n let (true1_block, false1_block, non1_block) = b.op_if_bool(span, l1_block, lhs_val);\n\n // True branch\n let true_val = b.value(true);\n b.op_call_flow(true1_block, ret_block, &[true_val]);\n\n // False branch\n let (l2_block, rhs_val) = lower_single(ctx, b, false1_block, rhs);\n b.op_call_flow(l2_block, ret_block, &[rhs_val]);\n\n // Nonbool branch\n {\n let block = non1_block;\n\n let typ_val = b.value(Symbol::intern(\"error\"));\n let err_atom = b.value(Symbol::intern(\"badarg\"));\n let err_val = b.prim_tuple(span, &[err_atom, lhs_val]);\n\n b.block_set_location(block, loc);\n ctx.exc_stack\n .make_error_jump(b, span, block, typ_val, err_val);\n }\n\n (ret_block, ret_val)\n }\n _ => {\n let lhs_val = map_block!(block, lower_single_same_scope(ctx, b, block, lhs));\n let rhs_val = map_block!(block, lower_single_same_scope(ctx, b, block, rhs));\n\n let (m, f) = match op {\n BinaryOp::Lt => (Ident::from_str(\"erlang\"), Ident::from_str(\"<\")),\n BinaryOp::Lte => (Ident::from_str(\"erlang\"), Ident::from_str(\"=<\")),\n BinaryOp::Gt => (Ident::from_str(\"erlang\"), Ident::from_str(\">\")),\n BinaryOp::Gte => (Ident::from_str(\"erlang\"), Ident::from_str(\">=\")),\n BinaryOp::Sub => (Ident::from_str(\"erlang\"), Ident::from_str(\"-\")),\n BinaryOp::Add => (Ident::from_str(\"erlang\"), Ident::from_str(\"+\")),\n BinaryOp::Append => (Ident::from_str(\"erlang\"), Ident::from_str(\"++\")),\n BinaryOp::Remove => (Ident::from_str(\"erlang\"), Ident::from_str(\"--\")),\n BinaryOp::Multiply => (Ident::from_str(\"erlang\"), Ident::from_str(\"*\")),\n BinaryOp::Divide => (Ident::from_str(\"erlang\"), Ident::from_str(\"/\")),\n BinaryOp::Rem => (Ident::from_str(\"erlang\"), Ident::from_str(\"rem\")),\n BinaryOp::Div => (Ident::from_str(\"erlang\"), Ident::from_str(\"div\")),\n BinaryOp::Equal => (Ident::from_str(\"erlang\"), Ident::from_str(\"==\")),\n BinaryOp::NotEqual => (Ident::from_str(\"erlang\"), Ident::from_str(\"/=\")),\n BinaryOp::StrictEqual => (Ident::from_str(\"erlang\"), Ident::from_str(\"=:=\")),\n BinaryOp::StrictNotEqual => (Ident::from_str(\"erlang\"), Ident::from_str(\"=/=\")),\n BinaryOp::Band => (Ident::from_str(\"erlang\"), Ident::from_str(\"band\")),\n BinaryOp::Bor => (Ident::from_str(\"erlang\"), Ident::from_str(\"bor\")),\n BinaryOp::Bxor => (Ident::from_str(\"erlang\"), Ident::from_str(\"bxor\")),\n BinaryOp::Bsl => (Ident::from_str(\"erlang\"), Ident::from_str(\"bsl\")),\n BinaryOp::Bsr => (Ident::from_str(\"erlang\"), Ident::from_str(\"bsr\")),\n BinaryOp::Or => (Ident::from_str(\"erlang\"), Ident::from_str(\"or\")),\n BinaryOp::Xor => (Ident::from_str(\"erlang\"), Ident::from_str(\"xor\")),\n BinaryOp::And => (Ident::from_str(\"erlang\"), Ident::from_str(\"and\")),\n BinaryOp::Send => (Ident::from_str(\"erlang\"), Ident::from_str(\"!\")),\n\n BinaryOp::AndAlso => unreachable!(),\n BinaryOp::OrElse => unreachable!(),\n };\n\n ctx.call_function(b, block, span, m, f, &[lhs_val, rhs_val])\n }\n }\n}\n" }, { "path": "libeir_syntax_erl/src/lower/expr/case.rs", "content": "use libeir_ir::operation::case::Case as CaseOp;\nuse libeir_ir::{Block as IrBlock, FunctionBuilder, Value as IrValue};\n\nuse libeir_intern::Symbol;\n\nuse crate::parser::ast::{Case, If};\n\nuse crate::lower::expr::{lower_block, lower_block_same_scope, lower_single_same_scope};\nuse crate::lower::pattern::lower_clause;\nuse crate::lower::scope::ScopeMerge;\nuse crate::lower::LowerCtx;\n\npub(super) fn lower_case_expr(\n ctx: &mut LowerCtx,\n b: &mut FunctionBuilder,\n mut block: IrBlock,\n case: &Case,\n) -> (IrBlock, IrValue) {\n let span = case.span;\n let case_loc = ctx.current_location(b, span);\n\n let match_val = map_block!(block, lower_single_same_scope(ctx, b, block, &case.expr));\n\n let no_match = b.block_insert();\n b.block_set_location(no_match, case_loc);\n {\n let typ_val = b.value(Symbol::intern(\"error\"));\n let case_clause_val = b.value(Symbol::intern(\"case_clause\"));\n let err_val = b.prim_tuple(span, &[case_clause_val, match_val]);\n ctx.exc_stack\n .make_error_jump(b, span, no_match, typ_val, err_val);\n }\n\n let mut case_b = CaseOp::builder();\n case_b.set_span(span);\n case_b.match_on = Some(match_val);\n case_b.no_match = Some(b.value(no_match));\n\n let entry_exc_height = ctx.exc_stack.len();\n\n let mut scope_merge = ScopeMerge::new();\n\n for clause in case.clauses.iter() {\n match lower_clause(\n ctx,\n &mut case_b.container,\n b,\n &mut block,\n false,\n clause.span,\n [&clause.pattern].iter().map(|i| *i),\n clause.guard.as_ref(),\n ) {\n Ok(lowered) => {\n let (scope_token, body) = lowered.make_body(ctx, b);\n\n // Add to case\n let body_val = b.value(body);\n case_b.push_clause(lowered.clause, lowered.guard, body_val, b);\n for value in lowered.values.iter() {\n case_b.push_value(*value, b);\n }\n\n let (body_ret_block, body_ret) = lower_block_same_scope(ctx, b, body, &clause.body);\n\n let binds = ctx.scope.pop_take(scope_token);\n scope_merge.branch(body_ret_block, body_ret, binds);\n }\n Err(lowered) => {\n let (scope_tok, dummy_body) = lowered.make_body(ctx, b);\n\n let (body_ret_block, body_ret) =\n lower_block_same_scope(ctx, b, dummy_body, &clause.body);\n\n let binds = ctx.scope.pop_take(scope_tok);\n scope_merge.branch(body_ret_block, body_ret, binds);\n }\n }\n assert!(ctx.exc_stack.len() == entry_exc_height)\n }\n case_b.finish(block, b);\n\n scope_merge.finish(ctx, b)\n}\n\npub(super) fn lower_if_expr(\n ctx: &mut LowerCtx,\n b: &mut FunctionBuilder,\n mut block: IrBlock,\n if_expr: &If,\n) -> (IrBlock, IrValue) {\n let span = if_expr.span;\n let loc = ctx.current_location(b, span);\n\n let match_val = b.prim_value_list(&[]);\n\n let no_match = b.block_insert();\n {\n let block = no_match;\n b.block_set_location(block, loc);\n let typ_val = b.value(Symbol::intern(\"error\"));\n let badmatch_val = b.value(Symbol::intern(\"badmatch\"));\n let err_val = b.prim_tuple(span, &[badmatch_val, match_val]);\n ctx.exc_stack\n .make_error_jump(b, span, block, typ_val, err_val);\n }\n\n let mut case_b = CaseOp::builder();\n case_b.set_span(span);\n case_b.match_on = Some(match_val);\n case_b.no_match = Some(b.value(no_match));\n\n let entry_exc_height = ctx.exc_stack.len();\n\n let mut scope_merge = ScopeMerge::new();\n\n for clause in if_expr.clauses.iter() {\n match lower_clause(\n ctx,\n &mut case_b.container,\n b,\n &mut block,\n false,\n span,\n [].iter(),\n Some(&clause.guards),\n ) {\n Ok(lowered) => {\n let (scope_token, body) = lowered.make_body(ctx, b);\n\n // Add to case\n let body_val = b.value(body);\n case_b.push_clause(lowered.clause, lowered.guard, body_val, b);\n for value in lowered.values.iter() {\n case_b.push_value(*value, b);\n }\n\n let (body_ret_block, body_ret) = lower_block(ctx, b, body, &clause.body);\n\n // Pop scope pushed in lower_clause\n let binds = ctx.scope.pop_take(scope_token);\n scope_merge.branch(body_ret_block, body_ret, binds);\n }\n Err(lowered) => {\n let (scope_token, body) = lowered.make_body(ctx, b);\n\n let (body_ret_block, body_ret) = lower_block(ctx, b, body, &clause.body);\n\n let binds = ctx.scope.pop_take(scope_token);\n scope_merge.branch(body_ret_block, body_ret, binds);\n }\n }\n assert!(ctx.exc_stack.len() == entry_exc_height)\n }\n\n case_b.finish(block, b);\n\n scope_merge.finish(ctx, b)\n}\n" }, { "path": "libeir_syntax_erl/src/lower/expr/catch.rs", "content": "use libeir_ir::operation::case::{Case, CaseBuilder};\nuse libeir_ir::{Block as IrBlock, FunctionBuilder, Value as IrValue};\n\nuse libeir_intern::Symbol;\n\nuse crate::parser::ast::Name;\nuse crate::parser::ast::NodeId;\nuse crate::parser::ast::{Catch, Try};\nuse crate::parser::ast::{Expr, Literal, Var};\n\nuse crate::lower::expr::{lower_block, lower_single};\nuse crate::lower::pattern::lower_clause;\nuse crate::lower::LowerCtx;\n\npub(super) fn lower_try_expr(\n ctx: &mut LowerCtx,\n b: &mut FunctionBuilder,\n mut block: IrBlock,\n try_expr: &Try,\n) -> (IrBlock, IrValue) {\n let span = try_expr.span;\n let exc_block = b.block_insert();\n\n let exc_type = b.block_arg_insert(exc_block);\n let exc_error = b.block_arg_insert(exc_block);\n let exc_trace = b.block_arg_insert(exc_block);\n\n // Lower exprs while catching exceptions\n ctx.exc_stack.push_handler(b.value(exc_block));\n let body_ret = map_block!(block, lower_block(ctx, b, block, &try_expr.exprs));\n ctx.exc_stack.pop_handler();\n\n let entry_exc_height = ctx.exc_stack.len();\n\n let join_block = b.block_insert();\n let join_val = b.block_arg_insert(join_block);\n\n // Clauses\n if let Some(clauses) = try_expr.clauses.as_ref() {\n let no_match = b.block_insert();\n {\n let block = no_match;\n let typ_val = b.value(Symbol::intern(\"error\"));\n let try_clause_val = b.value(Symbol::intern(\"try_clause\"));\n let err_val = b.prim_tuple(span, &[try_clause_val, body_ret]);\n ctx.exc_stack\n .make_error_jump(b, span, block, typ_val, err_val);\n }\n\n let mut case_b = Case::builder();\n case_b.set_span(span);\n case_b.match_on = Some(body_ret);\n case_b.no_match = Some(b.value(no_match));\n\n for clause in clauses {\n match lower_clause(\n ctx,\n &mut case_b.container,\n b,\n &mut block,\n false,\n clause.span,\n [&clause.pattern].iter().map(|i| *i),\n clause.guard.as_ref(),\n ) {\n Ok(lowered) => {\n let (scope_token, body) = lowered.make_body(ctx, b);\n\n // Add to case\n let body_val = b.value(body);\n case_b.push_clause(lowered.clause, lowered.guard, body_val, b);\n for value in lowered.values.iter() {\n case_b.push_value(*value, b);\n }\n\n let (body_ret_block, body_ret) = lower_block(ctx, b, body, &clause.body);\n\n // Call to join block\n b.op_call_flow(body_ret_block, join_block, &[body_ret]);\n\n // Pop scope pushed in lower_clause\n ctx.scope.pop(scope_token);\n }\n Err(_lowered) => {}\n }\n assert!(ctx.exc_stack.len() == entry_exc_height)\n }\n\n case_b.finish(block, b);\n } else {\n b.op_call_flow(block, join_block, &[body_ret]);\n }\n\n let catch_no_match_block = b.block_insert();\n\n // Catch\n if let Some(catch_clauses) = try_expr.catch_clauses.as_ref() {\n let mut block = exc_block;\n\n let match_val = b.prim_value_list(&[exc_type, exc_error]);\n\n let mut case_b = Case::builder();\n case_b.set_span(span);\n case_b.match_on = Some(match_val);\n case_b.no_match = Some(b.value(catch_no_match_block));\n\n let entry_exc_height = ctx.exc_stack.len();\n\n for clause in catch_clauses {\n // Convert the kind expression into a pattern expression so\n // that we can use existing pattern matching infrastructure.\n let kind_expr = match clause.kind {\n Name::Atom(atom) => Expr::Literal(Literal::Atom(NodeId(0), atom)),\n Name::Var(var) => Expr::Var(Var(NodeId(0), var)),\n };\n\n match lower_clause(\n ctx,\n &mut case_b.container,\n b,\n &mut block,\n false,\n clause.span,\n [&kind_expr, &clause.error].iter().map(|i| *i),\n clause.guard.as_ref(),\n ) {\n Ok(lowered) => {\n let (scope_token, body) = lowered.make_body(ctx, b);\n\n // Add to case\n let body_val = b.value(body);\n case_b.push_clause(lowered.clause, lowered.guard, body_val, b);\n for value in lowered.values.iter() {\n case_b.push_value(*value, b);\n }\n\n // Bind stack trace in scope\n ctx.bind(clause.trace, exc_trace);\n\n let (body_ret_block, body_ret) = lower_block(ctx, b, body, &clause.body);\n\n // Call to join block\n b.op_call_flow(body_ret_block, join_block, &[body_ret]);\n\n // Pop scope pushed in lower_clause\n ctx.scope.pop(scope_token);\n }\n Err(_lowered) => {}\n }\n\n assert!(ctx.exc_stack.len() == entry_exc_height)\n }\n\n case_b.finish(block, b);\n } else {\n b.op_call_flow(exc_block, catch_no_match_block, &[]);\n }\n\n // After\n if let Some(after) = try_expr.after.as_ref() {\n // Make after lambda\n let after_lambda = b.block_insert();\n let cont = b.block_arg_insert(after_lambda);\n let (after_block_cont, _after_val) = lower_block(ctx, b, after_lambda, &*after);\n b.op_call_flow(after_block_cont, cont, &[]);\n\n let ret_block = b.block_insert();\n let ret_val = b.block_arg_insert(ret_block);\n\n // Exception\n let ret_exc_block = b.block_insert();\n let ret_exc_block_val = b.value(ret_exc_block);\n b.op_call_flow(catch_no_match_block, after_lambda, &[ret_exc_block_val]);\n ctx.exc_stack\n .make_error_jump_trace(b, ret_exc_block, exc_type, exc_error, exc_trace);\n\n // Return regular\n let ret_regular_block = b.block_insert();\n let ret_regular_block_val = b.value(ret_regular_block);\n b.op_call_flow(join_block, after_lambda, &[ret_regular_block_val]);\n b.op_call_flow(ret_regular_block, ret_block, &[join_val]);\n\n (ret_block, ret_val)\n } else {\n ctx.exc_stack.make_error_jump_trace(\n b,\n catch_no_match_block,\n exc_type,\n exc_error,\n exc_trace,\n );\n (join_block, join_val)\n }\n}\n\npub(super) fn lower_catch_expr(\n ctx: &mut LowerCtx,\n b: &mut FunctionBuilder,\n mut block: IrBlock,\n catch_expr: &Catch,\n) -> (IrBlock, IrValue) {\n let span = catch_expr.span;\n let exc_block = b.block_insert();\n\n let exc_type = b.block_arg_insert(exc_block);\n let exc_error = b.block_arg_insert(exc_block);\n let exc_trace = b.block_arg_insert(exc_block);\n\n let mut case_b = Case::builder();\n case_b.set_span(span);\n\n // Atoms\n let big_exit_atom = b.value(Symbol::intern(\"EXIT\"));\n\n let make_value_clause = |b: &mut FunctionBuilder, case_b: &mut CaseBuilder, val: IrValue| {\n let clause = case_b.container.clause_start(span);\n\n // Value\n case_b.push_value(val, b);\n let pat_val = case_b.container.clause_value(clause);\n\n let pat = case_b.container.node_empty(Some(span));\n case_b.container.value(pat, pat_val);\n\n case_b.container.clause_node_push(clause, pat);\n case_b.container.clause_finish(clause);\n clause\n };\n\n let error_atom = b.value(Symbol::intern(\"error\"));\n let error_clause = make_value_clause(b, &mut case_b, error_atom);\n\n let exit_atom = b.value(Symbol::intern(\"exit\"));\n let exit_clause = make_value_clause(b, &mut case_b, exit_atom);\n\n let throw_atom = b.value(Symbol::intern(\"throw\"));\n let throw_clause = make_value_clause(b, &mut case_b, throw_atom);\n\n // Join block\n let join_block = b.block_insert();\n let join_arg = b.block_arg_insert(join_block);\n\n // Lower exprs while catching exceptions\n ctx.exc_stack.push_handler(b.value(exc_block));\n let body_ret = map_block!(block, lower_single(ctx, b, block, &catch_expr.expr));\n ctx.exc_stack.pop_handler();\n b.op_call_flow(block, join_block, &[body_ret]);\n\n // no_match is unreachable\n let no_match = b.block_insert();\n b.op_unreachable(span, no_match);\n\n // Guard lambda returning true\n let guard = b.block_insert();\n let guard_val = b.value(guard);\n let guard_cont = b.block_arg_insert(guard);\n let _guard_throw_cont = b.block_arg_insert(guard);\n let true_val = b.value(true);\n b.op_call_flow(guard, guard_cont, &[true_val]);\n\n // Actual case\n case_b.match_on = Some(exc_type);\n case_b.no_match = Some(b.value(no_match));\n\n // Error branch\n {\n let error_block = b.block_insert();\n let error_block_val = b.value(error_block);\n case_b.push_clause(error_clause, guard_val, error_block_val, b);\n\n let inner_tup = b.prim_tuple(span, &[exc_error, exc_trace]);\n let ret_tup = b.prim_tuple(span, &[big_exit_atom, inner_tup]);\n\n b.op_call_flow(error_block, join_block, &[ret_tup]);\n }\n\n // Exit branch\n {\n let exit_block = b.block_insert();\n let exit_block_val = b.value(exit_block);\n case_b.push_clause(exit_clause, guard_val, exit_block_val, b);\n\n let ret_tup = b.prim_tuple(span, &[big_exit_atom, exc_error]);\n\n b.op_call_flow(exit_block, join_block, &[ret_tup]);\n }\n\n // Throw branch\n {\n let throw_block = b.block_insert();\n let throw_block_val = b.value(throw_block);\n case_b.push_clause(throw_clause, guard_val, throw_block_val, b);\n\n b.op_call_flow(throw_block, join_block, &[exc_error]);\n }\n\n case_b.finish(exc_block, b);\n\n (join_block, join_arg)\n}\n" }, { "path": "libeir_syntax_erl/src/lower/expr/comprehension.rs", "content": "use snafu::Snafu;\n\nuse libeir_ir::binary::BinaryEntrySpecifier;\nuse libeir_ir::constant::NilTerm;\nuse libeir_ir::operation::binary_construct::{\n BinaryConstructFinish, BinaryConstructPush, BinaryConstructStart,\n};\nuse libeir_ir::operation::case::Case;\nuse libeir_ir::BinOp;\nuse libeir_ir::{Block as IrBlock, FunctionBuilder, Value as IrValue};\nuse libeir_ir::pattern::{PatternContainer, PatternClause};\n\nuse libeir_intern::{Ident, Symbol};\nuse libeir_diagnostics::SourceSpan;\n\nuse crate::parser::ast::{BinaryComprehension, Binary, BinaryElement, Expr, ListComprehension, NodeId, Var};\n\nuse crate::lower::expr::binary::lower_binary_expr;\nuse crate::lower::expr::{lower_single, lower_single_same_scope};\nuse crate::lower::pattern::lower_clause;\nuse crate::lower::LowerCtx;\n\n#[derive(Debug, Snafu)]\npub enum ComprehensionError {\n InvalidUnsizedBinaryElement {\n span: SourceSpan,\n },\n}\n\n/// Makes a pattern that matches on a single iteration of a binary generator.\nfn make_head_pattern(\n ctx: &mut LowerCtx,\n b: &mut FunctionBuilder,\n expr: &Expr,\n) -> Result<(Expr, Ident), ComprehensionError> {\n match expr {\n Expr::Binary(binary) => {\n let mut elements = binary.elements.clone();\n\n let tail = Ident::from_str(&format!(\"$generatortail{}\", ctx.make_unique()));\n\n // Validate that all elements in binary pattern are actually sized\n for elem in elements.iter() {\n match elem.specifier {\n Some(BinaryEntrySpecifier::Bytes { .. }) if elem.bit_size.is_none() => {\n return Err(ComprehensionError::InvalidUnsizedBinaryElement {\n span: elem.span,\n });\n },\n Some(BinaryEntrySpecifier::Bits { .. }) if elem.bit_size.is_none() => {\n return Err(ComprehensionError::InvalidUnsizedBinaryElement {\n span: elem.span,\n });\n },\n _ => (),\n }\n }\n\n elements.push(BinaryElement {\n span: binary.span,\n id: NodeId(0),\n bit_expr: Expr::Var(Var(NodeId(0), tail)),\n bit_size: None,\n specifier: Some(BinaryEntrySpecifier::Bytes { unit: 1 }),\n });\n\n let pattern = Expr::Binary(Binary {\n span: binary.span,\n id: NodeId(0),\n elements,\n });\n\n Ok((pattern, tail))\n },\n _ => unreachable!(),\n }\n}\n\nfn make_structural_bin_pattern(\n pat: &mut PatternContainer,\n expr: &Expr,\n) -> PatternClause {\n match expr {\n Expr::Binary(bin) => {\n unimplemented!()\n }\n _ => unimplemented!(),\n }\n}\n\nfn lower_qual(\n ctx: &mut LowerCtx,\n b: &mut FunctionBuilder,\n inner: &F,\n quals: &[Expr],\n mut block: IrBlock,\n acc: IrValue,\n) -> (IrBlock, IrValue)\nwhere\n F: Fn(&mut LowerCtx, &mut FunctionBuilder, IrBlock, IrValue) -> (IrBlock, IrValue),\n{\n if quals.len() == 0 {\n inner(ctx, b, block, acc)\n } else {\n match &quals[0] {\n Expr::Generator(gen) => {\n let gen_span = gen.span;\n\n // loop_block(list_val, acc)\n // loop_block(loop_list_arg, loop_acc_arg):\n // binop equal(is_nil_block, non_nil_block, loop_list_arg, [])\n // is_nil_block:\n // ret(loop_acc_arg)\n // non_nil_block:\n // unpack_list_cell(unpack_ok_block, unpack_fail_block, loop_list_arg)\n // unpack_fail_block:\n // throw non proper list\n // unpack_ok_block(head_val, tail_val):\n // do match on head_val\n // loop_block(tail_val, acc)\n\n let list_val = map_block!(block, lower_single(ctx, b, block, &gen.expr));\n\n // Loop entry block\n let loop_block = b.block_insert();\n let loop_list_arg = b.block_arg_insert(loop_block);\n let loop_acc_arg = b.block_arg_insert(loop_block);\n\n // Initial list cell unpack call\n b.op_call_flow(block, loop_block, &[list_val, acc]);\n\n // Return block\n let ret_block;\n let ret_val;\n\n // Check for nil and unpack list\n let nil = b.value(NilTerm);\n let comp_res = b.prim_binop(gen_span, BinOp::Equal, loop_list_arg, nil);\n let (is_nil_block, non_nil_block) =\n b.op_if_bool_strict(gen_span, loop_block, comp_res);\n\n ret_block = is_nil_block;\n ret_val = loop_acc_arg;\n\n let mut match_builder = b.op_match_build(gen_span);\n let unpack_ok_block = match_builder.push_list_cell(b);\n let unpack_fail_block = match_builder.push_wildcard(gen_span, b);\n match_builder.finish(non_nil_block, loop_list_arg, b);\n\n let head_val = b.block_args(unpack_ok_block)[0];\n let tail_val = b.block_args(unpack_ok_block)[1];\n\n {\n let typ = b.value(Symbol::intern(\"error\"));\n let error = b.value(Symbol::intern(\"function_clause\"));\n ctx.exc_stack\n .make_error_jump(b, gen_span, unpack_fail_block, typ, error);\n }\n\n // When there is no match, continue iterating\n let no_match = b.block_insert();\n b.op_call_flow(no_match, loop_block, &[tail_val, acc]);\n\n block = unpack_ok_block;\n let pattern_span = gen.pattern.span();\n\n let mut case_b = Case::builder();\n case_b.set_span(pattern_span);\n case_b.match_on = Some(head_val);\n case_b.no_match = Some(b.value(no_match));\n\n match lower_clause(\n ctx,\n &mut case_b.container,\n b,\n &mut block,\n false,\n pattern_span,\n [&*gen.pattern].iter().map(|i| *i),\n None,\n ) {\n Ok(lowered) => {\n let (scope_token, body) = lowered.make_body(ctx, b);\n\n // Add to case\n let body_val = b.value(body);\n case_b.push_clause(lowered.clause, lowered.guard, body_val, b);\n for value in lowered.values.iter() {\n case_b.push_value(*value, b);\n }\n\n let (cont, cont_val) =\n lower_qual(ctx, b, inner, &quals[1..], body, loop_acc_arg);\n b.op_call_flow(cont, loop_block, &[tail_val, cont_val]);\n\n // Pop scope pushed in lower_clause\n ctx.scope.pop(scope_token);\n\n case_b.finish(block, b);\n\n (ret_block, ret_val)\n }\n Err(_) => unimplemented!(), // TODO warn/error unreachable pattern\n }\n }\n Expr::BinaryGenerator(gen) => {\n let gen_span = gen.span;\n\n // loop_block(bin_val, acc)\n // loop_block(loop_bin_arg, loop_acc_arg):\n // do match on loop_bin_arg\n // 1. full pattern, append acc and continue\n // 2. structural pattern, continue\n // 3. wildcard, break\n\n let nil = b.value(NilTerm);\n\n let bin_val = map_block!(block, lower_single(ctx, b, block, &gen.expr));\n\n let break_block = b.block_insert();\n let break_arg = b.block_arg_insert(break_block);\n\n // Loop entry block\n let loop_block = b.block_insert();\n let mut loop_block_head = loop_block;\n let loop_bin_arg = b.block_arg_insert(loop_block);\n let loop_acc_arg = b.block_arg_insert(loop_block);\n\n let pattern_span = gen.pattern.span();\n\n b.op_call_flow(block, loop_block, &[bin_val, acc]);\n\n // No match block, break\n let no_match = b.block_insert();\n b.op_call_flow(no_match, break_block, &[nil]);\n\n let mut case_b = Case::builder();\n case_b.set_span(pattern_span);\n case_b.match_on = Some(loop_bin_arg);\n case_b.no_match = Some(b.value(no_match));\n\n let (head_pattern, tail_ident) = make_head_pattern(ctx, b, &gen.pattern).unwrap();\n\n match lower_clause(\n ctx,\n &mut case_b.container,\n b,\n &mut loop_block_head,\n false,\n pattern_span,\n [&head_pattern].iter().map(|v| *v),\n None,\n ) {\n Ok(lowered) => {\n // Main body\n {\n let (scope_token, body) = lowered.make_body(ctx, b);\n\n // Add to case\n let body_val = b.value(body);\n case_b.push_clause(lowered.clause, lowered.guard, body_val, b);\n for value in lowered.values.iter() {\n case_b.push_value(*value, b);\n }\n\n let tail_val = ctx.resolve(tail_ident);\n\n let (cont, cont_val) =\n lower_qual(ctx, b, inner, &quals[1..], body, loop_acc_arg);\n b.op_call_flow(cont, loop_block, &[tail_val, cont_val]);\n\n // Pop scope pushed in lower_clause\n ctx.scope.pop(scope_token);\n }\n\n // Structural body\n {\n let (scope_token, body) = lowered.make_body(ctx, b);\n\n // Make an always succeeding dummy guard\n let dummy_guard = {\n let dummy_guard = b.block_insert();\n let guard_ret_cont = b.block_arg_insert(dummy_guard);\n let _guard_throw_cont = b.block_arg_insert(dummy_guard);\n for _bind in lowered.binds.iter() {\n b.block_arg_insert(dummy_guard);\n }\n let true_val = b.value(true);\n b.op_call_flow(dummy_guard, guard_ret_cont, &[true_val]);\n dummy_guard\n };\n let dummy_guard_val = b.value(dummy_guard);\n\n let structural_clause = case_b.container.make_structural(lowered.clause);\n\n // Add to case\n let body_val = b.value(body);\n case_b.push_clause(structural_clause, dummy_guard_val, body_val, b);\n for value in lowered.values.iter() {\n case_b.push_value(*value, b);\n }\n\n let tail_val = ctx.resolve(tail_ident);\n\n // Match on structural means full match failed.\n // We consume the matched binary chunk and proceed\n // to the next iteration.\n b.op_call_flow(body, loop_block, &[tail_val, loop_acc_arg]);\n\n // Pop scope pushed in lower_clause\n ctx.scope.pop(scope_token);\n }\n },\n Err(_) => unimplemented!(),\n }\n\n case_b.finish(loop_block_head, b);\n\n //let structual_pattern = make_structural_bin_pattern(&mut case_b.container, &gen.expr);\n\n (break_block, break_arg)\n },\n expr => {\n let bool_val = map_block!(block, lower_single_same_scope(ctx, b, block, expr));\n let span = expr.span();\n let (true_block, false_block, else_block) = b.op_if_bool(span, block, bool_val);\n\n let join_block = b.block_insert();\n let join_arg = b.block_arg_insert(join_block);\n\n let (cont, cont_val) = lower_qual(ctx, b, inner, &quals[1..], true_block, acc);\n b.op_call_flow(cont, join_block, &[cont_val]);\n\n b.op_call_flow(false_block, join_block, &[acc]);\n b.op_call_flow(else_block, join_block, &[acc]);\n\n (join_block, join_arg)\n }\n }\n }\n}\n\npub(super) fn lower_list_comprehension_expr(\n ctx: &mut LowerCtx,\n b: &mut FunctionBuilder,\n mut block: IrBlock,\n compr: &ListComprehension,\n) -> (IrBlock, IrValue) {\n let inner = |ctx: &mut LowerCtx, b: &mut FunctionBuilder, mut block: IrBlock, acc: IrValue| {\n let span = compr.body.span();\n let val = map_block!(block, lower_single(ctx, b, block, &compr.body));\n let cell = b.prim_list_cell(span, val, acc);\n (block, cell)\n };\n\n let nil = b.value(NilTerm);\n let val = map_block!(\n block,\n lower_qual(ctx, b, &inner, &compr.qualifiers, block, nil)\n );\n ctx.call_function(\n b,\n block,\n compr.span,\n Ident::from_str(\"lists\"),\n Ident::from_str(\"reverse\"),\n &[val],\n )\n}\n\npub(super) fn lower_binary_comprehension_expr(\n ctx: &mut LowerCtx,\n b: &mut FunctionBuilder,\n mut block: IrBlock,\n compr: &BinaryComprehension,\n) -> (IrBlock, IrValue) {\n let inner =\n |ctx: &mut LowerCtx, b: &mut FunctionBuilder, mut block: IrBlock, bin_ref: IrValue| {\n let val = map_block!(block, lower_single(ctx, b, block, &compr.body));\n let spec = BinaryEntrySpecifier::Bytes { unit: 1 };\n let (ok_cont, err_cont) =\n BinaryConstructPush::build(b, block, bin_ref, val, spec, None);\n\n b.op_unreachable(compr.span, err_cont);\n\n let bin_ref = b.block_args(ok_cont)[0];\n (ok_cont, bin_ref)\n };\n\n block = BinaryConstructStart::build(b, block);\n let mut bin_ref = b.block_args(block)[0];\n\n bin_ref = map_block!(\n block,\n lower_qual(ctx, b, &inner, &compr.qualifiers, block, bin_ref)\n );\n\n block = BinaryConstructFinish::build(b, block, bin_ref);\n let res = b.block_args(block)[0];\n\n (block, res)\n}\n" }, { "path": "libeir_syntax_erl/src/lower/expr/literal.rs", "content": "use libeir_ir::constant::{AtomTerm, BinaryTerm, Const, ConstantContainer, NilTerm};\nuse libeir_ir::{Block as IrBlock, FunctionBuilder, Value as IrValue};\n\nuse libeir_diagnostics::{SourceIndex, SourceSpan};\nuse libeir_intern::Ident;\n\nuse crate::util::string_tokenizer::StringTokenizer;\nuse crate::lower::{LowerCtx, LowerError};\n\nuse crate::parser::ast::Literal;\n\npub(super) fn lower_literal(\n ctx: &mut LowerCtx,\n b: &mut FunctionBuilder,\n block: IrBlock,\n literal: &Literal,\n) -> (IrBlock, IrValue) {\n let value = match literal {\n Literal::Atom(_id, ident) => b.value(AtomTerm(ident.name)),\n Literal::Integer(_id, _span, int) => b.value(int.clone()),\n Literal::Float(_id, _span, flt) => b.value(*flt),\n Literal::String(_id, ident) => match intern_string_const(*ident, b.cons_mut()) {\n Ok(cons) => b.value(cons),\n Err(err) => {\n ctx.error(err);\n ctx.sentinel()\n }\n },\n Literal::Char(_id, _span, c) => b.value(*c),\n };\n (block, value)\n}\n\npub fn intern_string_const(ident: Ident, c: &mut ConstantContainer) -> Result {\n let mut chars = Vec::new();\n\n let tokenizer = StringTokenizer::new(ident);\n for elem in tokenizer {\n let (cp, _span) = elem?;\n chars.push(cp);\n }\n\n let mut cons = c.from(NilTerm);\n for elem in chars.iter().rev() {\n let val = c.from(*elem);\n cons = c.list_cell(val, cons);\n }\n\n Ok(c.from(cons))\n}\n" }, { "path": "libeir_syntax_erl/src/lower/expr/map.rs", "content": "use libeir_ir::{\n constant::EmptyMap, Block as IrBlock, FunctionBuilder, MapPutUpdate, Value as IrValue,\n};\n\nuse libeir_diagnostics::SourceSpan;\nuse libeir_intern::Symbol;\n\nuse crate::lower::{lower_single, LowerCtx, LowerError};\nuse crate::parser::ast::{Map, MapField, MapUpdate};\n\npub(super) fn lower_map_update_expr(\n ctx: &mut LowerCtx,\n b: &mut FunctionBuilder,\n mut block: IrBlock,\n map: &MapUpdate,\n) -> (IrBlock, IrValue) {\n let entry_map_val = map_block!(block, lower_single(ctx, b, block, &map.map));\n\n if let Some(cons) = b.fun().value_const(entry_map_val) {\n if b.cons().const_kind(cons).is_map() {\n // TODO: More warnings\n } else {\n ctx.warn(LowerError::MapUpdateOnNonMap { map: map.span });\n }\n }\n\n lower(ctx, b, block, entry_map_val, map.span, &map.updates)\n}\n\npub(super) fn lower_map_expr(\n ctx: &mut LowerCtx,\n b: &mut FunctionBuilder,\n block: IrBlock,\n map: &Map,\n) -> (IrBlock, IrValue) {\n for field in map.fields.iter() {\n match field {\n MapField::Exact { .. } => {\n ctx.error(LowerError::MapUpdateInConstruction {\n map: map.span,\n field: field.span(),\n });\n // No need to generate more than one error here,\n // the user will probably have gotten the point.\n break;\n }\n _ => (),\n }\n }\n\n let empty_map = b.value(EmptyMap);\n lower(ctx, b, block, empty_map, map.span, &map.fields)\n}\n\nfn lower(\n ctx: &mut LowerCtx,\n b: &mut FunctionBuilder,\n mut block: IrBlock,\n old_map: IrValue,\n span: SourceSpan,\n fields: &[MapField],\n) -> (IrBlock, IrValue) {\n let mut map_builder = b.op_map_put_build(span, old_map);\n\n for field in fields.iter() {\n let (key, value, action) = match field {\n MapField::Assoc { key, value, .. } => (key, value, MapPutUpdate::Put),\n MapField::Exact { key, value, .. } => (key, value, MapPutUpdate::Update),\n };\n\n let key_val = map_block!(block, lower_single(ctx, b, block, key));\n let value_val = map_block!(block, lower_single(ctx, b, block, value));\n map_builder.push_kv(key_val, value_val, action, b);\n }\n\n let loc = ctx.current_location(b, span);\n b.block_set_location(block, loc);\n let (ok, fail) = map_builder.finish(block, b);\n\n b.block_set_location(fail, loc);\n\n let typ_val = b.value(Symbol::intern(\"error\"));\n let badmatch_val = b.value(Symbol::intern(\"badkey\"));\n let failed_key = b.block_args(fail)[0];\n let err_val = b.prim_tuple(span, &[badmatch_val, failed_key]);\n ctx.exc_stack\n .make_error_jump(b, span, fail, typ_val, err_val);\n\n (ok, b.block_args(ok)[0])\n}\n" }, { "path": "libeir_syntax_erl/src/lower/expr/mod.rs", "content": "use libeir_ir::constant::NilTerm;\nuse libeir_ir::operation::case::Case;\nuse libeir_ir::{Block as IrBlock, FunctionBuilder, Value as IrValue};\n\nuse libeir_intern::{Ident, Symbol};\n\nuse super::lower_function;\n\nuse super::pattern::lower_clause;\nuse super::{LowerCtx, LowerError};\n\nuse crate::parser::ast::UnaryOp;\nuse crate::parser::ast::{Apply, Remote, UnaryExpr};\nuse crate::parser::ast::{Arity, Name};\nuse crate::parser::ast::{Expr, Literal, Var};\nuse crate::{\n parser::ast::{FunctionName, LocalFunctionName},\n DelayedSubstitution,\n};\n\npub mod literal;\nuse literal::lower_literal;\n\npub mod binary;\nmod binary_expr;\nmod case;\nmod catch;\nmod comprehension;\nmod record;\nmod map;\nmod receive;\n\npub(super) fn lower_block<'a, T>(\n ctx: &mut LowerCtx,\n b: &mut FunctionBuilder,\n block: IrBlock,\n exprs: T,\n) -> (IrBlock, IrValue)\nwhere\n T: IntoIterator,\n{\n let scope_tok = ctx.scope.push();\n let mut block = block;\n let mut value = None;\n let mut loc = None;\n\n for expr in exprs {\n assert!(b.fun().block_kind(block).is_none());\n let (new_block, val) = lower_expr(ctx, b, block, expr);\n loc = Some(b.fun().block_location(block));\n assert!(b.fun().block_kind(new_block).is_none());\n block = new_block;\n value = Some(val);\n }\n\n // This will pop all the scopes that has been pushed by\n // the expressions in the block.\n ctx.scope.pop(scope_tok);\n\n // In the case that this is the last block in a function, we want the\n // location of the return block to be the last expression.\n if let Some(loc) = loc {\n b.block_set_location(block, loc);\n }\n\n (block, value.unwrap())\n}\n\npub(super) fn lower_block_same_scope<'a, T>(\n ctx: &mut LowerCtx,\n b: &mut FunctionBuilder,\n block: IrBlock,\n exprs: T,\n) -> (IrBlock, IrValue)\nwhere\n T: IntoIterator,\n{\n let mut block = block;\n let mut value = None;\n\n for expr in exprs {\n assert!(b.fun().block_kind(block).is_none());\n let (new_block, val) = lower_expr(ctx, b, block, expr);\n assert!(b.fun().block_kind(new_block).is_none());\n block = new_block;\n value = Some(val);\n }\n\n (block, value.unwrap())\n}\n\npub(super) fn lower_single(\n ctx: &mut LowerCtx,\n b: &mut FunctionBuilder,\n block: IrBlock,\n expr: &Expr,\n) -> (IrBlock, IrValue) {\n let scope_tok = ctx.scope.push();\n assert!(b.fun().block_kind(block).is_none());\n let (new_block, val) = lower_expr(ctx, b, block, expr);\n assert!(b.fun().block_kind(new_block).is_none());\n ctx.scope.pop(scope_tok);\n (new_block, val)\n}\n\npub(super) fn lower_single_same_scope(\n ctx: &mut LowerCtx,\n b: &mut FunctionBuilder,\n block: IrBlock,\n expr: &Expr,\n) -> (IrBlock, IrValue) {\n assert!(b.fun().block_kind(block).is_none());\n let (new_block, val) = lower_expr(ctx, b, block, expr);\n assert!(b.fun().block_kind(new_block).is_none());\n (new_block, val)\n}\n\nfn lower_expr(\n ctx: &mut LowerCtx,\n b: &mut FunctionBuilder,\n block: IrBlock,\n expr: &Expr,\n) -> (IrBlock, IrValue) {\n let mut block = block;\n\n let loc = ctx.current_location(b, expr.span());\n b.block_set_location(block, loc);\n\n match expr {\n Expr::Apply(Apply {\n span, callee, args, ..\n }) => {\n let span = *span;\n let mut arg_vals = vec![];\n\n let arity_val = b.value(args.len());\n\n let callee_val = match &**callee {\n Expr::Remote(Remote {\n module, function, ..\n }) => {\n let mod_val = map_block!(block, lower_single(ctx, b, block, module));\n let fun_val = map_block!(block, lower_single(ctx, b, block, function));\n\n b.prim_capture_function(span, mod_val, fun_val, arity_val)\n }\n Expr::Literal(Literal::Atom(_id, name)) => {\n let local = LocalFunctionName {\n span: callee.span(),\n function: *name,\n arity: args.len(),\n };\n\n let (module, function) = if ctx.module.functions.contains_key(&local) {\n (ctx.module.name, *name)\n } else {\n if let Some(resolved) = ctx.module.imports.get(&local) {\n assert!(resolved.arity == args.len());\n (resolved.module, resolved.function)\n } else {\n (ctx.module.name, *name)\n }\n };\n\n let mod_val = b.value(module);\n let fun_val = b.value(function);\n\n b.prim_capture_function(span, mod_val, fun_val, arity_val)\n }\n expr => map_block!(block, lower_single_same_scope(ctx, b, block, expr)),\n };\n\n for arg in args {\n let (new_block, arg_val) = lower_single_same_scope(ctx, b, block, arg);\n block = new_block;\n\n arg_vals.push(arg_val);\n }\n\n let (ok_block, fail_block) = b.op_call_function(span, block, callee_val, &arg_vals);\n b.block_set_location(fail_block, loc);\n\n let fail_type = b.block_args(fail_block)[0];\n let fail_error = b.block_args(fail_block)[1];\n let fail_trace = b.block_args(fail_block)[2];\n ctx.exc_stack\n .make_error_jump_trace(b, fail_block, fail_type, fail_error, fail_trace);\n\n let ok_res = b.block_args(ok_block)[0];\n (ok_block, ok_res)\n }\n Expr::Var(Var(_id, var)) => (block, ctx.resolve(*var)),\n Expr::UnaryExpr(UnaryExpr {\n op, operand, span, ..\n }) => {\n let operand_val = map_block!(block, lower_single(ctx, b, block, operand));\n\n let (block, val) = match op {\n UnaryOp::Not => ctx.call_function(\n b,\n block,\n *span,\n Symbol::intern(\"erlang\"),\n Symbol::intern(\"not\"),\n &[operand_val],\n ),\n UnaryOp::Minus => ctx.call_function(\n b,\n block,\n *span,\n Symbol::intern(\"erlang\"),\n Symbol::intern(\"-\"),\n &[operand_val],\n ),\n UnaryOp::Plus => ctx.call_function(\n b,\n block,\n *span,\n Symbol::intern(\"erlang\"),\n Symbol::intern(\"+\"),\n &[operand_val],\n ),\n UnaryOp::Bnot => ctx.call_function(\n b,\n block,\n *span,\n Symbol::intern(\"erlang\"),\n Symbol::intern(\"bnot\"),\n &[operand_val],\n ),\n };\n\n (block, val)\n }\n Expr::Match(mat) => {\n let match_val = map_block!(block, lower_single_same_scope(ctx, b, block, &mat.expr));\n\n if let Expr::Var(Var(_id, var)) = *mat.pattern {\n // This branch is not required, since the normal pattern match\n // compilation path will cover it just fine.\n // However, since this is a really really common path, we can save\n // ourself a lot of work by just handling variable binding in a\n // simpler way.\n if ctx.scope.resolve(var).is_err() {\n ctx.bind(var, match_val);\n return (block, match_val);\n }\n }\n\n let no_match = b.block_insert();\n b.block_set_location(no_match, loc);\n {\n let typ_val = b.value(Symbol::intern(\"error\"));\n let badmatch_val = b.value(Symbol::intern(\"badmatch\"));\n let err_val = b.prim_tuple(mat.span, &[badmatch_val, match_val]);\n ctx.exc_stack\n .make_error_jump(b, mat.span, no_match, typ_val, err_val);\n }\n\n let mut match_case = Case::builder();\n match_case.set_span(mat.span);\n\n match lower_clause(\n ctx,\n &mut match_case.container,\n b,\n &mut block,\n false,\n mat.span,\n [&mat.pattern].iter().map(|i| &***i),\n None,\n ) {\n Ok(lowered) => {\n let (_scope_token, body) = lowered.make_body(ctx, b);\n\n match_case.match_on = Some(match_val);\n match_case.no_match = Some(b.value(no_match));\n\n // Add clause to match\n let body_val = b.value(body);\n match_case.push_clause(lowered.clause, lowered.guard, body_val, b);\n for value in lowered.values.iter() {\n match_case.push_value(*value, b);\n }\n\n match_case.finish(block, b);\n\n // The scope pushed in lower_case will be popped by the\n // calling `lower_block`.\n\n (body, match_val)\n }\n Err(lowered) => {\n b.op_call_flow(block, no_match, &[]);\n\n let (_scope_token, body) = lowered.make_body(ctx, b);\n\n (body, match_val)\n }\n }\n }\n Expr::Cons(cons) => {\n let head = map_block!(block, lower_single(ctx, b, block, &cons.head));\n let tail = map_block!(block, lower_single(ctx, b, block, &cons.tail));\n let list = b.prim_list_cell(cons.span, head, tail);\n (block, list)\n }\n Expr::Nil(_nil) => {\n let nil_val = b.value(NilTerm);\n (block, nil_val)\n }\n Expr::Tuple(tup) => {\n let mut vals = Vec::new();\n\n for elem in tup.elements.iter() {\n let val = map_block!(block, lower_single_same_scope(ctx, b, block, elem));\n vals.push(val);\n }\n\n let tuple = b.prim_tuple(tup.span, &vals);\n (block, tuple)\n }\n Expr::Fun(fun) => {\n let fun = lower_function(ctx, b, fun);\n (block, b.value(fun))\n }\n Expr::FunctionName(name) => match name {\n FunctionName::Resolved(resolved) => {\n let module = b.value(resolved.module);\n let function = b.value(resolved.function);\n let arity = b.value(resolved.arity);\n\n let fun_val = b.prim_capture_function(resolved.span, module, function, arity);\n\n (block, fun_val)\n }\n FunctionName::PartiallyResolved(partial) => {\n let local = ctx.module.imports.get(&partial.to_local());\n let resolved = if let Some(fun) = local {\n fun.clone()\n } else {\n partial.resolve(ctx.module.name)\n };\n\n let module = b.value(resolved.module);\n let function = b.value(resolved.function);\n let arity = b.value(resolved.arity);\n\n let fun_val = b.prim_capture_function(partial.span, module, function, arity);\n\n (block, fun_val)\n }\n FunctionName::Unresolved(unresolved) => {\n let module = match unresolved.module {\n None => b.value(ctx.module.name),\n Some(Name::Atom(atom)) => b.value(atom),\n Some(Name::Var(var)) => ctx.resolve(var),\n };\n let function = match unresolved.function {\n Name::Atom(atom) => b.value(atom),\n Name::Var(var) => ctx.resolve(var),\n };\n let arity = match unresolved.arity {\n Arity::Int(int) => b.value(int),\n Arity::Var(var) => b.value(var),\n };\n\n let fun_val = b.prim_capture_function(unresolved.span, module, function, arity);\n\n (block, fun_val)\n }\n },\n Expr::Receive(recv) => receive::lower_receive(ctx, b, block, recv),\n Expr::Map(map) => map::lower_map_expr(ctx, b, block, map),\n Expr::MapUpdate(map) => map::lower_map_update_expr(ctx, b, block, map),\n Expr::Begin(begin) => lower_block_same_scope(ctx, b, block, &begin.body),\n Expr::Case(case) => case::lower_case_expr(ctx, b, block, case),\n Expr::If(if_expr) => case::lower_if_expr(ctx, b, block, if_expr),\n Expr::Try(try_expr) => catch::lower_try_expr(ctx, b, block, try_expr),\n Expr::Catch(catch_expr) => catch::lower_catch_expr(ctx, b, block, catch_expr),\n Expr::BinaryExpr(binary_expr) => binary_expr::lower_binary_expr(ctx, b, block, binary_expr),\n Expr::Literal(lit) => lower_literal(ctx, b, block, lit),\n Expr::Record(rec) => record::lower_record_expr(ctx, b, block, rec),\n Expr::RecordAccess(rec) => record::lower_record_access_expr(ctx, b, block, rec),\n Expr::RecordUpdate(rec) => record::lower_record_update_expr(ctx, b, block, rec),\n Expr::RecordIndex(rec) => record::lower_record_index(ctx, b, block, rec),\n Expr::ListComprehension(compr) => {\n comprehension::lower_list_comprehension_expr(ctx, b, block, compr)\n }\n Expr::BinaryComprehension(compr) => {\n comprehension::lower_binary_comprehension_expr(ctx, b, block, compr)\n }\n Expr::Binary(bin) => binary::lower_binary_expr(ctx, b, block, None, bin),\n Expr::DelayedSubstitution(_, id, DelayedSubstitution::FunctionName) => {\n lower_literal(ctx, b, block, &Literal::Atom(*id, b.fun().ident().name))\n }\n Expr::DelayedSubstitution(span, id, DelayedSubstitution::FunctionArity) => lower_literal(\n ctx,\n b,\n block,\n &Literal::Integer(*span, *id, b.fun().ident().arity.into()),\n ),\n Expr::Remote(rem) => {\n ctx.error(LowerError::IllegalExpression { span: rem.span });\n (block, ctx.sentinel())\n }\n Expr::MapProjection(_) => unreachable!(),\n Expr::BinaryGenerator(_) => unreachable!(),\n Expr::Generator(_) => unreachable!(),\n //_ => {\n // unimplemented!(\"{:?}\", expr);\n //}\n }\n}\n" }, { "path": "libeir_syntax_erl/src/lower/expr/receive.rs", "content": "use libeir_intern::Ident;\nuse libeir_ir::{\n operation::case::Case,\n operation::receive::{ReceiveDone, ReceiveStart, ReceiveWait},\n Block as IrBlock, FunctionBuilder, Value as IrValue,\n};\n\nuse crate::{\n lower::{lower_block, lower_single, pattern::lower_clause, LowerCtx},\n parser::ast::Receive,\n};\n\npub(super) fn lower_receive(\n ctx: &mut LowerCtx,\n b: &mut FunctionBuilder,\n mut block: IrBlock,\n recv: &Receive,\n) -> (IrBlock, IrValue) {\n let loc = ctx.current_location(b, recv.span);\n\n let join_block = b.block_insert();\n b.block_set_location(join_block, loc);\n let join_arg = b.block_arg_insert(join_block);\n\n // The timeout time\n let after_timeout_val = if let Some(after) = &recv.after {\n map_block!(block, lower_single(ctx, b, block, &after.timeout))\n } else {\n b.value(Ident::from_str(\"infinity\"))\n };\n\n // Receive start\n let recv_wait_block = ReceiveStart::build(b, block, after_timeout_val);\n b.block_set_location(recv_wait_block, loc);\n let recv_ref_val = b.block_args(recv_wait_block)[0];\n\n // Receive wait\n let (after_block, mut body_block) = ReceiveWait::build(b, recv_wait_block, recv_ref_val);\n b.block_set_location(body_block, loc);\n let body_message_arg = b.block_args(body_block)[0];\n\n // If there is a timeout block, the after code\n if let Some(after) = &recv.after {\n let (after_ret_block, after_ret) = lower_block(ctx, b, after_block, &after.body);\n b.op_call_flow(after_ret_block, join_block, &[after_ret]);\n } else {\n b.block_set_location(after_block, loc);\n b.op_unreachable(recv.span, after_block);\n };\n\n if let Some(clauses) = &recv.clauses {\n let no_match = b.block_insert();\n b.block_set_location(no_match, loc);\n b.op_call_flow(no_match, recv_wait_block, &[recv_ref_val]);\n\n let mut case_b = Case::builder();\n case_b.set_span(recv.span);\n case_b.match_on = Some(body_message_arg);\n case_b.no_match = Some(b.value(no_match));\n\n let entry_exc_height = ctx.exc_stack.len();\n\n for clause in clauses.iter() {\n match lower_clause(\n ctx,\n &mut case_b.container,\n b,\n &mut body_block,\n false,\n clause.span,\n [&clause.pattern].iter().map(|i| *i),\n clause.guard.as_ref(),\n ) {\n Ok(lowered) => {\n let scope_token = ctx.scope.push();\n let body = b.block_insert();\n\n let body_loc = ctx.current_location(b, clause.span);\n b.block_set_location(body, body_loc);\n\n // Map all matched values through receive_done.\n // This enables us to do things like copy from\n // a heap fragment to the main process heap.\n let values: Vec<_> = lowered\n .binds\n .iter()\n .map(|_bind| b.block_arg_insert(body))\n .collect();\n let body_mapped = ReceiveDone::build(b, body, recv_ref_val, &values);\n\n for (idx, bind) in lowered.binds.iter().enumerate() {\n if let Some(name) = bind {\n let mapped_val = b.block_args(body_mapped)[idx];\n ctx.bind(*name, mapped_val);\n }\n }\n\n // Add to case\n let body_val = b.value(body);\n case_b.push_clause(lowered.clause, lowered.guard, body_val, b);\n for value in lowered.values.iter() {\n case_b.push_value(*value, b);\n }\n\n let (body_ret_block, body_ret) = lower_block(ctx, b, body_mapped, &clause.body);\n\n // Call to join block\n b.op_call_flow(body_ret_block, join_block, &[body_ret]);\n\n // Pop scope pushed in lower_clause\n ctx.scope.pop(scope_token);\n }\n Err(_lowered) => {}\n }\n assert!(ctx.exc_stack.len() == entry_exc_height)\n }\n\n case_b.finish(body_block, b);\n } else {\n b.op_call_flow(body_block, join_block, &[body_message_arg]);\n }\n\n (join_block, join_arg)\n}\n" }, { "path": "libeir_syntax_erl/src/lower/expr/record.rs", "content": "use libeir_diagnostics::SourceSpan;\nuse libeir_ir::{BinOp as IrBinOp, Block as IrBlock, FunctionBuilder, Value as IrValue};\n\nuse libeir_intern::Symbol;\n\nuse crate::parser::ast::{Record, RecordAccess, RecordIndex, RecordUpdate};\n\nuse crate::lower::expr::lower_single;\nuse crate::lower::{LowerCtx, LowerError};\n\nfn make_rec_fail(\n ctx: &mut LowerCtx,\n b: &mut FunctionBuilder,\n span: SourceSpan,\n recname_val: IrValue,\n) -> IrBlock {\n let fail_block = b.block_insert();\n let block = fail_block;\n\n let fail_type = b.value(Symbol::intern(\"error\")); // TODO double check correct type\n\n let badrecord_val = b.value(Symbol::intern(\"badrecord\"));\n let fail_error = b.prim_tuple(span, &[badrecord_val, recname_val]);\n\n ctx.exc_stack\n .make_error_jump(b, span, block, fail_type, fail_error);\n\n fail_block\n}\n\npub(super) fn lower_record_access_expr(\n ctx: &mut LowerCtx,\n b: &mut FunctionBuilder,\n mut block: IrBlock,\n rec: &RecordAccess,\n) -> (IrBlock, IrValue) {\n let span = rec.span;\n let rec_def = &ctx.module.records[&rec.name.name];\n let recname_val = b.value(rec.name);\n\n let idx = rec_def.field_idx_map[&rec.field];\n\n let fail_block = make_rec_fail(ctx, b, span, recname_val);\n\n let record_val = map_block!(block, lower_single(ctx, b, block, &rec.record));\n\n let mut match_builder = b.op_match_build(span);\n let unpack_ok_block = match_builder.push_tuple(rec_def.record.fields.len() + 1, b);\n let unpack_fail_block = match_builder.push_wildcard(span, b);\n match_builder.finish(block, record_val, b);\n block = unpack_ok_block;\n\n b.op_call_flow(unpack_fail_block, fail_block, &[]);\n\n let recname_test_val = b.block_args(block)[0];\n let rec_field_val = b.block_args(block)[idx + 1];\n\n let eq_cond = b.prim_binop(span, IrBinOp::Equal, recname_test_val, recname_val);\n let eq_fail_block = map_block!(block, b.op_if_bool_strict(span, block, eq_cond));\n b.op_call_flow(eq_fail_block, fail_block, &[]);\n\n (block, rec_field_val)\n}\n\npub(super) fn lower_record_update_expr(\n ctx: &mut LowerCtx,\n b: &mut FunctionBuilder,\n mut block: IrBlock,\n rec: &RecordUpdate,\n) -> (IrBlock, IrValue) {\n let span = rec.span;\n // TODO Warn/error when updates overlap?\n let rec_def = &ctx.module.records[&rec.name.name];\n let recname_val = b.value(rec.name);\n\n let num_fields = rec_def.record.fields.len();\n\n let fail_block = make_rec_fail(ctx, b, span, recname_val);\n\n // Unpack tuple\n let record_val = map_block!(block, lower_single(ctx, b, block, &rec.record));\n\n let mut match_builder = b.op_match_build(span);\n let unpack_ok_block = match_builder.push_tuple(num_fields + 1, b);\n let unpack_fail_block = match_builder.push_wildcard(span, b);\n match_builder.finish(block, record_val, b);\n block = unpack_ok_block;\n\n b.op_call_flow(unpack_fail_block, fail_block, &[]);\n\n // Make a vector with all the values in the unpacked tuple\n let mut elems = Vec::with_capacity(num_fields);\n for idx in 0..num_fields {\n elems.push(b.block_args(block)[idx + 1]);\n }\n\n // Check first tuple element\n let recname_test_val = b.block_args(block)[0];\n let eq_cond = b.prim_binop(span, IrBinOp::Equal, recname_test_val, recname_val);\n let eq_fail_block = map_block!(block, b.op_if_bool_strict(span, block, eq_cond));\n b.op_call_flow(eq_fail_block, fail_block, &[]);\n\n // Update fields\n for update in rec.updates.iter() {\n let idx = rec_def.field_idx_map[&update.name];\n let new_val = map_block!(\n block,\n lower_single(ctx, b, block, update.value.as_ref().unwrap())\n );\n elems[idx] = new_val;\n }\n\n // Create new tuple\n let mut tup_values = Vec::new();\n tup_values.push(recname_val);\n tup_values.extend(elems.iter().cloned());\n let tup = b.prim_tuple(span, &tup_values);\n\n (block, tup)\n}\n\npub(super) fn lower_record_expr(\n ctx: &mut LowerCtx,\n b: &mut FunctionBuilder,\n mut block: IrBlock,\n rec: &Record,\n) -> (IrBlock, IrValue) {\n let span = rec.span;\n let rec_def = &ctx.module.records[&rec.name.name];\n let recname_val = b.value(rec.name);\n\n let num_fields = rec_def.record.fields.len();\n\n let mut elems = vec![None; num_fields];\n\n // Populate values from expression\n for field in rec.fields.iter() {\n let idx = rec_def.field_idx_map[&field.name];\n\n if elems[idx].is_some() {\n ctx.error(LowerError::DuplicateRecordField {\n new: field.name.span,\n old: rec\n .fields\n .iter()\n .find(|f| f.name == field.name)\n .unwrap()\n .name\n .span,\n });\n }\n\n let new_val = map_block!(\n block,\n lower_single(ctx, b, block, field.value.as_ref().unwrap())\n );\n elems[idx] = Some(new_val);\n }\n\n // Fill with defaults\n for (idx, field) in rec_def.record.fields.iter().enumerate() {\n if elems[idx].is_none() {\n let new_val = if let Some(const_expr) = field.value.as_ref() {\n // TODO: Allow only constants. This should be a separate lowering method!\n map_block!(block, lower_single(ctx, b, block, const_expr))\n } else {\n b.value(Symbol::intern(\"undefined\"))\n };\n elems[idx] = Some(new_val);\n }\n }\n\n let mut tup_values = Vec::new();\n tup_values.push(recname_val);\n tup_values.extend(elems.iter().map(|e| e.unwrap()));\n let tup = b.prim_tuple(span, &tup_values);\n\n (block, tup)\n}\n\npub(super) fn lower_record_index(\n ctx: &mut LowerCtx,\n b: &mut FunctionBuilder,\n block: IrBlock,\n rec: &RecordIndex,\n) -> (IrBlock, IrValue) {\n let rec_def = &ctx.module.records[&rec.name.name];\n let index = rec_def.field_idx_map[&rec.field];\n let val = b.value(index);\n (block, val)\n}\n" }, { "path": "libeir_syntax_erl/src/lower/mod.rs", "content": "use std::sync::Arc;\n\nuse libeir_ir::operation::case::Case;\nuse libeir_ir::{\n Block as IrBlock, FunctionBuilder, IntoValue, Location, Module as IrModule, Value as IrValue,\n};\n\nuse libeir_diagnostics::{CodeMap, SourceSpan};\nuse libeir_intern::{Ident, Symbol};\nuse libeir_util_parse::ErrorReceiver;\n\nuse crate::parser::ast::{Function, FunctionClause, Module, NamedFunction};\nuse crate::evaluator::ResolveRecordIndexError;\n\nmacro_rules! map_block {\n ($block:expr, $call:expr) => {{\n let (block, val) = $call;\n $block = block;\n val\n }};\n}\n\nmod pattern;\nuse pattern::lower_clause;\n\nmod expr;\nuse expr::{lower_block, lower_single};\n\nmod errors;\npub use errors::LowerError;\n\nmod exception_handler_stack;\nuse exception_handler_stack::ExceptionHandlerStack;\n\nmod scope;\nuse scope::ScopeToken;\n\n#[cfg(test)]\nmod tests;\n\npub(crate) struct LowerCtx<'a> {\n codemap: Arc,\n module: &'a Module,\n\n scope: scope::ScopeTracker,\n exc_stack: ExceptionHandlerStack,\n\n sentinel_value: Option,\n\n errors: &'a mut (dyn ErrorReceiver + 'a),\n\n val_buf: Vec,\n\n fun_num: usize,\n /// Top is current function name.\n /// Used to generate debug info.\n functions: Vec,\n\n unique: usize,\n}\n\nimpl<'a> LowerCtx<'a> {\n /// Since we want to catch as many errors as possible in a single\n /// compiler invocation, we frequently purposefully generate invalid\n /// IR so that the lowering process can continue.\n /// In a case where, say, we have an unresolved variable, we need\n /// a dummy value that we can use.\n /// If this value is used in the resulting IR, it is REQUIRED that\n /// `error` be called at least once, which sets the error receiver\n /// to the failed state.\n pub fn sentinel(&self) -> IrValue {\n self.sentinel_value.unwrap()\n }\n\n pub fn error(&mut self, err: LowerError) {\n self.errors.error(err);\n }\n\n pub fn warn(&mut self, err: LowerError) {\n self.errors.warning(err);\n }\n\n pub fn failed(&self) -> bool {\n self.errors.is_failed()\n }\n\n pub fn make_unique(&mut self) -> usize {\n self.unique += 1;\n self.unique\n }\n\n /// Resolves the index of a field in a record.\n pub fn resolve_rec_idx(&self, name: Ident, field: Ident) -> Result {\n let rec = self\n .module\n .records\n .get(&name.name)\n .ok_or(ResolveRecordIndexError::NoRecord)?;\n let idx = rec\n .field_idx_map\n .get(&field)\n .ok_or(ResolveRecordIndexError::NoField)?;\n Ok(*idx)\n }\n\n pub fn resolve(&mut self, ident: Ident) -> IrValue {\n match self.scope.resolve(ident) {\n Ok(val) => val,\n Err(err) => {\n self.error(err);\n self.sentinel()\n }\n }\n }\n\n pub fn bind_shadow(&mut self, ident: Ident, val: IrValue) {\n match self.scope.bind_shadow(ident, val) {\n Ok(()) => (),\n Err(err) => {\n self.warn(err);\n }\n }\n }\n\n pub fn bind(&mut self, ident: Ident, val: IrValue) {\n match self.scope.bind(ident, val) {\n Ok(()) => (),\n Err(err) => {\n self.error(err);\n }\n }\n }\n\n pub fn function_name(&self) -> String {\n self.functions[self.functions.len() - 1].clone()\n }\n pub fn current_location(&self, b: &mut FunctionBuilder, span: SourceSpan) -> Location {\n b.fun_mut().locations.from_bytespan(\n &self.codemap,\n span,\n Some(self.module.name.as_str().to_string()),\n Some(self.function_name()),\n )\n }\n\n pub fn call_function(\n &mut self,\n b: &mut FunctionBuilder,\n block: IrBlock,\n span: SourceSpan,\n m: M,\n f: F,\n args: &[IrValue],\n ) -> (IrBlock, IrValue)\n where\n M: IntoValue,\n F: IntoValue,\n {\n let fun_val = b.prim_capture_function(span, m, f, args.len());\n\n self.val_buf.clear();\n for arg in args.iter() {\n self.val_buf.push(*arg);\n }\n\n let loc = self.current_location(b, span);\n b.block_set_location(block, loc);\n\n let (ok_block, fail_block) = b.op_call_function(span, block, fun_val, args);\n b.block_set_location(fail_block, loc);\n\n let fail_type = b.block_args(fail_block)[0];\n let fail_error = b.block_args(fail_block)[1];\n let fail_trace = b.block_args(fail_block)[2];\n self.exc_stack\n .make_error_jump_trace(b, fail_block, fail_type, fail_error, fail_trace);\n\n let ok_res = b.block_args(ok_block)[0];\n\n (ok_block, ok_res)\n }\n}\n\npub fn lower_module<'a>(\n errors: &'a mut (dyn ErrorReceiver + 'a),\n codemap: Arc,\n module: &Module,\n) -> Result {\n // TODO sort functions for more deterministic compilation\n\n let mut ir_module = IrModule::new_with_span(module.name, module.span);\n\n let mut ctx = LowerCtx {\n codemap,\n module,\n\n scope: scope::ScopeTracker::new(),\n exc_stack: ExceptionHandlerStack::new(),\n\n sentinel_value: None,\n\n errors,\n\n val_buf: Vec::new(),\n\n fun_num: 0,\n functions: Vec::new(),\n\n unique: 0,\n };\n\n for (ident, function) in module.functions.iter() {\n assert!(ctx.scope.height() == 0);\n ctx.fun_num = 0;\n\n let fun_def = ir_module.add_function(function.span, ident.function, function.arity);\n let mut fun = fun_def.function_mut();\n let mut builder = FunctionBuilder::new(&mut fun);\n\n // We do not want the sentinel value to be a constant,\n // since that would interfere with potential constant\n // comparisons while lowering. Insert an orphaned block\n // with an argument that we use.\n // This has the added benefit of generating actually\n // invalid IR when used.\n let sentinel_block = builder.block_insert();\n let sentinel_value = builder.block_arg_insert(sentinel_block);\n ctx.sentinel_value = Some(sentinel_value);\n\n lower_top_function(&mut ctx, &mut builder, function);\n }\n\n ctx.exc_stack.finish();\n\n if ctx.failed() {\n Err(())\n } else {\n Ok(ir_module)\n }\n}\n\nfn lower_function(ctx: &mut LowerCtx, b: &mut FunctionBuilder, fun: &Function) -> IrBlock {\n let entry = b.block_insert_with_span(Some(fun.span()));\n\n ctx.fun_num += 1;\n let base_fun = &ctx.functions[0];\n let new_fun = format!(\"{}-fun-{}\", base_fun, ctx.fun_num);\n ctx.functions.push(new_fun);\n\n match fun {\n Function::Named(named) => {\n let entry_val = b.value(entry);\n ctx.bind(named.name.var(), entry_val);\n\n lower_function_base(ctx, b, entry, named.span, named.arity, &named.clauses);\n }\n Function::Unnamed(lambda) => {\n lower_function_base(ctx, b, entry, lambda.span, lambda.arity, &lambda.clauses);\n }\n }\n\n ctx.functions.pop().unwrap();\n\n entry\n}\n\nfn lower_function_base(\n ctx: &mut LowerCtx,\n b: &mut FunctionBuilder,\n // The block the function should be lowered into\n entry: IrBlock,\n span: SourceSpan,\n arity: usize,\n clauses: &[FunctionClause],\n) {\n let match_loc = ctx.current_location(b, span);\n\n let mut block = entry;\n\n // Ok and Fail continuations\n let ok_cont = b.block_arg_insert(entry);\n let err_cont = b.block_arg_insert(entry);\n\n ctx.exc_stack.push_handler(err_cont);\n\n // Add arguments and pack them into a value list\n let mut args_val = Vec::new();\n for _ in 0..arity {\n let arg = b.block_arg_insert(entry);\n args_val.push(arg);\n }\n let args_list = b.prim_value_list(&args_val);\n\n // Join block after case\n let join_block = b.block_insert();\n b.block_set_location(join_block, match_loc);\n let join_arg = b.block_arg_insert(join_block);\n b.op_call_flow(join_block, ok_cont, &[join_arg]);\n\n // Match fail block\n let match_fail_block = b.block_insert();\n b.block_set_location(match_fail_block, match_loc);\n {\n let typ_val = b.value(Symbol::intern(\"error\"));\n let err_val = b.value(Symbol::intern(\"function_clause\"));\n ctx.exc_stack\n .make_error_jump(b, span, match_fail_block, typ_val, err_val);\n }\n\n let entry_exc_height = ctx.exc_stack.len();\n\n // Top level function case expression\n {\n // TODO: Fuse locations of function heads\n //let mut func_case = b.op_case_build(span);\n let mut func_case = Case::builder();\n func_case.set_span(span);\n\n func_case.match_on = Some(args_list);\n func_case.no_match = Some(b.value(match_fail_block));\n\n for clause in clauses.iter() {\n match lower_clause(\n ctx,\n &mut func_case.container,\n b,\n &mut block,\n true,\n clause.span,\n clause.params.iter(),\n clause.guard.as_ref(),\n ) {\n Ok(lowered) => {\n let (scope_token, body) = lowered.make_body(ctx, b);\n\n // Add to case\n let body_val = b.value(body);\n func_case.push_clause(lowered.clause, lowered.guard, body_val, b);\n for value in lowered.values.iter() {\n func_case.push_value(*value, b);\n }\n\n let (body_ret_block, body_ret) = lower_block(ctx, b, body, &clause.body);\n\n // Call to join block\n b.op_call_flow(body_ret_block, join_block, &[body_ret]);\n\n // Pop scope pushed in lower_clause\n ctx.scope.pop(scope_token);\n }\n // When the pattern of the clause is unmatchable, we don't add it to\n // the case.\n Err(_lowered) => {}\n }\n assert!(ctx.exc_stack.len() == entry_exc_height)\n }\n\n func_case.finish(block, b);\n }\n\n ctx.exc_stack.pop_handler();\n}\n\nfn lower_top_function(ctx: &mut LowerCtx, b: &mut FunctionBuilder, function: &NamedFunction) {\n let entry = b.block_insert();\n b.block_set_entry(entry);\n\n let fun_name = format!(\"{}/{}\", function.name.atom(), function.arity);\n assert!(ctx.functions.len() == 0);\n ctx.functions.push(fun_name);\n\n let loc = ctx.current_location(b, function.span);\n b.block_set_location(entry, loc);\n\n lower_function_base(\n ctx,\n b,\n entry,\n function.span,\n function.arity,\n &function.clauses,\n );\n\n ctx.functions.pop().unwrap();\n assert!(ctx.functions.len() == 0);\n}\n" }, { "path": "libeir_syntax_erl/src/lower/pattern/mod.rs", "content": "use std::collections::HashMap;\n\nuse libeir_diagnostics::SourceSpan;\nuse libeir_ir::pattern::{PatternClause, PatternContainer, PatternValue};\nuse libeir_ir::{Block as IrBlock, FunctionBuilder, Location, LogicOp, Value as IrValue};\n\nuse crate::parser::ast::{Expr, Guard};\n\nuse super::{lower_block, LowerCtx, ScopeToken};\n\nuse libeir_intern::Ident;\n\nmod tree;\nuse tree::Tree;\n\n//use prewalk::{ prewalk_pattern, PrewalkFail };\n//use lower::{ lower_pattern, to_node, PatternRes, LowerFail };\n\nenum EqGuard {\n EqValue(usize, IrValue),\n EqBind(usize, usize),\n}\n\nstruct ClauseLowerCtx {\n span: SourceSpan,\n loc: Location,\n\n // The clause we are constructing\n pat_clause: PatternClause,\n\n /// Patterns can contain a (limited) amount of expressions.\n /// We construct these values before the case structure starts.\n /// This contains the current last block in the control flow\n /// chain of constructed values.\n pre_case: IrBlock,\n\n /// When values are bound when lowering patterns, they are added\n /// here in the same order as they are referenced in the pattern.\n binds: Vec>,\n\n /// Corresponds to PatternValues in the clause\n values: Vec,\n\n // Auxillary equality guards\n // The first value represents the position in the bind list\n eq_guards: Vec,\n\n value_dedup: HashMap,\n}\n\nimpl ClauseLowerCtx {\n pub fn clause_value(&mut self, pat: &mut PatternContainer, val: IrValue) -> PatternValue {\n if let Some(pat_val) = self.value_dedup.get(&val) {\n *pat_val\n } else {\n self.values.push(val);\n pat.clause_value(self.pat_clause)\n }\n }\n}\n\npub(crate) struct LoweredClause {\n pub clause: PatternClause,\n pub guard: IrValue,\n pub values: Vec,\n\n pub shadow: bool,\n pub binds: Vec>,\n}\nimpl LoweredClause {\n pub fn make_body(&self, ctx: &mut LowerCtx, b: &mut FunctionBuilder) -> (ScopeToken, IrBlock) {\n let scope_token = ctx.scope.push();\n let body_block = b.block_insert();\n\n for bind in self.binds.iter() {\n let val = b.block_arg_insert(body_block);\n if let Some(name) = bind {\n if self.shadow {\n ctx.bind_shadow(*name, val);\n } else {\n ctx.bind(*name, val);\n }\n }\n }\n\n (scope_token, body_block)\n }\n}\n\npub(crate) struct UnreachableClause {\n pub shadow: bool,\n pub binds: Vec,\n}\nimpl UnreachableClause {\n pub fn make_body(&self, ctx: &mut LowerCtx, b: &mut FunctionBuilder) -> (ScopeToken, IrBlock) {\n let scope_token = ctx.scope.push();\n let body_block = b.block_insert();\n\n let sentinel = ctx.sentinel();\n for bind in self.binds.iter() {\n if self.shadow {\n ctx.bind_shadow(*bind, sentinel);\n } else {\n ctx.bind(*bind, sentinel);\n }\n }\n\n (scope_token, body_block)\n }\n}\n\n/// When this returns Some:\n/// * A scope will be pushed with the bound variables in the body block\n/// * The body is empty\npub(super) fn lower_clause<'a, P>(\n ctx: &mut LowerCtx,\n pat: &mut PatternContainer,\n b: &mut FunctionBuilder,\n // Once all clauses have been lowered, this is the block where the case\n // operation itself will be lowered into. The lowering logic for a clause\n // can use this to prepend anything it needs done before the pattern\n // starts, like creating needed values.\n // This block should always be empty.\n pre_case: &mut IrBlock,\n shadow: bool,\n span: SourceSpan,\n patterns: P,\n guard: Option<&Vec>,\n) -> Result\nwhere\n P: Iterator,\n{\n assert!(b.fun().block_kind(*pre_case).is_none());\n let loc = ctx.current_location(b, span);\n\n let pat_clause = pat.clause_start(span);\n\n let mut clause_ctx = ClauseLowerCtx {\n span,\n loc,\n\n pat_clause,\n pre_case: *pre_case,\n\n binds: Vec::new(),\n\n values: Vec::new(),\n eq_guards: Vec::new(),\n\n value_dedup: HashMap::new(),\n };\n\n let mut tree = Tree::new();\n for pattern in patterns {\n tree.add_root(ctx, b, &mut clause_ctx.pre_case, pattern);\n }\n tree.process(ctx, b, shadow);\n\n if tree.unmatchable {\n return Err(UnreachableClause {\n shadow,\n binds: tree.pseudo_binds(),\n });\n }\n\n tree.lower(b, pat, &mut clause_ctx);\n\n // Construct guard lambda\n let guard_lambda_block = clause_ctx.lower_guard(ctx, b, shadow, guard);\n\n *pre_case = clause_ctx.pre_case;\n\n // Construct body\n //let scope_token = ctx.scope.push();\n\n // Binds\n //let body_block = b.block_insert();\n\n //for bind in clause_ctx.binds.iter() {\n // let val = b.block_arg_insert(body_block);\n // if let Some(name) = bind {\n // ctx.bind(*name, val);\n // }\n //}\n\n Ok(LoweredClause {\n clause: pat_clause,\n guard: b.value(guard_lambda_block),\n values: clause_ctx.values,\n\n shadow,\n binds: clause_ctx.binds,\n })\n}\n\nimpl ClauseLowerCtx {\n fn lower_guard(\n &self,\n ctx: &mut LowerCtx,\n b: &mut FunctionBuilder,\n shadow: bool,\n guard: Option<&Vec>,\n ) -> IrBlock {\n let guard_lambda_block = b.block_insert();\n b.block_set_location(guard_lambda_block, self.loc);\n\n let ret_cont = b.block_arg_insert(guard_lambda_block);\n let _throw_cont = b.block_arg_insert(guard_lambda_block);\n\n let scope_tok = ctx.scope.push();\n {\n let fail_handler_block = b.block_insert();\n b.block_set_location(fail_handler_block, self.loc);\n b.block_arg_insert(fail_handler_block);\n b.block_arg_insert(fail_handler_block);\n b.block_arg_insert(fail_handler_block);\n let false_val = b.value(false);\n b.op_call_flow(fail_handler_block, ret_cont, &[false_val]);\n ctx.exc_stack.push_handler(b.value(fail_handler_block));\n }\n\n // Binds\n for bind in self.binds.iter() {\n let val = b.block_arg_insert(guard_lambda_block);\n if let Some(name) = bind {\n if shadow {\n let _ = ctx.scope.bind_shadow(*name, val);\n } else {\n ctx.bind(*name, val);\n }\n }\n }\n\n // Body\n let mut block = guard_lambda_block;\n\n let mut top_and = Vec::new();\n\n let erlang_atom = b.value(Ident::from_str(\"erlang\"));\n let exact_eq_atom = b.value(Ident::from_str(\"=:=\"));\n let two_atom = b.value(2);\n\n // Aux guards\n for eq_guard in self.eq_guards.iter() {\n let (lhs, rhs) = match eq_guard {\n EqGuard::EqValue(lhs_idx, rhs) => {\n let lhs = b.block_args(guard_lambda_block)[lhs_idx + 2];\n (lhs, *rhs)\n }\n EqGuard::EqBind(lhs_idx, rhs_idx) => {\n let lhs = b.block_args(guard_lambda_block)[lhs_idx + 2];\n let rhs = b.block_args(guard_lambda_block)[rhs_idx + 2];\n (lhs, rhs)\n }\n };\n\n let fun_val = b.prim_capture_function(self.span, erlang_atom, exact_eq_atom, two_atom);\n\n let (ok_block, err_block) = b.op_call_function(self.span, block, fun_val, &[lhs, rhs]);\n b.block_set_location(block, self.loc);\n let res_val = b.block_args(ok_block)[0];\n block = ok_block;\n\n b.op_unreachable(self.span, err_block);\n b.block_set_location(err_block, self.loc);\n\n top_and.push(res_val);\n }\n\n let mut or = Vec::new();\n let mut and = Vec::new();\n\n // Clause guards\n if let Some(guard_seq) = guard {\n for guard in guard_seq {\n for condition in guard.conditions.iter() {\n let (block_new, val) =\n lower_block(ctx, b, block, [condition].iter().map(|v| *v));\n\n and.push(val);\n block = block_new;\n }\n\n let val = b.prim_logic_op(guard.span, LogicOp::And, &and);\n and.clear();\n or.push(val);\n }\n\n let val = b.prim_logic_op(self.span, LogicOp::Or, &or);\n or.clear();\n top_and.push(val);\n }\n\n let result_bool = b.prim_logic_op(self.span, LogicOp::And, &top_and);\n b.op_call_flow(block, ret_cont, &[result_bool]);\n b.block_set_location(block, self.loc);\n\n ctx.exc_stack.pop_handler();\n ctx.scope.pop(scope_tok);\n\n guard_lambda_block\n }\n}\n" }, { "path": "libeir_syntax_erl/src/lower/pattern/tree/from_expr.rs", "content": "use either::Either;\nuse std::convert::TryInto;\n\nuse cranelift_entity::EntityList;\n\nuse libeir_ir::{\n AtomicTerm, BigIntTerm, BinaryTerm, Block, FloatTerm, FunctionBuilder, IntTerm, NilTerm,\n};\n\nuse libeir_diagnostics::SourceSpan;\nuse libeir_intern::Ident;\n\nuse libeir_util_number::bigint::BigInt;\n\nuse snafu::ResultExt;\n\nuse crate::evaluator::{eval_expr, ResolveRecordIndexError, Term};\nuse crate::lower::{lower_single, LowerCtx, LowerError};\nuse crate::util::string_tokenizer::StringTokenizer;\nuse crate::parser::ast::{Binary, BinaryExpr, BinaryOp, Expr, Literal, UnaryExpr, UnaryOp, Var};\n\nuse super::{Tree, TreeNode, TreeNodeKind};\n\nfn pattern_to_tree_node_append_tail(\n ctx: &mut LowerCtx,\n b: &mut FunctionBuilder,\n pre_block: &mut Block,\n t: &mut Tree,\n expr: &Expr,\n tail: TreeNode,\n span: SourceSpan,\n) -> TreeNode {\n match expr {\n Expr::Literal(Literal::String(_id, ident)) => {\n let mut tokens = Vec::new();\n\n let tokenizer = StringTokenizer::new(*ident);\n for elem in tokenizer {\n match elem {\n Ok((cp, _span)) => {\n tokens.push(cp);\n },\n Err(err) => {\n ctx.error(err.into());\n return t.nodes.push(TreeNodeKind::Wildcard(span));\n },\n }\n }\n\n let mut node = tail;\n for c in tokens.iter().rev() {\n let head = t\n .nodes\n .push(TreeNodeKind::Atomic(span, b.cons_mut().from(*c)));\n node = t.nodes.push(TreeNodeKind::Cons {\n span,\n head,\n tail: node,\n });\n }\n\n node\n }\n Expr::Nil(_) => tail,\n Expr::Cons(cons) => {\n let tail =\n pattern_to_tree_node_append_tail(ctx, b, pre_block, t, &cons.tail, tail, span);\n let head = pattern_to_tree_node(ctx, b, pre_block, t, &cons.head);\n\n t.nodes.push(TreeNodeKind::Cons {\n span,\n head,\n tail,\n })\n }\n _ => unimplemented!(\"{:?}\", expr),\n }\n}\n\nimpl Tree {\n pub(crate) fn add_root(\n &mut self,\n ctx: &mut LowerCtx,\n b: &mut FunctionBuilder,\n pre_block: &mut Block,\n expr: &Expr,\n ) {\n let root = pattern_to_tree_node(ctx, b, pre_block, self, expr);\n self.roots.push(root);\n }\n}\n\nfn pattern_to_tree_node(\n ctx: &mut LowerCtx,\n b: &mut FunctionBuilder,\n pre_block: &mut Block,\n t: &mut Tree,\n expr: &Expr,\n) -> TreeNode {\n match expr {\n Expr::Nil(nil) => {\n let cons = b.cons_mut().from(NilTerm);\n t.nodes.push(TreeNodeKind::Atomic(nil.0, cons))\n }\n Expr::Literal(lit) => {\n let cons = match lit {\n Literal::Atom(_id, ident) => b.cons_mut().from(*ident).into(),\n Literal::Char(_span, _id, c) => b.cons_mut().from(*c).into(),\n Literal::Integer(_span, _id, num) => b.cons_mut().from(num.clone()).into(),\n Literal::Float(_span, _id, num) => b.cons_mut().from(*num).into(),\n Literal::String(_id, ident) => {\n let mut chars = Vec::new();\n\n let tokenizer = StringTokenizer::new(*ident);\n for elem in tokenizer {\n match elem {\n Ok((cp, _span)) => {\n chars.push(cp);\n },\n Err(err) => {\n ctx.error(err.into());\n return t.nodes.push(TreeNodeKind::Wildcard(ident.span));\n },\n }\n }\n\n let nil_const = b.cons_mut().from(NilTerm);\n let mut node =\n t.nodes.push(TreeNodeKind::Atomic(ident.span, nil_const));\n\n for c in chars.iter().rev() {\n let char_const = b.cons_mut().from(*c);\n let head =\n t.nodes.push(TreeNodeKind::Atomic(ident.span, char_const));\n\n node = t.nodes.push(TreeNodeKind::Cons {\n span: ident.span,\n head,\n tail: node,\n });\n }\n\n return node;\n }\n };\n t.nodes.push(TreeNodeKind::Atomic(lit.span(), cons))\n }\n Expr::Match(match_expr) => {\n let left = pattern_to_tree_node(ctx, b, pre_block, t, &match_expr.pattern);\n let right = pattern_to_tree_node(ctx, b, pre_block, t, &match_expr.expr);\n t.nodes.push(TreeNodeKind::And { left, right })\n }\n Expr::Var(Var(_id, var)) => {\n let node = t.nodes.push(TreeNodeKind::Wildcard(expr.span()));\n if !crate::lower::scope::is_wildcard(*var) {\n t.binds[node].push(*var);\n }\n node\n }\n Expr::Tuple(tup) => {\n let mut elems = EntityList::new();\n for elem in tup.elements.iter() {\n let node = pattern_to_tree_node(ctx, b, pre_block, t, elem);\n elems.push(node, &mut t.node_pool);\n }\n t.nodes.push(TreeNodeKind::Tuple {\n span: tup.span,\n elems,\n })\n }\n Expr::Cons(cons) => {\n let head = pattern_to_tree_node(ctx, b, pre_block, t, &cons.head);\n let tail = pattern_to_tree_node(ctx, b, pre_block, t, &cons.tail);\n t.nodes.push(TreeNodeKind::Cons {\n span: cons.span,\n head,\n tail,\n })\n }\n Expr::Record(rec) => {\n let span = expr.span();\n if !ctx.module.records.contains_key(&rec.name.name) {\n ctx.error(LowerError::UndefinedRecord {\n span: rec.name.span,\n });\n return t.nodes.push(TreeNodeKind::Wildcard(span));\n }\n\n let rec_def = &ctx.module.records[&rec.name.name];\n\n let name = b.cons_mut().from(rec.name);\n let name_node = t.nodes.push(TreeNodeKind::Atomic(rec.name.span, name));\n\n let mut pat_fields = vec![];\n for _ in 0..rec_def.record.fields.len() {\n pat_fields.push(t.nodes.push(TreeNodeKind::Wildcard(span)));\n }\n\n for field in rec.fields.iter() {\n let idx = rec_def.field_idx_map[&field.name];\n\n let node =\n pattern_to_tree_node(ctx, b, pre_block, t, &field.value.as_ref().unwrap());\n\n let prev = pat_fields[idx];\n pat_fields[idx] = t.nodes.push(TreeNodeKind::And {\n left: prev,\n right: node,\n });\n }\n\n let mut elems = EntityList::new();\n elems.push(name_node, &mut t.node_pool);\n for field in pat_fields {\n elems.push(field, &mut t.node_pool);\n }\n t.nodes.push(TreeNodeKind::Tuple {\n span: rec.span,\n elems,\n })\n }\n Expr::BinaryExpr(BinaryExpr {\n op: BinaryOp::Append,\n lhs,\n rhs,\n span,\n ..\n }) => {\n let tail = pattern_to_tree_node(ctx, b, pre_block, t, rhs);\n pattern_to_tree_node_append_tail(ctx, b, pre_block, t, lhs, tail, *span)\n }\n Expr::Binary(Binary { span, elements, .. }) => {\n use crate::parser::binary::{default_specifier, specifier_can_have_size, specifier_to_typename, TypeName};\n\n // Desugar <<\"binary string\">>\n if elements.len() == 1 {\n let elem = &elements[0];\n if elem.bit_size.is_none() && elem.specifier.is_none() {\n if let Expr::Literal(Literal::String(_id, string)) = &elem.bit_expr {\n let mut chars = Vec::new();\n\n let tokenizer = StringTokenizer::new(*string);\n for elem in tokenizer {\n match elem {\n Ok((cp, _span)) => {\n chars.push(cp);\n },\n Err(err) => {\n ctx.error(err.into());\n return t.nodes.push(TreeNodeKind::Wildcard(string.span));\n },\n }\n }\n\n let bin =\n chars.iter().map(|ch| (ch & 0xff) as u8).collect::>();\n let cons = b.cons_mut().from(bin);\n return t.nodes.push(TreeNodeKind::Atomic(*span, cons));\n }\n }\n }\n\n let mut bin_node = None;\n //let mut bin_node = t.nodes.push(TreeNodeKind::Atomic(\n // span.clone(),\n // b.cons_mut().from(Vec::::new()),\n //));\n\n for (_idx, elem) in elements.iter().enumerate().rev() {\n let spec = elem\n .specifier\n .unwrap_or(default_specifier());\n\n let spec_typ = specifier_to_typename(&spec);\n\n let bit_val = pattern_to_tree_node(ctx, b, pre_block, t, &elem.bit_expr);\n\n let size_val = if let Some(size_expr) = &elem.bit_size {\n if !specifier_can_have_size(&spec) {\n ctx.error(LowerError::BinaryInvalidSize {\n span: size_expr.span(),\n typ: spec_typ,\n });\n None\n } else {\n let ret = match size_expr {\n Expr::Var(Var(_id, var)) => Either::Left(*var),\n _ => {\n let (block, val) = lower_single(ctx, b, *pre_block, size_expr);\n *pre_block = block;\n Either::Right(val)\n }\n };\n Some(ret)\n }\n } else {\n match spec_typ {\n TypeName::Integer => Some(b.value(8)),\n TypeName::Float => Some(b.value(64)),\n _ => None,\n }\n .map(Either::Right)\n };\n\n bin_node = Some(t.nodes.push(TreeNodeKind::Binary {\n span: *span,\n specifier: spec,\n size: size_val,\n size_resolved: None,\n value: bit_val,\n tail: bin_node,\n }));\n }\n\n bin_node.unwrap_or_else(|| {\n t.nodes.push(TreeNodeKind::Atomic(\n span.clone(),\n b.cons_mut().from(Vec::::new()),\n ))\n })\n }\n Expr::Map(map) => {\n let mut entries = Vec::new();\n for field in map.fields.iter() {\n let (block, key) = lower_single(ctx, b, *pre_block, &field.key());\n *pre_block = block;\n\n let val = pattern_to_tree_node(ctx, b, pre_block, t, &field.value());\n\n entries.push((key, val));\n }\n t.nodes.push(TreeNodeKind::Map {\n span: map.span,\n entries,\n })\n }\n expr => {\n let resolve_rec_idx = |name: Ident, field: Ident| {\n ctx.resolve_rec_idx(name, field)\n };\n match eval_expr(expr, Some(&resolve_rec_idx)) {\n Ok(term) => {\n let constant = match term {\n Term::Number(num) => b.cons_mut().from(num),\n _ => unreachable!(),\n };\n t.nodes.push(TreeNodeKind::Atomic(expr.span(), constant))\n }\n Err(error) => {\n ctx.error(LowerError::PatternConst {\n source: error,\n span: expr.span(),\n });\n\n // In this path compilation has failed.\n // Add a wildcard to don't affect other parts of the compilation.\n t.nodes.push(TreeNodeKind::Wildcard(expr.span()))\n }\n }\n }\n }\n}\n" }, { "path": "libeir_syntax_erl/src/lower/pattern/tree/lower.rs", "content": "use std::collections::{BTreeMap, HashMap};\n\nuse either::Either;\n\nuse libeir_intern::Ident;\nuse libeir_ir::pattern::PatternContainer;\nuse libeir_ir::{FunctionBuilder, PatternNode};\n\nuse super::super::{ClauseLowerCtx, EqGuard};\nuse super::{ConstraintKind, Tree, TreeNode, TreeNodeKind};\n\nimpl Tree {\n pub(in super::super) fn lower(\n &self,\n b: &mut FunctionBuilder,\n pat: &mut PatternContainer,\n cl_ctx: &mut ClauseLowerCtx,\n ) {\n let mut node_map = BTreeMap::new();\n\n for root in self.roots.iter() {\n create_nodes(b, pat, self, &mut node_map, *root);\n }\n\n for root in self.roots.iter() {\n let lowered = lower_tree_node(b, pat, cl_ctx, &node_map, self, *root);\n pat.clause_node_push(cl_ctx.pat_clause, lowered);\n }\n\n let mut node_binds_map = HashMap::new();\n for (ident, node) in self.resolved_binds.as_ref().unwrap() {\n let new_bind_idx = cl_ctx.binds.len();\n node_binds_map.insert(*node, new_bind_idx);\n\n cl_ctx.binds.push(Some(*ident));\n let pat_node = node_map[node];\n pat.clause_bind_push(cl_ctx.pat_clause, pat_node);\n }\n\n for (node, constraints) in self.constraints.iter() {\n if constraints.len() == 0 {\n continue;\n }\n let pat_node = node_map[&node];\n\n let new_bind_idx = cl_ctx.binds.len();\n cl_ctx.binds.push(None);\n pat.clause_bind_push(cl_ctx.pat_clause, pat_node);\n\n for constraint in constraints.iter() {\n match constraint {\n ConstraintKind::Value(val) => {\n cl_ctx.eq_guards.push(EqGuard::EqValue(new_bind_idx, *val));\n }\n ConstraintKind::Const(cons) => {\n let val = b.value(*cons);\n cl_ctx.eq_guards.push(EqGuard::EqValue(new_bind_idx, val));\n }\n ConstraintKind::PrimOp(prim) => {\n let val = b.value(*prim);\n cl_ctx.eq_guards.push(EqGuard::EqValue(new_bind_idx, val));\n }\n ConstraintKind::Node(node) => {\n let bind_idx = node_binds_map[node];\n cl_ctx\n .eq_guards\n .push(EqGuard::EqBind(new_bind_idx, bind_idx));\n }\n }\n }\n }\n }\n\n pub fn pseudo_binds(&self) -> Vec {\n self.resolved_binds\n .as_ref()\n .unwrap()\n .keys()\n .cloned()\n .collect()\n }\n}\n\nfn create_nodes(\n b: &mut FunctionBuilder,\n pat: &mut PatternContainer,\n t: &Tree,\n map: &mut BTreeMap,\n node: TreeNode,\n) {\n assert!(!map.contains_key(&node));\n\n let span = t.node_span(node);\n let p_node = pat.node_empty(Some(span));\n map.insert(node, p_node);\n\n match &t.nodes[node] {\n TreeNodeKind::Atomic(_, _) => (),\n TreeNodeKind::Value(_, _) => (),\n TreeNodeKind::Wildcard(_) => (),\n TreeNodeKind::Tuple { elems, .. } => {\n for elem in elems.as_slice(&t.node_pool) {\n create_nodes(b, pat, t, map, *elem);\n }\n }\n TreeNodeKind::Cons { head, tail, .. } => {\n create_nodes(b, pat, t, map, *head);\n create_nodes(b, pat, t, map, *tail);\n }\n TreeNodeKind::Binary { value, tail, .. } => {\n create_nodes(b, pat, t, map, *value);\n if let Some(tail_node) = tail {\n create_nodes(b, pat, t, map, *tail_node);\n }\n }\n TreeNodeKind::Map { entries, .. } => {\n for (_, v) in entries {\n create_nodes(b, pat, t, map, *v);\n }\n }\n _ => unreachable!(),\n }\n}\n\nfn lower_tree_node(\n b: &mut FunctionBuilder,\n pat: &mut PatternContainer,\n cl_ctx: &mut ClauseLowerCtx,\n map: &BTreeMap,\n t: &Tree,\n node: TreeNode,\n) -> PatternNode {\n let p_node = map[&node];\n\n match &t.nodes[node] {\n TreeNodeKind::Atomic(span, cons) => {\n pat.constant(p_node, *cons);\n pat.node_set_span(p_node, *span);\n }\n TreeNodeKind::Value(span, Either::Left(val)) => {\n let cl_val = cl_ctx.clause_value(pat, *val);\n\n pat.value(p_node, cl_val);\n pat.node_set_span(p_node, *span);\n }\n TreeNodeKind::Value(_, Either::Right(_node)) => unimplemented!(),\n TreeNodeKind::Wildcard(_) => {\n pat.wildcard(p_node);\n }\n TreeNodeKind::Tuple { span, elems } => {\n pat.tuple(p_node);\n for elem in elems.as_slice(&t.node_pool) {\n let child = lower_tree_node(b, pat, cl_ctx, map, t, *elem);\n pat.tuple_elem_push(p_node, child);\n }\n pat.node_finish(p_node);\n pat.node_set_span(p_node, *span);\n }\n TreeNodeKind::Cons { span, head, tail } => {\n let head_n = lower_tree_node(b, pat, cl_ctx, map, t, *head);\n let tail_n = lower_tree_node(b, pat, cl_ctx, map, t, *tail);\n pat.list(p_node, head_n, tail_n);\n pat.node_set_span(p_node, *span);\n }\n TreeNodeKind::Binary {\n span,\n specifier,\n size_resolved,\n value,\n tail,\n ..\n } => {\n let size = size_resolved.map(|s| match s {\n Either::Left(node) => {\n let pat_node = map[&node];\n pat.clause_node_value(cl_ctx.pat_clause, pat_node)\n }\n Either::Right(val) => cl_ctx.clause_value(pat, val),\n });\n\n let value_n = lower_tree_node(b, pat, cl_ctx, map, t, *value);\n let tail_n = tail.map(|n| lower_tree_node(b, pat, cl_ctx, map, t, n));\n pat.binary(p_node, *specifier, value_n, size, tail_n);\n pat.node_set_span(p_node, *span);\n }\n TreeNodeKind::Map { span, entries } => {\n pat.map(p_node);\n for (k, v) in entries {\n let key = cl_ctx.clause_value(pat, *k);\n let val = lower_tree_node(b, pat, cl_ctx, map, t, *v);\n pat.map_push(p_node, key, val);\n }\n pat.node_set_span(p_node, *span);\n }\n _ => unreachable!(),\n }\n\n p_node\n}\n" }, { "path": "libeir_syntax_erl/src/lower/pattern/tree/merge.rs", "content": "//! Merges And nodes in the pattern tree\n\nuse std::collections::{BTreeMap, BTreeSet};\n\nuse libeir_ir::FunctionBuilder;\n\nuse cranelift_entity::EntityList;\n\nuse super::{Tree, TreeNode, TreeNodeKind};\nuse crate::lower::{LowerCtx, LowerError};\n\npub(crate) fn merge_tree_nodes(ctx: &mut LowerCtx, b: &mut FunctionBuilder, t: &mut Tree) {\n let num_root = t.roots.len();\n for n in 0..num_root {\n let root = t.roots[n];\n let new = map_node(ctx, b, t, root);\n t.roots[n] = new;\n }\n}\n\nfn map_node(ctx: &mut LowerCtx, b: &mut FunctionBuilder, t: &mut Tree, node: TreeNode) -> TreeNode {\n let new = match t.nodes[node].clone() {\n TreeNodeKind::Atomic(_, _) => node,\n TreeNodeKind::Wildcard(_) => node,\n TreeNodeKind::Tuple { span, elems } => {\n let mut new_elems = EntityList::new();\n for idx in 0..elems.len(&t.node_pool) {\n let node = elems.get(idx, &t.node_pool).unwrap();\n let new = map_node(ctx, b, t, node);\n new_elems.push(new, &mut t.node_pool);\n }\n t.nodes.push(TreeNodeKind::Tuple {\n span,\n elems: new_elems,\n })\n }\n TreeNodeKind::Cons { span, head, tail } => {\n let new_head = map_node(ctx, b, t, head);\n let new_tail = map_node(ctx, b, t, tail);\n t.nodes.push(TreeNodeKind::Cons {\n span,\n head: new_head,\n tail: new_tail,\n })\n }\n TreeNodeKind::Binary {\n span,\n specifier,\n size,\n size_resolved,\n value,\n tail,\n } => {\n let n_value = map_node(ctx, b, t, value);\n let n_tail = tail.map(|n| map_node(ctx, b, t, n));\n t.nodes.push(TreeNodeKind::Binary {\n span,\n specifier,\n size,\n size_resolved,\n value: n_value,\n tail: n_tail,\n })\n }\n TreeNodeKind::Map { span, entries } => {\n let mut dedup = BTreeMap::new();\n for (k, v) in entries.iter() {\n if let Some(old) = dedup.get(k) {\n let new = t.nodes.push(TreeNodeKind::And {\n left: *old,\n right: *v,\n });\n dedup.insert(*k, new);\n } else {\n dedup.insert(*k, *v);\n }\n }\n let new_entries: Vec<_> = dedup\n .iter()\n .map(|(k, v)| (*k, map_node(ctx, b, t, *v)))\n .collect();\n t.nodes.push(TreeNodeKind::Map {\n span,\n entries: new_entries,\n })\n }\n TreeNodeKind::And { left, right } => merge_nodes(ctx, b, t, left, right),\n _ => unreachable!(),\n };\n t.rename(node, new);\n new\n}\n\nfn merge_nodes(\n ctx: &mut LowerCtx,\n b: &mut FunctionBuilder,\n t: &mut Tree,\n left: TreeNode,\n right: TreeNode,\n) -> TreeNode {\n let left = map_node(ctx, b, t, left);\n let l_kind = t.nodes[left].clone();\n\n let right = map_node(ctx, b, t, right);\n let r_kind = t.nodes[right].clone();\n\n let new = match (l_kind, r_kind) {\n (TreeNodeKind::Wildcard(_), _) => right,\n (_, TreeNodeKind::Wildcard(_)) => left,\n (TreeNodeKind::Atomic(s1, c1), TreeNodeKind::Atomic(s2, c2)) => {\n if c1 == c2 {\n t.nodes.push(TreeNodeKind::Atomic(s1, c1))\n } else {\n ctx.warn(LowerError::DisjointPatternUnionWarning {\n left: Some(s1),\n right: Some(s2),\n });\n t.unmatchable = true;\n t.nodes.push(TreeNodeKind::Wildcard(s1))\n }\n }\n (\n TreeNodeKind::Tuple {\n span: s1,\n elems: e1,\n },\n TreeNodeKind::Tuple {\n span: s2,\n elems: e2,\n },\n ) => {\n let len1 = e1.len(&t.node_pool);\n if len1 != e2.len(&t.node_pool) {\n ctx.warn(LowerError::DisjointPatternUnionWarning {\n left: Some(s1),\n right: Some(s2),\n });\n t.unmatchable = true;\n t.nodes.push(TreeNodeKind::Wildcard(s1))\n } else {\n let mut elems = EntityList::new();\n for idx in 0..len1 {\n let l = e1.get(idx, &t.node_pool).unwrap();\n let r = e2.get(idx, &t.node_pool).unwrap();\n let merged = merge_nodes(ctx, b, t, l, r);\n elems.push(merged, &mut t.node_pool);\n }\n t.nodes.push(TreeNodeKind::Tuple { span: s1, elems })\n }\n }\n (\n TreeNodeKind::Cons {\n span: s1,\n head: h1,\n tail: t1,\n },\n TreeNodeKind::Cons {\n span: _s2,\n head: h2,\n tail: t2,\n },\n ) => {\n let h_m = merge_nodes(ctx, b, t, h1, h2);\n let t_m = merge_nodes(ctx, b, t, t1, t2);\n t.nodes.push(TreeNodeKind::Cons {\n span: s1,\n head: h_m,\n tail: t_m,\n })\n }\n (TreeNodeKind::Binary { .. }, TreeNodeKind::Binary { .. }) => unimplemented!(),\n (TreeNodeKind::Map { entries: e_l, span }, TreeNodeKind::Map { entries: e_r, .. }) => {\n // Entries vectors should already be sorted\n debug_assert!(e_l.windows(2).all(|w| w[0].0 < w[1].0));\n debug_assert!(e_r.windows(2).all(|w| w[0].0 < w[1].0));\n\n let left: BTreeSet<_> = e_l.iter().map(|(k, _v)| *k).collect();\n let right: BTreeSet<_> = e_r.iter().map(|(k, _v)| *k).collect();\n\n let mut new = Vec::new();\n\n // Merge the intersection of the two maps\n let mut l_iter = e_l.iter();\n let mut r_iter = e_r.iter();\n for key in left.intersection(&right) {\n let l_n = l_iter.find(|(k, _v)| k == key).map(|(_k, v)| *v).unwrap();\n let r_n = r_iter.find(|(k, _v)| k == key).map(|(_k, v)| *v).unwrap();\n\n let merged = merge_nodes(ctx, b, t, l_n, r_n);\n new.push((*key, merged));\n }\n\n // Map over the left and right differences\n let mut l_iter = e_l.iter();\n for key in left.difference(&right) {\n let l_n = l_iter.find(|(k, _v)| k == key).map(|(_k, v)| *v).unwrap();\n\n let node = map_node(ctx, b, t, l_n);\n new.push((*key, node));\n }\n\n let mut r_iter = e_r.iter();\n for key in right.difference(&left) {\n let r_n = r_iter.find(|(k, _v)| k == key).map(|(_k, v)| *v).unwrap();\n\n let node = map_node(ctx, b, t, r_n);\n new.push((*key, node));\n }\n\n new.sort_by(|(k1, _), (k2, _)| k1.cmp(k2));\n\n t.nodes.push(TreeNodeKind::Map { span, entries: new })\n }\n (TreeNodeKind::And { .. }, TreeNodeKind::And { .. }) => unreachable!(),\n _ => {\n ctx.warn(LowerError::DisjointPatternUnionWarning {\n left: Some(t.node_span(left)),\n right: Some(t.node_span(right)),\n });\n t.unmatchable = true;\n t.nodes.push(TreeNodeKind::And { left, right })\n }\n };\n\n t.rename(left, new);\n t.rename(right, new);\n\n new\n}\n" }, { "path": "libeir_syntax_erl/src/lower/pattern/tree/mod.rs", "content": "//! Small IR used to do linting and transformations on patterns\n//! before they are lowered to Eir.\n\nuse std::collections::{BTreeSet, HashMap};\n\nuse either::Either;\n\nuse cranelift_entity::{entity_impl, EntityList, ListPool, PrimaryMap, SecondaryMap};\n\nuse libeir_ir::{BinaryEntrySpecifier, Const, FunctionBuilder, PrimOp, Value as IrValue};\n\nuse libeir_diagnostics::SourceSpan;\nuse libeir_intern::Ident;\n\nuse crate::lower::LowerCtx;\n\nmod from_expr;\n\nmod merge;\nuse self::merge::merge_tree_nodes;\n\nmod promote_values;\nuse self::promote_values::promote_values;\n\nmod lower;\n\n#[derive(Debug)]\npub(crate) struct Tree {\n roots: Vec,\n pub unmatchable: bool,\n\n nodes: PrimaryMap,\n node_pool: ListPool,\n\n binds: SecondaryMap>,\n\n constraints: SecondaryMap>,\n resolved_binds: Option>,\n}\nimpl Tree {\n pub fn new() -> Self {\n Tree {\n roots: Vec::new(),\n unmatchable: false,\n\n nodes: PrimaryMap::new(),\n node_pool: ListPool::new(),\n\n binds: SecondaryMap::new(),\n\n constraints: SecondaryMap::new(),\n resolved_binds: None,\n }\n }\n\n pub fn process(&mut self, ctx: &mut LowerCtx, b: &mut FunctionBuilder, shadow: bool) {\n merge_tree_nodes(ctx, b, self);\n promote_values(ctx, b, self, shadow);\n }\n\n pub fn node_span(&self, node: TreeNode) -> SourceSpan {\n match &self.nodes[node] {\n TreeNodeKind::Atomic(span, _) => *span,\n TreeNodeKind::Value(span, _) => *span,\n TreeNodeKind::Wildcard(span) => *span,\n TreeNodeKind::Tuple { span, .. } => *span,\n TreeNodeKind::Cons { span, .. } => *span,\n TreeNodeKind::Binary { span, .. } => *span,\n TreeNodeKind::Map { span, .. } => *span,\n TreeNodeKind::And { left, .. } => self.node_span(*left),\n }\n }\n\n fn rename(&mut self, from: TreeNode, to: TreeNode) {\n if from == to {\n return;\n }\n let len = self.binds[from].len();\n for n in 0..len {\n let ident = self.binds[from][n];\n self.binds[to].push(ident);\n }\n }\n}\n\n#[derive(Copy, Clone, Hash, PartialEq, Eq, PartialOrd, Ord)]\npub(crate) struct TreeNode(u32);\nentity_impl!(TreeNode, \"tree_node\");\n\n#[derive(Debug, Clone)]\npub(crate) enum TreeNodeKind {\n /// This must be an atomic value.\n /// Compound types are not allowed.\n Atomic(SourceSpan, Const),\n\n // Promoted to in a late pass.\n Value(SourceSpan, Either),\n\n Wildcard(SourceSpan),\n Tuple {\n span: SourceSpan,\n elems: EntityList,\n },\n Cons {\n span: SourceSpan,\n head: TreeNode,\n tail: TreeNode,\n },\n Binary {\n span: SourceSpan,\n specifier: BinaryEntrySpecifier,\n size: Option>,\n size_resolved: Option>,\n value: TreeNode,\n tail: Option,\n },\n Map {\n span: SourceSpan,\n entries: Vec<(IrValue, TreeNode)>,\n },\n\n And {\n left: TreeNode,\n right: TreeNode,\n },\n}\n\n#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq, PartialOrd, Ord)]\npub(crate) enum ConstraintKind {\n Value(IrValue),\n Const(Const),\n PrimOp(PrimOp),\n Node(TreeNode),\n}\nimpl ConstraintKind {\n fn constant(&self) -> Option {\n if let ConstraintKind::Const(cons) = self {\n Some(*cons)\n } else {\n None\n }\n }\n fn primop(&self) -> Option {\n if let ConstraintKind::PrimOp(prim) = self {\n Some(*prim)\n } else {\n None\n }\n }\n fn value(&self) -> Option {\n if let ConstraintKind::Value(val) = self {\n Some(*val)\n } else {\n None\n }\n }\n}\n" }, { "path": "libeir_syntax_erl/src/lower/pattern/tree/promote_values.rs", "content": "//! Resolves values, promotes nodes to values, applies constraints\n\nuse either::Either;\nuse std::collections::{BTreeSet, HashMap};\n\nuse libeir_ir::{FunctionBuilder, Value as IrValue, ValueKind};\n\nuse libeir_intern::Ident;\n\nuse libeir_util_datastructures::hashmap_stack::HashMapStack;\n\nuse super::{ConstraintKind, Tree, TreeNode, TreeNodeKind};\nuse crate::lower::{LowerCtx, LowerError};\n\nstruct PromoteCtx<'a, 'b> {\n ctx: &'a mut LowerCtx<'b>,\n binds: HashMap,\n binds_scope: HashMapStack,\n shadow: bool,\n}\nimpl<'a, 'b> PromoteCtx<'a, 'b> {\n fn resolve_or_bind(\n &mut self,\n hier: bool,\n ident: Ident,\n node: TreeNode,\n ) -> Option> {\n if hier {\n self.binds_scope.insert(ident, node);\n }\n if self.shadow {\n if let Some(bound_node) = self.binds.get(&ident) {\n Some(Either::Left(*bound_node))\n } else {\n self.bind(ident, node);\n None\n }\n } else {\n if let Ok(prev_bound) = self.ctx.scope.resolve(ident) {\n Some(Either::Right(prev_bound))\n } else {\n if let Some(bound_node) = self.binds.get(&ident) {\n Some(Either::Left(*bound_node))\n } else {\n self.bind(ident, node);\n None\n }\n }\n }\n }\n\n fn resolve_only(&self, ident: Ident) -> Option> {\n if let Some(bound_node) = self.binds_scope.get(&ident) {\n Some(Either::Left(*bound_node))\n } else {\n if let Ok(prev_bound) = self.ctx.scope.resolve(ident) {\n Some(Either::Right(prev_bound))\n } else {\n None\n }\n }\n }\n\n fn bind(&mut self, ident: Ident, node: TreeNode) -> Option {\n let res = if let Some(prev) = self.binds.get(&ident) {\n if *prev == node {\n None\n } else {\n Some(*prev)\n }\n } else {\n self.binds.insert(ident, node);\n None\n };\n res\n }\n}\n\npub(crate) fn promote_values(\n ctx: &mut LowerCtx,\n b: &mut FunctionBuilder,\n t: &mut Tree,\n shadow: bool,\n) {\n let mut prom = PromoteCtx {\n ctx,\n binds: HashMap::new(),\n binds_scope: HashMapStack::new(),\n shadow,\n };\n\n prom.binds_scope.push();\n\n let num_root = t.roots.len();\n for n in 0..num_root {\n let root = t.roots[n];\n process_constants_node(b, &mut prom, t, root, false);\n promote_values_node(b, &mut prom, t, root);\n }\n\n prom.binds_scope.push();\n\n t.resolved_binds = Some(prom.binds);\n}\n\nfn process_constants_node(\n b: &mut FunctionBuilder,\n prom: &mut PromoteCtx,\n t: &mut Tree,\n node: TreeNode,\n hier_bind: bool,\n) {\n let constraints: BTreeSet<_> = t.binds[node]\n .iter()\n .flat_map(|ident| prom.resolve_or_bind(hier_bind, *ident, node))\n .map(|v| match v {\n Either::Left(node) => ConstraintKind::Node(node),\n Either::Right(val) => match b.fun().value_kind(val) {\n ValueKind::Const(cons) => ConstraintKind::Const(cons),\n ValueKind::PrimOp(prim) => ConstraintKind::PrimOp(prim),\n _ => ConstraintKind::Value(val),\n },\n })\n .collect();\n\n t.constraints[node] = constraints;\n}\n\nfn promote_values_node(\n b: &mut FunctionBuilder,\n prom: &mut PromoteCtx,\n t: &mut Tree,\n node: TreeNode,\n) {\n let kind = t.nodes[node].clone();\n\n let constraints = &t.constraints[node];\n let mut const_iter = constraints.iter().flat_map(|v| v.constant());\n\n // Get first constant constraint\n let const_constraint = const_iter.next();\n\n // If we have multiple different constant constraints,\n // the pattern can never be matched.\n if let Some(first) = const_constraint {\n for other in const_iter {\n if first != other {\n prom.ctx.warn(LowerError::UnmatchablePatternWarning {\n pat: Some(t.node_span(node)),\n reason: None,\n });\n t.unmatchable = true;\n return;\n }\n }\n }\n\n // If we have multiple different PrimOp constraints,\n // the pattern can never be matched\n // TODO implement this warning when eir typing utilities\n // are more complete.\n\n // TODO: Check compatibility with TreeNode constraints.\n\n match kind {\n TreeNodeKind::Atomic(span, c) => {\n // If we have another constant constraint, and they are not\n // equal, we can never match the pattern.\n if let Some(nc) = const_constraint {\n if c != nc {\n prom.ctx.warn(LowerError::UnmatchablePatternWarning {\n pat: Some(span),\n reason: None,\n });\n t.unmatchable = true;\n return;\n }\n }\n }\n TreeNodeKind::Wildcard(span) => {\n // Prefer to promote to constants, here we have\n // the most information.\n if let Some(cons) = const_constraint {\n t.nodes[node] = TreeNodeKind::Atomic(span, cons);\n return;\n }\n // Second choice is PrimOps. Here we have a certain\n // amount of information.\n if let Some(prim) = constraints.iter().flat_map(|c| c.primop()).nth(0) {\n let val = b.value(prim);\n t.nodes[node] = TreeNodeKind::Value(span, Either::Left(val));\n return;\n }\n // Third choice is any other value\n if let Some(val) = constraints.iter().flat_map(|c| c.value()).nth(0) {\n t.nodes[node] = TreeNodeKind::Value(span, Either::Left(val));\n return;\n }\n }\n TreeNodeKind::Tuple { elems, .. } => {\n for idx in 0..elems.len(&t.node_pool) {\n let child = elems.get(idx, &t.node_pool).unwrap();\n process_constants_node(b, prom, t, child, false);\n }\n\n for idx in 0..elems.len(&t.node_pool) {\n let child = elems.get(idx, &t.node_pool).unwrap();\n promote_values_node(b, prom, t, child);\n }\n }\n TreeNodeKind::Cons { head, tail, .. } => {\n process_constants_node(b, prom, t, head, false);\n process_constants_node(b, prom, t, tail, false);\n\n promote_values_node(b, prom, t, head);\n promote_values_node(b, prom, t, tail);\n }\n TreeNodeKind::Binary {\n value, tail, size, ..\n } => {\n let size_res = size.map(|v| match v {\n // The size references another node\n Either::Left(ident) => {\n // We try to resolve it in the current pattern\n match prom.resolve_only(ident) {\n // We found a node in the pattern\n Some(inner) => inner,\n // No value found, error and return sentinel\n None => {\n prom.ctx\n .error(LowerError::UnresolvedVariable { span: ident.span });\n Either::Right(prom.ctx.sentinel())\n }\n }\n }\n Either::Right(val) => Either::Right(val),\n });\n if let TreeNodeKind::Binary { size_resolved, .. } = &mut t.nodes[node] {\n *size_resolved = size_res;\n } else {\n unreachable!();\n }\n\n prom.binds_scope.push();\n process_constants_node(b, prom, t, value, true);\n if let Some(tail_node) = tail {\n process_constants_node(b, prom, t, tail_node, false);\n }\n\n promote_values_node(b, prom, t, value);\n if let Some(tail_node) = tail {\n promote_values_node(b, prom, t, tail_node);\n }\n\n prom.binds_scope.pop();\n }\n TreeNodeKind::Map { entries, .. } => {\n for (_k, v) in entries.iter() {\n process_constants_node(b, prom, t, *v, false);\n }\n\n for (_k, v) in entries.iter() {\n promote_values_node(b, prom, t, *v);\n }\n }\n\n // While this cannot occur in a matchable pattern, we still\n // need to resolve scoping, so we handle it.\n TreeNodeKind::And { left, right } => {\n assert!(t.unmatchable);\n process_constants_node(b, prom, t, left, false);\n process_constants_node(b, prom, t, right, false);\n\n promote_values_node(b, prom, t, left);\n promote_values_node(b, prom, t, right);\n }\n\n TreeNodeKind::Value(_, _) => unreachable!(),\n }\n}\n" }, { "path": "libeir_syntax_erl/src/lower/scope.rs", "content": "use std::collections::{HashMap, HashSet};\n\nuse libeir_util_datastructures::hashmap_stack::HashMapStack;\n\nuse libeir_ir::{Block as IrBlock, FunctionBuilder, Value as IrValue};\n\nuse libeir_intern::Ident;\n\nuse super::{LowerCtx, LowerError};\n\npub fn is_wildcard(ident: Ident) -> bool {\n ident.name.as_str() == \"_\"\n}\n\npub struct ScopeToken {\n /// The position in the stack of the referenced scope.\n height: usize,\n}\n\n#[derive(Debug)]\npub struct ScopeTracker {\n // FIXME: Annoying that we have to store the key in the value.\n // Fix when get_key_value makes it into stable.\n stack: HashMapStack,\n}\n\nimpl ScopeTracker {\n pub fn new() -> Self {\n ScopeTracker {\n stack: HashMapStack::new(),\n }\n }\n\n /// This will push a new scope, returning a token which is required\n /// when later popping the token off the stack.\n pub fn push(&mut self) -> ScopeToken {\n self.stack.push();\n ScopeToken {\n height: self.stack.height(),\n }\n }\n\n /// This will pop all scopes above and including the provided token.\n /// Popping a token after one of its predecessors has been popped\n /// is illegal.\n pub fn pop(&mut self, token: ScopeToken) {\n assert!(self.stack.height() >= token.height);\n while self.stack.height() >= token.height {\n self.stack.pop();\n }\n }\n\n pub fn pop_take(&mut self, token: ScopeToken) -> HashMap {\n assert!(self.stack.height() >= token.height);\n\n let mut ret = HashMap::new();\n for layer_n in (token.height - 1)..self.stack.height() {\n let layer = self.stack.layer(layer_n);\n for (key, value) in layer.iter() {\n ret.insert(*key, value.1);\n }\n }\n\n self.pop(token);\n ret\n }\n\n pub fn resolve(&self, ident: Ident) -> Result {\n if let Some(val) = self.stack.get(&ident) {\n Ok(val.1)\n } else {\n Err(LowerError::UnresolvedVariable { span: ident.span })\n }\n }\n\n pub fn bind(&mut self, ident: Ident, val: IrValue) -> Result<(), LowerError> {\n if is_wildcard(ident) {\n Ok(())\n } else {\n if let Some(prev_val) = self.stack.get(&ident) {\n Err(LowerError::AlreadyBound {\n new: ident.span,\n old: prev_val.0.span,\n })\n } else {\n self.stack.insert(ident, (ident, val));\n Ok(())\n }\n }\n }\n\n pub fn bind_shadow(&mut self, ident: Ident, val: IrValue) -> Result<(), LowerError> {\n if is_wildcard(ident) {\n Ok(())\n } else {\n let ret = if let Some(prev_val) = self.stack.get(&ident) {\n Err(LowerError::ShadowingBind {\n new: ident.span,\n old: prev_val.0.span,\n })\n } else {\n Ok(())\n };\n self.stack.insert(ident, (ident, val));\n ret\n }\n }\n\n pub fn height(&self) -> usize {\n self.stack.height()\n }\n}\n\n#[derive(Debug)]\nstruct Branch {\n cont_block: IrBlock,\n ret: IrValue,\n binds: HashMap,\n}\n\n/// Utility for performing a scope merge, as is\n/// needed for case, if and receive branches.\n/// This will insert variable binding in the top\n/// scope if the binding is found to be present in\n/// every branch.\npub(super) struct ScopeMerge {\n branches: Vec,\n}\n\nimpl ScopeMerge {\n pub fn new() -> Self {\n ScopeMerge {\n branches: Vec::new(),\n }\n }\n\n pub fn branch(&mut self, cont: IrBlock, ret: IrValue, binds: HashMap) {\n self.branches.push(Branch {\n cont_block: cont,\n ret,\n binds,\n });\n }\n\n pub fn finish(&mut self, ctx: &mut LowerCtx, b: &mut FunctionBuilder) -> (IrBlock, IrValue) {\n // Find all bindings that are common to all branches\n let common_vars = if self.branches.len() > 0 {\n let mut common_set: HashSet<_> = self.branches[0].binds.keys().cloned().collect();\n common_set.retain(|ident| {\n self.branches\n .iter()\n .all(|res| res.binds.contains_key(ident))\n });\n common_set.drain().collect()\n } else {\n Vec::new()\n };\n\n // Insert the join block and the return argument\n let join_block = b.block_insert();\n let ret = b.block_arg_insert(join_block);\n\n // Insert common bindings on join block\n for var in common_vars.iter() {\n let val = b.block_arg_insert(join_block);\n ctx.bind(*var, val);\n }\n\n // Create calls from all branches to join block\n let mut val_buf = Vec::new();\n for result in self.branches.iter() {\n val_buf.clear();\n val_buf.push(result.ret);\n for var in common_vars.iter() {\n val_buf.push(result.binds[var]);\n }\n b.op_call_flow(result.cont_block, join_block, &val_buf);\n }\n\n (join_block, ret)\n }\n}\n" }, { "path": "libeir_syntax_erl/src/lower/tests.rs", "content": "use std::sync::Arc;\n\nuse crate::ast::*;\nuse crate::*;\n\nuse crate::lower::lower_module;\nuse crate::parser::ParseConfig;\n\nuse libeir_diagnostics::CodeMap;\nuse libeir_ir::{Module as IrModule, StandardFormatConfig};\nuse libeir_util_parse::Errors;\n\nfn parse(input: S, config: ParseConfig, codemap: Arc) -> T\nwhere\n T: Parse,\n S: AsRef,\n{\n let parser = Parser::new(config, codemap);\n let mut errors = Errors::new();\n match parser.parse_string::(&mut errors, input) {\n Ok(ast) => return ast,\n Err(()) => (),\n };\n errors.print(&parser.codemap);\n panic!(\"parse failed\");\n}\n\nfn lower(input: &str, config: ParseConfig) -> Result {\n let codemap = Arc::new(CodeMap::new());\n let parsed: Module = parse(input, config, codemap.clone());\n\n let mut errors = Errors::new();\n let res = lower_module(&mut errors, codemap.clone(), &parsed);\n errors.print(&codemap);\n\n res\n}\n\n#[test]\nfn fib_lower() {\n let _result = lower(\n \"-module(fib).\n\nfib(X) when X < 2 -> 1;\nfib(X) -> fib(X - 1) + fib(X-2).\n\",\n ParseConfig::default(),\n )\n .unwrap();\n}\n\n#[test]\nfn pat_1_lower() {\n let fun = lower(\n \"-module(pat).\npat(A, A) -> 1.\n\",\n ParseConfig::default(),\n )\n .unwrap();\n\n println!(\"{}\", fun.to_text(&mut StandardFormatConfig::default()));\n}\n\n#[test]\nfn spec_named_return_type() {\n let _result = lower(\n \"\n-module(test).\n-spec uniform() -> X :: float().\nuniform() -> 1.0.\n\",\n ParseConfig::default(),\n )\n .unwrap();\n}\n\n#[test]\nfn delayed_substitution_macros() {\n let _result = lower(\n \"\n-module(test).\nfunction_name() -> ?FUNCTION_NAME.\nfunction_arity() -> ?FUNCTION_ARITY.\n\",\n ParseConfig::default(),\n )\n .unwrap();\n}\n\n//#[test]\n//fn compiler_lower() {\n// let mut config = ParseConfig::default();\n//\n// config.include_paths.push_front(PathBuf::from(\"../otp/lib/compiler/src/\"));\n// config.include_paths.push_front(PathBuf::from(\"../otp/bootstrap/lib/stdlib/include/\"));\n//\n// let ir = lower_file(\"../otp/lib/compiler/src/compile.erl\", config).unwrap();\n//\n// let ident = FunctionIdent {\n// module: Ident::from_str(\"compile\"),\n// name: Ident::from_str(\"iofile\"),\n// arity: 1,\n// };\n//\n// let mut errors = Vec::new();\n// for fun in ir.functions.values() {\n// //if fun.ident() == &ident {\n// println!(\"{:?}\", fun.ident());\n// fun.validate(&mut errors);\n// //}\n// }\n// println!(\"{:#?}\", errors);\n//\n// let fun = &ir.functions[&ident];\n//\n// print!(\"{}\", fun.to_text());\n//\n// let mut dot = Vec::::new();\n// libeir_ir::text::dot_printer::function_to_dot(fun, &mut dot).unwrap();\n// let dot_text = std::str::from_utf8(&dot).unwrap();\n// print!(\"{}\", dot_text);\n//\n//}\n" }, { "path": "libeir_syntax_erl/src/parser/ast/attributes.rs", "content": "use std::fmt;\nuse std::hash::{Hash, Hasher};\n\nuse libeir_diagnostics::SourceSpan;\n\nuse super::{Expr, Ident, Name, PartiallyResolvedFunctionName, Type};\n\n/// Type definitions\n///\n/// ## Examples\n///\n/// ```text\n/// %% Simple types\n/// -type foo() :: bar.\n/// -opaque foo() :: bar.\n///\n/// %% Generic/parameterized types\n/// -type foo(T) :: [T].\n/// -opaque foo(T) :: [T].\n/// ```\n#[derive(Debug, Clone)]\npub struct TypeDef {\n pub span: SourceSpan,\n pub opaque: bool,\n pub name: Ident,\n pub params: Vec,\n pub ty: Type,\n}\nimpl PartialEq for TypeDef {\n fn eq(&self, other: &Self) -> bool {\n if self.opaque != other.opaque {\n return false;\n }\n if self.name != other.name {\n return false;\n }\n if self.params != other.params {\n return false;\n }\n if self.ty != other.ty {\n return false;\n }\n return true;\n }\n}\n\n/// Function type specifications, used for both function specs and callback specs\n///\n/// ## Example\n///\n/// ```text\n/// %% Monomorphic function\n/// -spec foo(A :: map(), Opts :: list({atom(), term()})) -> {ok, map()} | {error, term()}.\n///\n/// %% Polymorphic function\n/// -spec foo(A, Opts :: list({atom, term()})) -> {ok, A} | {error, term()}.\n///\n/// %% Multiple dispatch function\n/// -spec foo(map(), Opts) -> {ok, map()} | {error, term()};\n/// foo(list(), Opts) -> {ok, list()} | {error, term()}.\n///\n/// %% Using `when` to express subtype constraints\n/// -spec foo(map(), Opts) -> {ok, map()} | {error, term()}\n/// when Opts :: list({atom, term});\n/// ```\n#[derive(Debug, Clone)]\npub struct TypeSpec {\n pub span: SourceSpan,\n pub module: Option,\n pub function: Ident,\n pub sigs: Vec,\n}\nimpl PartialEq for TypeSpec {\n fn eq(&self, other: &Self) -> bool {\n self.module == other.module && self.function == other.function && self.sigs == other.sigs\n }\n}\n\n/// A callback declaration, which is functionally identical to `TypeSpec` in\n/// its syntax, but is used to both define a callback function for a behaviour,\n/// as well as provide an expected type specification for that function.\n#[derive(Debug, Clone)]\npub struct Callback {\n pub span: SourceSpan,\n pub optional: bool,\n pub module: Option,\n pub function: Ident,\n pub sigs: Vec,\n}\nimpl PartialEq for Callback {\n fn eq(&self, other: &Self) -> bool {\n self.optional == other.optional\n && self.module == other.module\n && self.function == other.function\n && self.sigs == other.sigs\n }\n}\n\n/// Contains type information for a single clause of a function type specification\n#[derive(Debug, Clone, PartialEq)]\npub struct TypeSig {\n pub span: SourceSpan,\n pub params: Vec,\n pub ret: Box,\n pub guards: Option>,\n}\n\n/// Contains a single subtype constraint to be applied to a type specification\n#[derive(Debug, Clone)]\npub struct TypeGuard {\n pub span: SourceSpan,\n pub var: Name,\n pub ty: Type,\n}\nimpl PartialEq for TypeGuard {\n fn eq(&self, other: &TypeGuard) -> bool {\n self.var == other.var && self.ty == other.ty\n }\n}\n\n/// Represents a user-defined custom attribute.\n///\n/// ## Example\n///\n/// ```text\n/// -my_attribute([foo, bar]).\n/// ```\n#[derive(Debug, Clone)]\npub struct UserAttribute {\n pub span: SourceSpan,\n pub name: Ident,\n pub value: Expr,\n}\nimpl PartialEq for UserAttribute {\n fn eq(&self, other: &Self) -> bool {\n self.name == other.name && self.value == other.value\n }\n}\n\n/// Represents a deprecated function or module\n#[derive(Debug, Clone)]\npub enum Deprecation {\n Module {\n span: SourceSpan,\n flag: DeprecatedFlag,\n },\n Function {\n span: SourceSpan,\n function: PartiallyResolvedFunctionName,\n flag: DeprecatedFlag,\n },\n}\nimpl Deprecation {\n pub fn span(&self) -> SourceSpan {\n match self {\n &Deprecation::Module { ref span, .. } => span.clone(),\n &Deprecation::Function { ref span, .. } => span.clone(),\n }\n }\n}\nimpl PartialEq for Deprecation {\n fn eq(&self, other: &Self) -> bool {\n match (self, other) {\n (&Deprecation::Module { .. }, &Deprecation::Module { .. }) => true,\n // We ignore the flag because it used only for display,\n // the function/arity determines equality\n (\n &Deprecation::Function {\n function: ref x1, ..\n },\n &Deprecation::Function {\n function: ref y1, ..\n },\n ) => x1 == y1,\n _ => false,\n }\n }\n}\nimpl Eq for Deprecation {}\nimpl Hash for Deprecation {\n fn hash(&self, state: &mut H) {\n let discriminant = std::mem::discriminant(self);\n discriminant.hash(state);\n match self {\n &Deprecation::Module { .. } => (),\n &Deprecation::Function { ref function, .. } => function.hash(state),\n }\n }\n}\n\n#[derive(Debug, Clone, Copy, PartialEq, Eq)]\npub enum DeprecatedFlag {\n Eventually,\n NextVersion,\n NextMajorRelease,\n Description(Ident),\n}\nimpl fmt::Display for DeprecatedFlag {\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n match self {\n &DeprecatedFlag::Eventually => write!(f, \"eventually\"),\n &DeprecatedFlag::NextVersion => write!(f, \"in the next version\"),\n &DeprecatedFlag::NextMajorRelease => write!(f, \"in the next major release\"),\n &DeprecatedFlag::Description(descr) => write!(f, \"{}\", descr.name),\n }\n }\n}\n\n/// Represents the set of allowed attributes in the body of a module\n#[derive(Debug, Clone)]\npub enum Attribute {\n Type(TypeDef),\n Spec(TypeSpec),\n Callback(Callback),\n Custom(UserAttribute),\n ExportType(SourceSpan, Vec),\n Export(SourceSpan, Vec),\n Import(SourceSpan, Ident, Vec),\n Removed(SourceSpan, Vec<(PartiallyResolvedFunctionName, Ident)>),\n Compile(SourceSpan, Expr),\n Vsn(SourceSpan, Expr),\n Author(SourceSpan, Expr),\n OnLoad(SourceSpan, PartiallyResolvedFunctionName),\n Behaviour(SourceSpan, Ident),\n Deprecation(Vec),\n}\nimpl PartialEq for Attribute {\n fn eq(&self, other: &Attribute) -> bool {\n let left = std::mem::discriminant(self);\n let right = std::mem::discriminant(other);\n if left != right {\n return false;\n }\n\n match (self, other) {\n (&Attribute::Type(ref x), &Attribute::Type(ref y)) => x == y,\n (&Attribute::Spec(ref x), &Attribute::Spec(ref y)) => x == y,\n (&Attribute::Callback(ref x), &Attribute::Callback(ref y)) => x == y,\n (&Attribute::Custom(ref x), &Attribute::Custom(ref y)) => x == y,\n (&Attribute::ExportType(_, ref x), &Attribute::ExportType(_, ref y)) => x == y,\n (&Attribute::Export(_, ref x), &Attribute::Export(_, ref y)) => x == y,\n (&Attribute::Import(_, ref x1, ref x2), &Attribute::Import(_, ref y1, ref y2)) => {\n (x1 == y1) && (x2 == y2)\n }\n (&Attribute::Removed(_, ref x), &Attribute::Removed(_, ref y)) => x == y,\n (&Attribute::Compile(_, ref x), &Attribute::Compile(_, ref y)) => x == y,\n (&Attribute::Vsn(_, ref x), &Attribute::Vsn(_, ref y)) => x == y,\n (&Attribute::Author(_, ref x), &Attribute::Author(_, ref y)) => x == y,\n (&Attribute::OnLoad(_, ref x), &Attribute::OnLoad(_, ref y)) => x == y,\n (&Attribute::Behaviour(_, ref x), &Attribute::Behaviour(_, ref y)) => x == y,\n _ => false,\n }\n }\n}\n" }, { "path": "libeir_syntax_erl/src/parser/ast/expr.rs", "content": "use std::cmp::Ordering;\n\nuse libeir_diagnostics::SourceSpan;\nuse libeir_util_number::{Float, Integer, Number};\nuse libeir_ir::binary::BinaryEntrySpecifier;\n\nuse super::NodeId;\nuse super::{BinaryOp, Ident, UnaryOp};\nuse super::{Function, FunctionName, Guard, Name, Type};\n\nuse crate::lexer::DelayedSubstitution;\n\n/// The set of all possible expressions\n#[derive(Debug, Clone, PartialEq)]\npub enum Expr {\n // An identifier/variable/function reference\n Var(Var),\n Literal(Literal),\n FunctionName(FunctionName),\n // Delayed substitution of macro\n DelayedSubstitution(SourceSpan, NodeId, DelayedSubstitution),\n // The various list forms\n Nil(Nil),\n Cons(Cons),\n // Other data structures\n Tuple(Tuple),\n Map(Map),\n MapUpdate(MapUpdate),\n MapProjection(MapProjection),\n Binary(Binary),\n Record(Record),\n RecordAccess(RecordAccess),\n RecordIndex(RecordIndex),\n RecordUpdate(RecordUpdate),\n // Comprehensions\n ListComprehension(ListComprehension),\n BinaryComprehension(BinaryComprehension),\n Generator(Generator),\n BinaryGenerator(BinaryGenerator),\n // Complex expressions\n Begin(Begin),\n Apply(Apply),\n Remote(Remote),\n BinaryExpr(BinaryExpr),\n UnaryExpr(UnaryExpr),\n Match(Match),\n If(If),\n Catch(Catch),\n Case(Case),\n Receive(Receive),\n Try(Try),\n Fun(Function),\n}\nimpl Expr {\n pub fn span(&self) -> SourceSpan {\n match self {\n &Expr::Var(Var(_, Ident { ref span, .. })) => span.clone(),\n &Expr::Literal(ref lit) => lit.span(),\n &Expr::FunctionName(ref name) => name.span(),\n &Expr::DelayedSubstitution(ref span, _, _) => *span,\n &Expr::Nil(Nil(ref span, _)) => span.clone(),\n &Expr::Cons(Cons { ref span, .. }) => span.clone(),\n &Expr::Tuple(Tuple { ref span, .. }) => span.clone(),\n &Expr::Map(Map { ref span, .. }) => span.clone(),\n &Expr::MapUpdate(MapUpdate { ref span, .. }) => span.clone(),\n &Expr::MapProjection(MapProjection { ref span, .. }) => span.clone(),\n &Expr::Binary(Binary { ref span, .. }) => span.clone(),\n &Expr::Record(Record { ref span, .. }) => span.clone(),\n &Expr::RecordAccess(RecordAccess { ref span, .. }) => span.clone(),\n &Expr::RecordIndex(RecordIndex { ref span, .. }) => span.clone(),\n &Expr::RecordUpdate(RecordUpdate { ref span, .. }) => span.clone(),\n &Expr::ListComprehension(ListComprehension { ref span, .. }) => span.clone(),\n &Expr::BinaryComprehension(BinaryComprehension { ref span, .. }) => span.clone(),\n &Expr::Generator(Generator { ref span, .. }) => span.clone(),\n &Expr::BinaryGenerator(BinaryGenerator { ref span, .. }) => span.clone(),\n &Expr::Begin(Begin { ref span, .. }) => span.clone(),\n &Expr::Apply(Apply { ref span, .. }) => span.clone(),\n &Expr::Remote(Remote { ref span, .. }) => span.clone(),\n &Expr::BinaryExpr(BinaryExpr { ref span, .. }) => span.clone(),\n &Expr::UnaryExpr(UnaryExpr { ref span, .. }) => span.clone(),\n &Expr::Match(Match { ref span, .. }) => span.clone(),\n &Expr::If(If { ref span, .. }) => span.clone(),\n &Expr::Catch(Catch { ref span, .. }) => span.clone(),\n &Expr::Case(Case { ref span, .. }) => span.clone(),\n &Expr::Receive(Receive { ref span, .. }) => span.clone(),\n &Expr::Try(Try { ref span, .. }) => span.clone(),\n &Expr::Fun(ref fun) => fun.span(),\n }\n }\n pub fn id(&self) -> NodeId {\n match self {\n Expr::Var(Var(id, _)) => *id,\n Expr::Literal(lit) => lit.id(),\n Expr::FunctionName(name) => name.id(),\n Expr::DelayedSubstitution(_, id, _) => *id,\n Expr::Nil(Nil(_, id)) => *id,\n Expr::Cons(cons) => cons.id,\n Expr::Tuple(tuple) => tuple.id,\n Expr::Map(map) => map.id,\n Expr::MapUpdate(map) => map.id,\n Expr::MapProjection(map) => map.id,\n Expr::Binary(bin) => bin.id,\n Expr::Record(rec) => rec.id,\n Expr::RecordAccess(rec) => rec.id,\n Expr::RecordIndex(rec) => rec.id,\n Expr::RecordUpdate(rec) => rec.id,\n Expr::ListComprehension(compr) => compr.id,\n Expr::BinaryComprehension(compr) => compr.id,\n Expr::Generator(gen) => gen.id,\n Expr::BinaryGenerator(gen) => gen.id,\n Expr::Begin(begin) => begin.id,\n Expr::Apply(apply) => apply.id,\n Expr::Remote(rem) => rem.id,\n Expr::BinaryExpr(bin) => bin.id,\n Expr::UnaryExpr(un) => un.id,\n Expr::Match(mat) => mat.id,\n Expr::If(expr) => expr.id,\n Expr::Catch(catch) => catch.id,\n Expr::Case(case) => case.id,\n Expr::Receive(rec) => rec.id,\n Expr::Try(tr) => tr.id,\n Expr::Fun(fun) => fun.id(),\n }\n }\n}\n\n#[derive(Debug, Clone)]\npub struct Var(pub NodeId, pub Ident);\nimpl PartialEq for Var {\n fn eq(&self, other: &Self) -> bool {\n self.1 == other.1\n }\n}\nimpl Eq for Var {}\n\n#[derive(Debug, Clone)]\npub struct Nil(pub SourceSpan, pub NodeId);\nimpl PartialEq for Nil {\n fn eq(&self, _: &Self) -> bool {\n return true;\n }\n}\nimpl Eq for Nil {}\n\n#[derive(Debug, Clone)]\npub struct Cons {\n pub span: SourceSpan,\n pub id: NodeId,\n pub head: Box,\n pub tail: Box,\n}\nimpl PartialEq for Cons {\n fn eq(&self, other: &Self) -> bool {\n self.head == other.head && self.tail == other.tail\n }\n}\n//impl PartialOrd for Cons {\n// fn partial_cmp(&self, other: &Self) -> Option {\n// match self.head.partial_cmp(&other.head) {\n// None => self.tail.partial_cmp(&other.tail),\n// Some(order) => Some(order),\n// }\n// }\n//}\n\n#[derive(Debug, Clone)]\npub struct Tuple {\n pub span: SourceSpan,\n pub id: NodeId,\n pub elements: Vec,\n}\nimpl PartialEq for Tuple {\n fn eq(&self, other: &Self) -> bool {\n self.elements == other.elements\n }\n}\n//impl PartialOrd for Tuple {\n// fn partial_cmp(&self, other: &Self) -> Option {\n// self.elements.partial_cmp(&other.elements)\n// }\n//}\n\n#[derive(Debug, Clone)]\npub struct Map {\n pub span: SourceSpan,\n pub id: NodeId,\n pub fields: Vec,\n}\nimpl PartialEq for Map {\n fn eq(&self, other: &Self) -> bool {\n self.fields == other.fields\n }\n}\n//impl PartialOrd for Map {\n// fn partial_cmp(&self, other: &Self) -> Option {\n// self.fields.partial_cmp(&other.fields)\n// }\n//}\n\n// Updating fields on an existing map, e.g. `Map#{field1 = value1}.`\n#[derive(Debug, Clone)]\npub struct MapUpdate {\n pub span: SourceSpan,\n pub id: NodeId,\n pub map: Box,\n pub updates: Vec,\n}\nimpl PartialEq for MapUpdate {\n fn eq(&self, other: &Self) -> bool {\n self.map == other.map && self.updates == other.updates\n }\n}\n\n// Pattern matching a map expression\n#[derive(Debug, Clone)]\npub struct MapProjection {\n pub span: SourceSpan,\n pub id: NodeId,\n pub map: Box,\n pub fields: Vec,\n}\nimpl PartialEq for MapProjection {\n fn eq(&self, other: &Self) -> bool {\n self.map == other.map && self.fields == other.fields\n }\n}\n\n/// The set of literal values\n///\n/// This does not include tuples, lists, and maps,\n/// even though those can be constructed at compile-time,\n/// as some places that allow literals do not permit those\n/// types\n#[derive(Debug, Clone)]\npub enum Literal {\n Atom(NodeId, Ident),\n String(NodeId, Ident),\n Char(SourceSpan, NodeId, char),\n Integer(SourceSpan, NodeId, Integer),\n Float(SourceSpan, NodeId, Float),\n}\nimpl Literal {\n pub fn span(&self) -> SourceSpan {\n match self {\n &Literal::Atom(_, Ident { ref span, .. }) => span.clone(),\n &Literal::String(_, Ident { ref span, .. }) => span.clone(),\n &Literal::Char(span, _, _) => span.clone(),\n &Literal::Integer(span, _, _) => span.clone(),\n &Literal::Float(span, _, _) => span.clone(),\n }\n }\n pub fn id(&self) -> NodeId {\n match self {\n Literal::Atom(id, _) => *id,\n Literal::String(id, _) => *id,\n Literal::Char(_, id, _) => *id,\n Literal::Integer(_, id, _) => *id,\n Literal::Float(_, id, _) => *id,\n }\n }\n}\nimpl PartialEq for Literal {\n fn eq(&self, other: &Literal) -> bool {\n match (self, other) {\n (&Literal::Atom(_, ref lhs), &Literal::Atom(_, ref rhs)) => lhs == rhs,\n (&Literal::Atom(_, _), _) => false,\n (_, &Literal::Atom(_, _)) => false,\n (&Literal::String(_, ref lhs), &Literal::String(_, ref rhs)) => lhs == rhs,\n (&Literal::String(_, _), _) => false,\n (_, &Literal::String(_, _)) => false,\n (x, y) => x.partial_cmp(y) == Some(Ordering::Equal),\n }\n }\n}\nimpl PartialOrd for Literal {\n // number < atom < reference < fun < port < pid < tuple < map < nil < list < bit string\n fn partial_cmp(&self, other: &Literal) -> Option {\n match (self, other) {\n (Literal::String(_, ref lhs), Literal::String(_, ref rhs)) => lhs.partial_cmp(rhs),\n (Literal::String(_, _), _) => Some(Ordering::Greater),\n (_, Literal::String(_, _)) => Some(Ordering::Less),\n (Literal::Atom(_, ref lhs), Literal::Atom(_, ref rhs)) => lhs.partial_cmp(rhs),\n (Literal::Atom(_, _), _) => Some(Ordering::Greater),\n (_, Literal::Atom(_, _)) => Some(Ordering::Less),\n\n (\n l @ (Literal::Integer(_, _, _) | Literal::Float(_, _, _) | Literal::Char(_, _, _)),\n r @ (Literal::Integer(_, _, _) | Literal::Float(_, _, _) | Literal::Char(_, _, _)),\n ) => {\n let to_num = |lit: &Literal| match lit {\n Literal::Integer(_, _, x) => x.clone().into(),\n Literal::Float(_, _, x) => x.clone().into(),\n Literal::Char(_, _, x) => {\n let int: Integer = (*x).into();\n int.into()\n }\n _ => unreachable!(),\n };\n\n let ln: Number = to_num(l);\n let rn: Number = to_num(r);\n\n ln.partial_cmp(&rn)\n }\n\n _ => unimplemented!(),\n }\n }\n}\n\n/// Maps can have two different types of field assignment:\n///\n/// * assoc - inserts or updates the given key with the given value\n/// * exact - updates the given key with the given value, or produces an error\n#[derive(Debug, Clone)]\npub enum MapField {\n Assoc {\n span: SourceSpan,\n id: NodeId,\n key: Expr,\n value: Expr,\n },\n Exact {\n span: SourceSpan,\n id: NodeId,\n key: Expr,\n value: Expr,\n },\n}\nimpl MapField {\n pub fn key(&self) -> Expr {\n match self {\n &MapField::Assoc { ref key, .. } => key.clone(),\n &MapField::Exact { ref key, .. } => key.clone(),\n }\n }\n\n pub fn value(&self) -> Expr {\n match self {\n &MapField::Assoc { ref value, .. } => value.clone(),\n &MapField::Exact { ref value, .. } => value.clone(),\n }\n }\n\n pub fn span(&self) -> SourceSpan {\n match self {\n MapField::Assoc { span, .. } => *span,\n MapField::Exact { span, .. } => *span,\n }\n }\n}\nimpl PartialEq for MapField {\n fn eq(&self, other: &Self) -> bool {\n (self.key() == other.key()) && (self.value() == other.value())\n }\n}\n//impl PartialOrd for MapField {\n// fn partial_cmp(&self, other: &Self) -> Option {\n// match self.key().partial_cmp(&other.key()) {\n// None => None,\n// Some(Ordering::Equal) => self.value().partial_cmp(&other.value()),\n// Some(order) => Some(order),\n// }\n// }\n//}\n\n#[derive(Debug, Clone)]\npub struct Record {\n pub span: SourceSpan,\n pub id: NodeId,\n pub name: Ident,\n pub fields: Vec,\n}\nimpl PartialEq for Record {\n fn eq(&self, other: &Self) -> bool {\n self.name == other.name && self.fields == other.fields\n }\n}\n\n// Accessing a record field value, e.g. Expr#myrec.field1\n#[derive(Debug, Clone)]\npub struct RecordAccess {\n pub span: SourceSpan,\n pub id: NodeId,\n pub record: Box,\n pub name: Ident,\n pub field: Ident,\n}\nimpl PartialEq for RecordAccess {\n fn eq(&self, other: &Self) -> bool {\n self.name == other.name && self.field == other.field && self.record == other.record\n }\n}\n\n// Referencing a record fields index, e.g. #myrec.field1\n#[derive(Debug, Clone)]\npub struct RecordIndex {\n pub span: SourceSpan,\n pub id: NodeId,\n pub name: Ident,\n pub field: Ident,\n}\nimpl PartialEq for RecordIndex {\n fn eq(&self, other: &Self) -> bool {\n self.name == other.name && self.field == other.field\n }\n}\n\n// Update a record field value, e.g. Expr#myrec.field1\n#[derive(Debug, Clone)]\npub struct RecordUpdate {\n pub span: SourceSpan,\n pub id: NodeId,\n pub record: Box,\n pub name: Ident,\n pub updates: Vec,\n}\nimpl PartialEq for RecordUpdate {\n fn eq(&self, other: &Self) -> bool {\n self.name == other.name && self.record == other.record && self.updates == other.updates\n }\n}\n\n/// Record fields always have a name, but both default value and type\n/// are optional in a record definition. When instantiating a record,\n/// if no value is given for a field, and no default is given,\n/// then `undefined` is the default.\n#[derive(Debug, Clone)]\npub struct RecordField {\n pub span: SourceSpan,\n pub id: NodeId,\n pub name: Ident,\n pub value: Option,\n pub ty: Option,\n}\nimpl PartialEq for RecordField {\n fn eq(&self, other: &Self) -> bool {\n (self.name == other.name) && (self.value == other.value) && (self.ty == other.ty)\n }\n}\n\n#[derive(Debug, Clone)]\npub struct Binary {\n pub span: SourceSpan,\n pub id: NodeId,\n pub elements: Vec,\n}\nimpl PartialEq for Binary {\n fn eq(&self, other: &Self) -> bool {\n self.elements == other.elements\n }\n}\n\n/// Used to represent a specific segment in a binary constructor, to\n/// produce a binary, all segments must be evaluated, and then assembled\n#[derive(Debug, Clone)]\npub struct BinaryElement {\n pub span: SourceSpan,\n pub id: NodeId,\n pub bit_expr: Expr,\n pub bit_size: Option,\n pub specifier: Option,\n}\nimpl PartialEq for BinaryElement {\n fn eq(&self, other: &Self) -> bool {\n (self.bit_expr == other.bit_expr)\n && (self.bit_size == other.bit_size)\n && (self.specifier == other.specifier)\n }\n}\n\n/// A bit type can come in the form `Type` or `Type:Size`\n#[derive(Debug, Clone)]\npub enum BitType {\n Name(SourceSpan, NodeId, Ident),\n Sized(SourceSpan, NodeId, Ident, i64),\n}\nimpl BitType {\n pub fn span(&self) -> SourceSpan {\n match self {\n BitType::Name(span, _, _) => *span,\n BitType::Sized(span, _, _, _) => *span,\n }\n }\n}\nimpl PartialEq for BitType {\n fn eq(&self, other: &Self) -> bool {\n match (self, other) {\n (&BitType::Name(_, _, ref x1), &BitType::Name(_, _, ref y1)) => x1 == y1,\n (&BitType::Sized(_, _, ref x1, ref x2), &BitType::Sized(_, _, ref y1, ref y2)) => {\n (x1 == y1) && (x2 == y2)\n }\n _ => false,\n }\n }\n}\n\n#[derive(Debug, Clone)]\npub struct ListComprehension {\n pub span: SourceSpan,\n pub id: NodeId,\n pub body: Box,\n pub qualifiers: Vec,\n}\nimpl PartialEq for ListComprehension {\n fn eq(&self, other: &Self) -> bool {\n self.body == other.body && self.qualifiers == other.qualifiers\n }\n}\n\n#[derive(Debug, Clone)]\npub struct BinaryComprehension {\n pub span: SourceSpan,\n pub id: NodeId,\n pub body: Box,\n pub qualifiers: Vec,\n}\nimpl PartialEq for BinaryComprehension {\n fn eq(&self, other: &Self) -> bool {\n self.body == other.body && self.qualifiers == other.qualifiers\n }\n}\n\n// A generator of the form `LHS <- RHS`\n#[derive(Debug, Clone)]\npub struct Generator {\n pub span: SourceSpan,\n pub id: NodeId,\n pub pattern: Box,\n pub expr: Box,\n}\nimpl PartialEq for Generator {\n fn eq(&self, other: &Self) -> bool {\n self.pattern == other.pattern && self.expr == other.expr\n }\n}\n\n// A generator of the form `LHS <= RHS`\n#[derive(Debug, Clone)]\npub struct BinaryGenerator {\n pub span: SourceSpan,\n pub id: NodeId,\n pub pattern: Box,\n pub expr: Box,\n}\nimpl PartialEq for BinaryGenerator {\n fn eq(&self, other: &Self) -> bool {\n self.pattern == other.pattern && self.expr == other.expr\n }\n}\n\n// A sequence of expressions, e.g. begin expr1, .., exprN end\n#[derive(Debug, Clone)]\npub struct Begin {\n pub span: SourceSpan,\n pub id: NodeId,\n pub body: Vec,\n}\nimpl PartialEq for Begin {\n fn eq(&self, other: &Self) -> bool {\n self.body == other.body\n }\n}\n\n// Function application, e.g. foo(expr1, .., exprN)\n#[derive(Debug, Clone)]\npub struct Apply {\n pub span: SourceSpan,\n pub id: NodeId,\n pub callee: Box,\n pub args: Vec,\n}\nimpl PartialEq for Apply {\n fn eq(&self, other: &Self) -> bool {\n self.callee == other.callee && self.args == other.args\n }\n}\n\n// Remote, e.g. Foo:Bar\n#[derive(Debug, Clone)]\npub struct Remote {\n pub span: SourceSpan,\n pub id: NodeId,\n pub module: Box,\n pub function: Box,\n}\nimpl PartialEq for Remote {\n fn eq(&self, other: &Self) -> bool {\n self.module == other.module && self.function == other.function\n }\n}\n\n#[derive(Debug, Clone)]\npub struct BinaryExpr {\n pub span: SourceSpan,\n pub id: NodeId,\n pub lhs: Box,\n pub op: BinaryOp,\n pub rhs: Box,\n}\nimpl PartialEq for BinaryExpr {\n fn eq(&self, other: &Self) -> bool {\n self.op == other.op && self.lhs == other.lhs && self.rhs == other.rhs\n }\n}\n\n#[derive(Debug, Clone)]\npub struct UnaryExpr {\n pub span: SourceSpan,\n pub id: NodeId,\n pub op: UnaryOp,\n pub operand: Box,\n}\nimpl PartialEq for UnaryExpr {\n fn eq(&self, other: &Self) -> bool {\n self.op == other.op && self.operand == other.operand\n }\n}\n\n#[derive(Debug, Clone)]\npub struct Match {\n pub span: SourceSpan,\n pub id: NodeId,\n pub pattern: Box,\n pub expr: Box,\n}\nimpl PartialEq for Match {\n fn eq(&self, other: &Self) -> bool {\n self.pattern == other.pattern && self.expr == other.expr\n }\n}\n\n#[derive(Debug, Clone)]\npub struct If {\n pub span: SourceSpan,\n pub id: NodeId,\n pub clauses: Vec,\n}\nimpl PartialEq for If {\n fn eq(&self, other: &Self) -> bool {\n self.clauses == other.clauses\n }\n}\n\n/// Represents a single clause in an `if` expression\n#[derive(Debug, Clone)]\npub struct IfClause {\n pub span: SourceSpan,\n pub id: NodeId,\n pub guards: Vec,\n pub body: Vec,\n}\nimpl PartialEq for IfClause {\n fn eq(&self, other: &Self) -> bool {\n self.guards == other.guards && self.body == other.body\n }\n}\n\n#[derive(Debug, Clone)]\npub struct Catch {\n pub span: SourceSpan,\n pub id: NodeId,\n pub expr: Box,\n}\nimpl PartialEq for Catch {\n fn eq(&self, other: &Self) -> bool {\n self.expr == other.expr\n }\n}\n\n#[derive(Debug, Clone)]\npub struct Case {\n pub span: SourceSpan,\n pub id: NodeId,\n pub expr: Box,\n pub clauses: Vec,\n}\nimpl PartialEq for Case {\n fn eq(&self, other: &Self) -> bool {\n self.expr == other.expr && self.clauses == other.clauses\n }\n}\n\n#[derive(Debug, Clone)]\npub struct Receive {\n pub span: SourceSpan,\n pub id: NodeId,\n pub clauses: Option>,\n pub after: Option,\n}\nimpl PartialEq for Receive {\n fn eq(&self, other: &Self) -> bool {\n self.clauses == other.clauses && self.after == other.after\n }\n}\n\n#[derive(Debug, Clone)]\npub struct Try {\n pub span: SourceSpan,\n pub id: NodeId,\n pub exprs: Vec,\n pub clauses: Option>,\n pub catch_clauses: Option>,\n pub after: Option>,\n}\nimpl PartialEq for Try {\n fn eq(&self, other: &Self) -> bool {\n self.exprs == other.exprs\n && self.clauses == other.clauses\n && self.catch_clauses == other.catch_clauses\n && self.after == other.after\n }\n}\n\n/// Represents a single `catch` clause in a `try` expression\n#[derive(Debug, Clone)]\npub struct TryClause {\n pub span: SourceSpan,\n pub id: NodeId,\n pub kind: Name,\n pub error: Expr,\n pub guard: Option>,\n pub trace: Ident,\n pub body: Vec,\n}\nimpl PartialEq for TryClause {\n fn eq(&self, other: &Self) -> bool {\n self.kind == other.kind\n && self.error == other.error\n && self.guard == other.guard\n && self.trace == other.trace\n && self.body == other.body\n }\n}\n\n/// Represents the `after` clause of a `receive` expression\n#[derive(Debug, Clone)]\npub struct After {\n pub span: SourceSpan,\n pub id: NodeId,\n pub timeout: Box,\n pub body: Vec,\n}\nimpl PartialEq for After {\n fn eq(&self, other: &Self) -> bool {\n self.timeout == other.timeout && self.body == other.body\n }\n}\n\n/// Represents a single match clause in a `case`, `try`, or `receive` expression\n#[derive(Debug, Clone)]\npub struct Clause {\n pub span: SourceSpan,\n pub id: NodeId,\n pub pattern: Expr,\n pub guard: Option>,\n pub body: Vec,\n}\nimpl PartialEq for Clause {\n fn eq(&self, other: &Self) -> bool {\n self.pattern == other.pattern && self.guard == other.guard && self.body == other.body\n }\n}\n" }, { "path": "libeir_syntax_erl/src/parser/ast/functions.rs", "content": "use std::cmp::Ordering;\nuse std::fmt;\nuse std::hash::{Hash, Hasher};\n\nuse libeir_diagnostics::{Diagnostic, Label, SourceSpan};\nuse libeir_util_parse::ErrorReceiver;\n\nuse crate::preprocessor::PreprocessorError;\n\nuse super::ParserError;\nuse super::{Arity, Expr, Ident, Name, NodeId, NodeIdGenerator, TypeSpec};\n\n#[derive(Debug, Copy, Clone)]\npub struct LocalFunctionName {\n pub span: SourceSpan,\n pub function: Ident,\n pub arity: usize,\n}\nimpl PartialEq for LocalFunctionName {\n fn eq(&self, other: &Self) -> bool {\n self.function == other.function && self.arity == other.arity\n }\n}\nimpl Eq for LocalFunctionName {}\nimpl Hash for LocalFunctionName {\n fn hash(&self, state: &mut H) {\n self.function.hash(state);\n self.arity.hash(state);\n }\n}\nimpl PartialOrd for LocalFunctionName {\n fn partial_cmp(&self, other: &Self) -> Option {\n let (xf, xa) = (self.function, self.arity);\n let (yf, ya) = (other.function, other.arity);\n match xf.partial_cmp(&yf) {\n None | Some(Ordering::Equal) => xa.partial_cmp(&ya),\n Some(order) => Some(order),\n }\n }\n}\nimpl Ord for LocalFunctionName {\n fn cmp(&self, other: &Self) -> Ordering {\n self.partial_cmp(other).unwrap()\n }\n}\n\n/// Represents a fully-resolved function name, with module/function/arity explicit\n#[derive(Debug, Clone)]\npub struct ResolvedFunctionName {\n pub span: SourceSpan,\n pub id: NodeId,\n pub module: Ident,\n pub function: Ident,\n pub arity: usize,\n}\nimpl PartialEq for ResolvedFunctionName {\n fn eq(&self, other: &Self) -> bool {\n self.module == other.module && self.function == other.function && self.arity == other.arity\n }\n}\nimpl Eq for ResolvedFunctionName {}\nimpl Hash for ResolvedFunctionName {\n fn hash(&self, state: &mut H) {\n self.module.hash(state);\n self.function.hash(state);\n self.arity.hash(state);\n }\n}\nimpl PartialOrd for ResolvedFunctionName {\n fn partial_cmp(&self, other: &Self) -> Option {\n let (xm, xf, xa) = (self.module, self.function, self.arity);\n let (ym, yf, ya) = (other.module, other.function, other.arity);\n match xm.partial_cmp(&ym) {\n None | Some(Ordering::Equal) => match xf.partial_cmp(&yf) {\n None | Some(Ordering::Equal) => xa.partial_cmp(&ya),\n Some(order) => Some(order),\n },\n Some(order) => Some(order),\n }\n }\n}\nimpl Ord for ResolvedFunctionName {\n fn cmp(&self, other: &Self) -> Ordering {\n self.partial_cmp(other).unwrap()\n }\n}\n\nimpl ResolvedFunctionName {\n pub fn to_local(&self) -> LocalFunctionName {\n LocalFunctionName {\n span: self.span,\n function: self.function,\n arity: self.arity,\n }\n }\n}\n\n/// Represents a partially-resolved function name, not yet associated with a module\n/// This is typically used to express local captures, e.g. `fun do_stuff/0`\n#[derive(Debug, Clone)]\npub struct PartiallyResolvedFunctionName {\n pub span: SourceSpan,\n pub id: NodeId,\n pub function: Ident,\n pub arity: usize,\n}\nimpl PartiallyResolvedFunctionName {\n pub fn resolve(&self, module: Ident) -> ResolvedFunctionName {\n ResolvedFunctionName {\n span: self.span.clone(),\n id: self.id,\n module,\n function: self.function.clone(),\n arity: self.arity,\n }\n }\n}\nimpl PartialEq for PartiallyResolvedFunctionName {\n fn eq(&self, other: &Self) -> bool {\n self.function == other.function && self.arity == other.arity\n }\n}\nimpl Eq for PartiallyResolvedFunctionName {}\nimpl Hash for PartiallyResolvedFunctionName {\n fn hash(&self, state: &mut H) {\n self.function.hash(state);\n self.arity.hash(state);\n }\n}\nimpl PartialOrd for PartiallyResolvedFunctionName {\n fn partial_cmp(&self, other: &Self) -> Option {\n let (xf, xa) = (self.function, self.arity);\n let (yf, ya) = (other.function, other.arity);\n match xf.partial_cmp(&yf) {\n None | Some(Ordering::Equal) => xa.partial_cmp(&ya),\n Some(order) => Some(order),\n }\n }\n}\n\nimpl PartiallyResolvedFunctionName {\n pub fn to_local(&self) -> LocalFunctionName {\n LocalFunctionName {\n span: self.span,\n function: self.function,\n arity: self.arity,\n }\n }\n}\n\n/// Represents a function name which contains parts which are not yet concrete,\n/// i.e. they are expressions which need to be evaluated to know precisely which\n/// module or function is referenced\n#[derive(Debug, Clone)]\npub struct UnresolvedFunctionName {\n pub span: SourceSpan,\n pub id: NodeId,\n pub module: Option,\n pub function: Name,\n pub arity: Arity,\n}\nimpl PartialEq for UnresolvedFunctionName {\n fn eq(&self, other: &Self) -> bool {\n self.module == other.module && self.function == other.function && self.arity == other.arity\n }\n}\nimpl Eq for UnresolvedFunctionName {}\nimpl Hash for UnresolvedFunctionName {\n fn hash(&self, state: &mut H) {\n self.module.hash(state);\n self.function.hash(state);\n self.arity.hash(state);\n }\n}\nimpl PartialOrd for UnresolvedFunctionName {\n fn partial_cmp(&self, other: &Self) -> Option {\n match self.module.partial_cmp(&other.module) {\n None | Some(Ordering::Equal) => match self.function.partial_cmp(&other.function) {\n None | Some(Ordering::Equal) => self.arity.partial_cmp(&other.arity),\n Some(order) => Some(order),\n },\n Some(order) => Some(order),\n }\n }\n}\n\n#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Hash)]\npub enum FunctionName {\n Resolved(ResolvedFunctionName),\n PartiallyResolved(PartiallyResolvedFunctionName),\n Unresolved(UnresolvedFunctionName),\n}\nimpl FunctionName {\n pub fn span(&self) -> SourceSpan {\n match self {\n &FunctionName::Resolved(ResolvedFunctionName { ref span, .. }) => span.clone(),\n &FunctionName::PartiallyResolved(PartiallyResolvedFunctionName {\n ref span, ..\n }) => span.clone(),\n &FunctionName::Unresolved(UnresolvedFunctionName { ref span, .. }) => span.clone(),\n }\n }\n pub fn id(&self) -> NodeId {\n match self {\n FunctionName::Resolved(fun) => fun.id,\n FunctionName::PartiallyResolved(fun) => fun.id,\n FunctionName::Unresolved(fun) => fun.id,\n }\n }\n\n pub fn detect(\n span: SourceSpan,\n nid: &mut NodeIdGenerator,\n module: Option,\n function: Name,\n arity: Arity,\n ) -> Self {\n if module.is_none() {\n return match (function, arity) {\n (Name::Atom(f), Arity::Int(a)) => {\n FunctionName::PartiallyResolved(PartiallyResolvedFunctionName {\n span,\n id: nid.next(),\n function: f,\n arity: a,\n })\n }\n _ => FunctionName::Unresolved(UnresolvedFunctionName {\n span,\n id: nid.next(),\n module: None,\n function,\n arity,\n }),\n };\n }\n\n if let (Some(Name::Atom(m)), Name::Atom(f), Arity::Int(a)) = (module, function, arity) {\n return FunctionName::Resolved(ResolvedFunctionName {\n span,\n id: nid.next(),\n module: m,\n function: f,\n arity: a,\n });\n }\n\n FunctionName::Unresolved(UnresolvedFunctionName {\n span,\n id: nid.next(),\n module,\n function,\n arity,\n })\n }\n\n pub fn from_clause(nid: &mut NodeIdGenerator, clause: &FunctionClause) -> FunctionName {\n match clause {\n &FunctionClause {\n name: Some(ref name),\n ref span,\n ref params,\n ..\n } => FunctionName::PartiallyResolved(PartiallyResolvedFunctionName {\n span: span.clone(),\n id: nid.next(),\n function: name.atom(),\n arity: params.len(),\n }),\n _ => panic!(\"cannot create a FunctionName from an anonymous FunctionClause!\"),\n }\n }\n}\nimpl fmt::Display for FunctionName {\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n match self {\n FunctionName::Resolved(ResolvedFunctionName {\n ref module,\n ref function,\n arity,\n ..\n }) => write!(f, \"{}:{}/{}\", module, function, arity),\n FunctionName::PartiallyResolved(PartiallyResolvedFunctionName {\n ref function,\n arity,\n ..\n }) => write!(f, \"{}/{}\", function, arity),\n FunctionName::Unresolved(UnresolvedFunctionName {\n module: Some(ref module),\n ref function,\n arity,\n ..\n }) => write!(f, \"{:?}:{:?}/{:?}\", module, function, arity),\n FunctionName::Unresolved(UnresolvedFunctionName {\n ref function,\n arity,\n ..\n }) => write!(f, \"{:?}/{:?}\", function, arity),\n }\n }\n}\n\n#[derive(Debug, Clone)]\npub struct NamedFunction {\n pub span: SourceSpan,\n pub id: NodeId,\n pub name: Name,\n pub arity: usize,\n pub clauses: Vec,\n pub spec: Option,\n}\nimpl PartialEq for NamedFunction {\n fn eq(&self, other: &Self) -> bool {\n self.name == other.name\n && self.arity == other.arity\n && self.clauses == other.clauses\n && self.spec == other.spec\n }\n}\nimpl NamedFunction {\n pub fn new(\n errs: &mut dyn ErrorReceiver,\n span: SourceSpan,\n nid: &mut NodeIdGenerator,\n clauses: Vec,\n ) -> Result {\n debug_assert!(clauses.len() > 0);\n let (head, rest) = clauses.split_first().unwrap();\n\n if head.name.is_none() {\n errs.error(\n PreprocessorError::ShowDiagnostic {\n diagnostic: Diagnostic::error()\n .with_message(\"expected named function\")\n .with_labels(vec![Label::primary(head.span.source_id(), head.span)\n .with_message(\n \"this clause has no name, but a name is required here\",\n )]),\n }\n .into(),\n );\n return Err(());\n }\n\n let head_span = &head.span;\n let name = head.name.clone().unwrap();\n let params = &head.params;\n let arity = params.len();\n\n // Check clauses\n let mut last_clause = head_span.clone();\n for clause in rest.iter() {\n if clause.name.is_none() {\n errs.error(\n PreprocessorError::ShowDiagnostic {\n diagnostic: Diagnostic::error()\n .with_message(\"expected named function clause\")\n .with_labels(vec![\n Label::primary(clause.span.source_id(), clause.span).with_message(\n \"this clause has no name, but a name is required here\",\n ),\n Label::secondary(last_clause.source_id(), last_clause)\n .with_message(\n \"expected a clause with the same name as this clause\",\n ),\n ]),\n }\n .into(),\n );\n return Err(());\n }\n\n let clause_span = &clause.span;\n let clause_name = clause.name.clone().unwrap();\n let clause_params = &clause.params;\n let clause_arity = clause_params.len();\n\n if clause_name != name {\n errs.error(ParserError::ShowDiagnostic {\n diagnostic: Diagnostic::error()\n .with_message(\"unterminated function clause\")\n .with_labels(vec![\n Label::primary(last_clause.source_id(), last_clause.clone())\n .with_message(\n \"this clause ends with ';', indicating that another clause follows\",\n ),\n Label::secondary(clause_span.source_id(), clause_span.clone())\n .with_message(\"but this clause has a different name\"),\n ]),\n });\n continue;\n }\n if clause_arity != arity {\n errs.error(ParserError::ShowDiagnostic {\n diagnostic: Diagnostic::error()\n .with_message(\"unterminated function clause\")\n .with_labels(vec![\n Label::primary(last_clause.source_id(), last_clause.clone())\n .with_message(\n \"this clause ends with ';', indicating that another clause follows\",\n ),\n Label::secondary(clause_span.source_id(), clause_span.clone())\n .with_message(\"but this clause has a different arity\"),\n ]),\n });\n continue;\n }\n\n last_clause = clause_span.clone();\n }\n\n Ok(NamedFunction {\n span,\n id: nid.next(),\n name: name.clone(),\n arity,\n clauses,\n spec: None,\n })\n }\n}\n\n#[derive(Debug, Clone)]\npub struct Lambda {\n pub span: SourceSpan,\n pub id: NodeId,\n pub arity: usize,\n pub clauses: Vec,\n}\nimpl PartialEq for Lambda {\n fn eq(&self, other: &Self) -> bool {\n self.arity == other.arity && self.clauses == other.clauses\n }\n}\nimpl Lambda {\n pub fn new(\n errs: &mut dyn ErrorReceiver,\n span: SourceSpan,\n nid: &mut NodeIdGenerator,\n clauses: Vec,\n ) -> Result {\n debug_assert!(clauses.len() > 0);\n let (head, rest) = clauses.split_first().unwrap();\n\n let head_span = &head.span;\n let params = &head.params;\n let arity = params.len();\n\n // Check clauses\n let mut last_clause = head_span.clone();\n for clause in rest.iter() {\n let clause_span = &clause.span;\n let clause_name = &clause.name;\n let clause_params = &clause.params;\n let clause_arity = clause_params.len();\n\n if clause_name.is_some() {\n errs.error(ParserError::ShowDiagnostic {\n diagnostic: Diagnostic::error()\n .with_message(\"mismatched function clause\")\n .with_labels(vec![\n Label::primary(clause_span.source_id(), clause_span.clone())\n .with_message(\"this clause is named\"),\n Label::secondary(last_clause.source_id(), last_clause.clone())\n .with_message(\n \"but this clause is unnamed, all clauses must share the same name\",\n ),\n ]),\n });\n return Err(());\n }\n\n if clause_arity != arity {\n errs.error(ParserError::ShowDiagnostic {\n diagnostic: Diagnostic::error()\n .with_message(\"mismatched function clause\")\n .with_labels(vec![\n Label::primary(clause_span.source_id(), clause_span.clone())\n .with_message(\n \"the arity of this clause does not match the previous clause\",\n ),\n Label::secondary(last_clause.source_id(), last_clause.clone())\n .with_message(\"this is the previous clause\"),\n ]),\n });\n continue;\n }\n\n last_clause = clause_span.clone();\n }\n\n Ok(Lambda {\n span,\n id: nid.next(),\n arity,\n clauses,\n })\n }\n}\n\n#[derive(Debug, Clone, PartialEq)]\npub enum Function {\n Named(NamedFunction),\n Unnamed(Lambda),\n}\nimpl Function {\n pub fn span(&self) -> SourceSpan {\n match self {\n &Function::Named(NamedFunction { ref span, .. }) => span.clone(),\n &Function::Unnamed(Lambda { ref span, .. }) => span.clone(),\n }\n }\n pub fn id(&self) -> NodeId {\n match self {\n Function::Named(fun) => fun.id,\n Function::Unnamed(fun) => fun.id,\n }\n }\n\n pub fn new(\n errs: &mut dyn ErrorReceiver,\n span: SourceSpan,\n nid: &mut NodeIdGenerator,\n clauses: Vec,\n ) -> Result {\n debug_assert!(clauses.len() > 0);\n\n if clauses[0].name.is_some() {\n Ok(Function::Named(NamedFunction::new(\n errs, span, nid, clauses,\n )?))\n } else {\n Ok(Function::Unnamed(Lambda::new(errs, span, nid, clauses)?))\n }\n }\n}\n\n#[derive(Debug, Clone)]\npub struct FunctionClause {\n pub span: SourceSpan,\n pub name: Option,\n pub params: Vec,\n pub guard: Option>,\n pub body: Vec,\n}\nimpl PartialEq for FunctionClause {\n fn eq(&self, other: &FunctionClause) -> bool {\n self.name == other.name\n && self.params == other.params\n && self.guard == other.guard\n && self.body == other.body\n }\n}\nimpl FunctionClause {\n pub fn new(\n span: SourceSpan,\n name: Option,\n params: Vec,\n guard: Option>,\n body: Vec,\n ) -> Self {\n FunctionClause {\n span,\n name,\n params,\n guard,\n body,\n }\n }\n}\n\n#[derive(Debug, Clone)]\npub struct Guard {\n pub span: SourceSpan,\n pub conditions: Vec,\n}\nimpl PartialEq for Guard {\n fn eq(&self, other: &Guard) -> bool {\n self.conditions == other.conditions\n }\n}\n" }, { "path": "libeir_syntax_erl/src/parser/ast/mod.rs", "content": "mod attributes;\nmod expr;\nmod functions;\nmod module;\nmod types;\n\nuse libeir_diagnostics::{SourceIndex, SourceSpan};\n\npub use self::attributes::*;\npub use self::expr::*;\npub use self::functions::*;\npub use self::module::*;\npub use self::types::*;\npub use super::{ParseError, ParserError};\npub use crate::lexer::{Ident, Symbol};\n\nuse crate::lexer::Token;\nuse crate::preprocessor::PreprocessorError;\n\n/// Used for AST functions which need to raise an error to the parser directly\npub type TryParseResult =\n Result>;\n\n/// Represents either a concrete name (an atom) or a variable name (an identifier).\n/// This is used in constructs where either are permitted.\n#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]\npub enum Name {\n Atom(Ident),\n Var(Ident),\n}\nimpl Name {\n pub fn symbol(&self) -> Symbol {\n match self {\n Name::Atom(Ident { ref name, .. }) => name.clone(),\n Name::Var(Ident { ref name, .. }) => name.clone(),\n }\n }\n pub fn span(&self) -> SourceSpan {\n match self {\n Name::Atom(Ident { ref span, .. }) => span.clone(),\n Name::Var(Ident { ref span, .. }) => span.clone(),\n }\n }\n pub fn atom(&self) -> Ident {\n match self {\n Name::Atom(ident) => *ident,\n _ => panic!(),\n }\n }\n pub fn var(&self) -> Ident {\n match self {\n Name::Var(ident) => *ident,\n _ => panic!(),\n }\n }\n}\nimpl PartialOrd for Name {\n fn partial_cmp(&self, other: &Name) -> Option {\n self.symbol().partial_cmp(&other.symbol())\n }\n}\n\n#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd)]\npub enum Arity {\n Int(usize),\n Var(Ident),\n}\n\n#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd)]\npub struct NodeId(pub usize);\n\n#[derive(Debug, Clone)]\npub struct NodeIdGenerator(usize);\nimpl NodeIdGenerator {\n pub fn new() -> Self {\n NodeIdGenerator(0)\n }\n\n pub fn next(&mut self) -> NodeId {\n self.0 += 1;\n NodeId(self.0)\n }\n}\n\n/// The set of all binary operators which may be used in expressions\n#[derive(Debug, Copy, Clone, PartialEq)]\npub enum BinaryOp {\n // 100 !, right associative\n Send,\n // 150 orelse\n OrElse,\n // 160 andalso\n AndAlso,\n // 200 \n Equal, // right associative\n NotEqual,\n Lte,\n Lt,\n Gte,\n Gt,\n StrictEqual,\n StrictNotEqual,\n // 300 , right associative\n Append,\n Remove,\n // 400 , left associative\n Add,\n Sub,\n Bor,\n Bxor,\n Bsl,\n Bsr,\n Or,\n Xor,\n // 500 , left associative\n Divide,\n Multiply,\n Div,\n Rem,\n Band,\n And,\n}\n\n/// The set of all unary (prefix) operators which may be used in expressions\n#[derive(Debug, Copy, Clone, PartialEq)]\npub enum UnaryOp {\n // 600 \n Plus,\n Minus,\n Bnot,\n Not,\n}\n" }, { "path": "libeir_syntax_erl/src/parser/ast/module.rs", "content": "use std::collections::btree_map::Entry;\nuse std::collections::BTreeMap;\nuse std::collections::{HashMap, HashSet};\n\nuse libeir_diagnostics::{Diagnostic, Label, SourceSpan};\nuse libeir_util_number::ToPrimitive;\nuse libeir_util_parse::ErrorReceiver;\n\nuse super::Name;\nuse super::NodeIdGenerator;\nuse super::ParserError;\nuse super::{Apply, Cons, Nil, Remote, Tuple, Var};\nuse super::{Attribute, Deprecation, UserAttribute};\nuse super::{Callback, Record, TypeDef, TypeSig, TypeSpec};\nuse super::{Expr, Ident, Literal, Symbol};\nuse super::{\n FunctionClause, FunctionName, LocalFunctionName, NamedFunction, PartiallyResolvedFunctionName,\n ResolvedFunctionName,\n};\n\n/// Represents expressions valid at the top level of a module body\n#[derive(Debug, Clone, PartialEq)]\npub enum TopLevel {\n Attribute(Attribute),\n Record(Record),\n Function(NamedFunction),\n}\n\n#[derive(Debug, Clone)]\npub struct DefinedRecord {\n pub record: Record,\n pub field_idx_map: HashMap,\n}\nimpl PartialEq for DefinedRecord {\n fn eq(&self, other: &Self) -> bool {\n self.record == other.record\n }\n}\n\n/// Represents a complete module, broken down into its constituent parts\n///\n/// Creating a module via `Module::new` ensures that each field is correctly\n/// populated, that sanity checking of the top-level constructs is performed,\n/// and that a module is ready for semantic analysis and lowering to IR\n///\n/// A key step performed by `Module::new` is decorating `ResolvedFunctionName`\n/// structs with the current module where appropriate (as this is currently not\n/// done during parsing, as the module is constructed last). This means that once\n/// constructed, one can use `ResolvedFunctionName` equality in sets/maps, which\n/// allows us to easily check definitions, usages, and more.\n#[derive(Debug, Clone)]\npub struct Module {\n pub span: SourceSpan,\n pub name: Ident,\n pub vsn: Option,\n pub author: Option,\n pub compile: Option,\n pub on_load: Option,\n pub imports: HashMap,\n pub exports: HashSet,\n pub removed: HashMap,\n pub types: HashMap,\n pub exported_types: HashSet,\n pub behaviours: HashSet,\n pub callbacks: HashMap,\n pub records: HashMap,\n pub attributes: HashMap,\n pub functions: BTreeMap,\n // Used for module-level deprecation\n pub deprecation: Option,\n // Used for function-level deprecation\n pub deprecations: HashSet,\n}\nimpl Module {\n /// Called by the parser to create the module once all of the top-level expressions have been\n /// parsed, in other words this is the last function called when parsing a module.\n ///\n /// As a result, this function performs some initial linting of the module:\n ///\n /// * If configured to do so, warns if functions are missing type specs\n /// * Warns about type specs for undefined functions\n /// * Warns about redefined attributes\n /// * Errors on invalid syntax in built-in attributes (e.g. -import(..))\n /// * Errors on mismatched function clauses (name/arity)\n /// * Errors on unterminated function clauses\n /// * Errors on redefined functions\n ///\n /// And a few other similar lints\n pub fn new(\n errs: &mut dyn ErrorReceiver,\n span: SourceSpan,\n nid: &mut NodeIdGenerator,\n name: Ident,\n mut body: Vec,\n ) -> Self {\n let mut module = Module {\n span,\n name,\n vsn: None,\n author: None,\n on_load: None,\n compile: None,\n imports: HashMap::new(),\n exports: HashSet::new(),\n removed: HashMap::new(),\n types: HashMap::new(),\n exported_types: HashSet::new(),\n behaviours: HashSet::new(),\n callbacks: HashMap::new(),\n records: HashMap::new(),\n attributes: HashMap::new(),\n functions: BTreeMap::new(),\n deprecation: None,\n deprecations: HashSet::new(),\n };\n\n // Functions will be decorated with their type specs as they are added\n // to the module. To accomplish this, we keep track of seen type specs\n // as they are defined, then later look up the spec for a function when\n // a definition is encountered\n let mut specs: HashMap = HashMap::new();\n\n // Walk every top-level expression and extend our initial module definition accordingly\n for item in body.drain(..) {\n match item {\n TopLevel::Attribute(Attribute::Vsn(aspan, vsn)) => {\n if module.vsn.is_none() {\n module.vsn = Some(vsn);\n continue;\n }\n let module_vsn_span = module.vsn.as_ref().map(|v| v.span()).unwrap();\n let module_vsn_source_id = module_vsn_span.source_id();\n errs.error(ParserError::ShowDiagnostic {\n diagnostic: Diagnostic::error()\n .with_message(\"attribute is already defined\")\n .with_labels(vec![\n Label::primary(aspan.source_id(), aspan)\n .with_message(\"redefinition occurs here\"),\n Label::secondary(module_vsn_source_id, module_vsn_span)\n .with_message(\"first defined here\"),\n ]),\n });\n }\n TopLevel::Attribute(Attribute::Author(aspan, author)) => {\n if module.author.is_none() {\n module.author = Some(author);\n continue;\n }\n let module_author_span = module.author.as_ref().map(|v| v.span()).unwrap();\n let module_author_source_id = module_author_span.source_id();\n errs.error(ParserError::ShowDiagnostic {\n diagnostic: Diagnostic::error()\n .with_message(\"attribute is already defined\")\n .with_labels(vec![\n Label::primary(aspan.source_id(), aspan)\n .with_message(\"redefinition occurs here\"),\n Label::secondary(module_author_source_id, module_author_span)\n .with_message(\"first defined here\"),\n ]),\n });\n }\n TopLevel::Attribute(Attribute::OnLoad(aspan, fname)) => {\n if module.on_load.is_none() {\n module.on_load = Some(fname.to_local());\n continue;\n }\n let module_onload_span = module.on_load.as_ref().map(|v| v.span).unwrap();\n let module_onload_source_id = module_onload_span.source_id();\n errs.error(ParserError::ShowDiagnostic {\n diagnostic: Diagnostic::error()\n .with_message(\"on_load can only be defined once\")\n .with_labels(vec![\n Label::primary(aspan.source_id(), aspan)\n .with_message(\"redefinition occurs here\"),\n Label::secondary(module_onload_source_id, module_onload_span)\n .with_message(\"first defined here\"),\n ]),\n });\n }\n TopLevel::Attribute(Attribute::Import(aspan, from_module, mut imports)) => {\n for import in imports.drain(..) {\n let import = import.resolve(from_module.clone());\n match module.imports.get(&import.to_local()) {\n None => {\n module.imports.insert(import.to_local(), import);\n }\n Some(ResolvedFunctionName {\n span: ref prev_span,\n ..\n }) => {\n errs.error(ParserError::ShowDiagnostic {\n diagnostic: Diagnostic::warning()\n .with_message(\"unused import\")\n .with_labels(vec![\n Label::primary(aspan.source_id(), aspan).with_message(\n \"this import is a duplicate of a previous import\",\n ),\n Label::secondary(\n prev_span.source_id(),\n prev_span.clone(),\n )\n .with_message(\"function was first imported here\"),\n ]),\n });\n }\n }\n }\n }\n TopLevel::Attribute(Attribute::Export(aspan, mut exports)) => {\n for export in exports.drain(..) {\n match module.exports.get(&export.to_local()) {\n None => {\n module.exports.insert(export.to_local());\n }\n Some(LocalFunctionName {\n span: ref prev_span,\n ..\n }) => {\n errs.error(ParserError::ShowDiagnostic {\n diagnostic: Diagnostic::warning()\n .with_message(\"already exported\")\n .with_labels(vec![\n Label::primary(aspan.source_id(), aspan)\n .with_message(\"duplicate export occurs here\"),\n Label::secondary(\n prev_span.source_id(),\n prev_span.clone(),\n )\n .with_message(\"function was first exported here\"),\n ]),\n });\n }\n }\n }\n }\n TopLevel::Attribute(Attribute::Removed(span, mut removed)) => {\n for (name, description) in removed.drain(..) {\n if let Some((prev_span, _)) = module.removed.get(&name.to_local()) {\n errs.error(ParserError::ShowDiagnostic {\n diagnostic: Diagnostic::warning()\n .with_message(\"already marked as removed\")\n .with_labels(vec![\n Label::primary(span.source_id(), span)\n .with_message(\"duplicate entry occurs here\"),\n Label::secondary(prev_span.source_id(), prev_span.clone())\n .with_message(\"function was marked here\"),\n ]),\n });\n } else {\n module.removed.insert(name.to_local(), (span, description));\n }\n }\n }\n TopLevel::Attribute(Attribute::Type(ty)) => {\n let arity = ty.params.len();\n let type_name = ResolvedFunctionName {\n span: ty.name.span.clone(),\n id: nid.next(),\n module: module.name.clone(),\n function: ty.name.clone(),\n arity,\n };\n match module.types.get(&type_name.to_local()) {\n None => {\n module.types.insert(type_name.to_local(), ty);\n }\n Some(TypeDef {\n span: ref prev_span,\n ..\n }) => {\n errs.error(ParserError::ShowDiagnostic {\n diagnostic: Diagnostic::warning()\n .with_message(\"type is already defined\")\n .with_labels(vec![\n Label::primary(ty.span.source_id(), ty.span)\n .with_message(\"redefinition occurs here\"),\n Label::secondary(prev_span.source_id(), prev_span.clone())\n .with_message(\"type was first defined here\"),\n ]),\n });\n }\n }\n }\n TopLevel::Attribute(Attribute::ExportType(aspan, mut exports)) => {\n for export in exports.drain(..) {\n match module.exported_types.get(&export.to_local()) {\n None => {\n module.exported_types.insert(export.to_local());\n }\n Some(LocalFunctionName {\n span: ref prev_span,\n ..\n }) => {\n errs.error(ParserError::ShowDiagnostic {\n diagnostic: Diagnostic::warning()\n .with_message(\"type already exported\")\n .with_labels(vec![\n Label::primary(aspan.source_id(), aspan)\n .with_message(\"duplicate export occurs here\"),\n Label::secondary(\n prev_span.source_id(),\n prev_span.clone(),\n )\n .with_message(\"type was first exported here\"),\n ]),\n });\n }\n }\n }\n }\n TopLevel::Attribute(Attribute::Behaviour(aspan, b_module)) => {\n match module.behaviours.get(&b_module) {\n None => {\n module.behaviours.insert(b_module);\n }\n Some(Ident {\n span: ref prev_span,\n ..\n }) => {\n errs.error(ParserError::ShowDiagnostic {\n diagnostic: Diagnostic::warning()\n .with_message(\"duplicate behaviour declaration\")\n .with_labels(vec![\n Label::primary(aspan.source_id(), aspan)\n .with_message(\"duplicate declaration occurs here\"),\n Label::secondary(prev_span.source_id(), prev_span.clone())\n .with_message(\"first declaration occurs here\"),\n ]),\n });\n }\n }\n }\n TopLevel::Attribute(Attribute::Callback(callback)) => {\n let first_sig = callback.sigs.first().unwrap();\n let arity = first_sig.params.len();\n\n // Verify that all clauses match\n if callback.sigs.len() > 1 {\n for TypeSig {\n span: ref sigspan,\n ref params,\n ..\n } in &callback.sigs[1..]\n {\n if params.len() != arity {\n errs.error(ParserError::ShowDiagnostic {\n diagnostic: Diagnostic::error()\n .with_message(\"mismatched arity\")\n .with_labels(vec![\n Label::primary(sigspan.source_id(), sigspan.clone())\n .with_message(format!(\n \"expected arity of {}\",\n arity\n )),\n Label::secondary(\n first_sig.span.source_id(),\n first_sig.span.clone(),\n )\n .with_message(\n \"expected arity was derived from this clause\",\n ),\n ]),\n });\n }\n }\n }\n // Check for redefinition\n let cb_name = ResolvedFunctionName {\n span: callback.span.clone(),\n id: nid.next(),\n module: module.name.clone(),\n function: callback.function.clone(),\n arity,\n };\n match module.callbacks.get(&cb_name.to_local()) {\n None => {\n module.callbacks.insert(cb_name.to_local(), callback);\n continue;\n }\n Some(ref a @ Callback {\n //span: ref prev_span,\n ..\n }) => {\n errs.error(ParserError::ShowDiagnostic {\n diagnostic: Diagnostic::error()\n .with_message(\"cannot redefine callback\")\n .with_labels(vec![\n Label::primary(callback.span.source_id(), callback.span)\n .with_message(\"redefinition occurs here\"),\n Label::secondary(a.span.source_id(), a.span.clone())\n .with_message(\"callback first defined here\")\n ]),\n });\n }\n }\n }\n TopLevel::Attribute(Attribute::Spec(typespec)) => {\n let first_sig = typespec.sigs.first().unwrap();\n let arity = first_sig.params.len();\n\n // Verify that all clauses match\n if typespec.sigs.len() > 1 {\n for TypeSig {\n span: ref sigspan,\n ref params,\n ..\n } in &typespec.sigs[1..]\n {\n if params.len() != arity {\n errs.error(ParserError::ShowDiagnostic {\n diagnostic: Diagnostic::error()\n .with_message(\"mismatched arity\")\n .with_labels(vec![\n Label::primary(sigspan.source_id(), sigspan.clone())\n .with_message(format!(\n \"expected arity of {}\",\n arity\n )),\n Label::secondary(\n first_sig.span.source_id(),\n first_sig.span.clone(),\n )\n .with_message(\n \"expected arity was derived from this clause\",\n ),\n ]),\n });\n }\n }\n }\n // Check for redefinition\n let spec_name = ResolvedFunctionName {\n span: typespec.span.clone(),\n id: nid.next(),\n module: module.name.clone(),\n function: typespec.function.clone(),\n arity,\n };\n match specs.get(&spec_name) {\n None => {\n specs.insert(spec_name.clone(), typespec);\n }\n Some(TypeSpec {\n span: ref prev_span,\n ..\n }) => {\n errs.error(ParserError::ShowDiagnostic {\n diagnostic: Diagnostic::error()\n .with_message(\"spec already defined\")\n .with_labels(vec![\n Label::primary(typespec.span.source_id(), typespec.span)\n .with_message(\"redefinition occurs here\"),\n Label::secondary(prev_span.source_id(), prev_span.clone())\n .with_message(\"spec first defined here\"),\n ]),\n });\n }\n }\n }\n TopLevel::Attribute(Attribute::Compile(_, compile)) => match module.compile {\n None => {\n let (opts, mut validation_errs) =\n CompileOptions::from_expr(&module.name, &compile);\n module.compile = Some(opts);\n for diagnostic in validation_errs.drain(..) {\n errs.error(ParserError::ShowDiagnostic { diagnostic });\n }\n continue;\n }\n Some(ref mut opts) => {\n if let Err(mut validation_errs) =\n opts.merge_from_expr(&module.name, &compile)\n {\n for diagnostic in validation_errs.drain(..) {\n errs.error(ParserError::ShowDiagnostic { diagnostic });\n }\n }\n }\n },\n TopLevel::Attribute(Attribute::Deprecation(mut deprecations)) => {\n for deprecation in deprecations.drain(..) {\n match deprecation {\n Deprecation::Module {\n span: ref dspan, ..\n } => match module.deprecation {\n None => {\n module.deprecation = Some(deprecation);\n }\n Some(Deprecation::Module {\n span: ref orig_span,\n ..\n }) => {\n errs.error(ParserError::ShowDiagnostic {\n diagnostic: Diagnostic::warning()\n .with_message(\"redundant deprecation\")\n .with_labels(vec![\n Label::primary(dspan.source_id(), dspan.clone())\n .with_message(\"this module is already deprecated by a previous declaration\"),\n Label::secondary(orig_span.source_id(), orig_span.clone())\n .with_message(\"deprecation first declared here\")\n ]),\n });\n }\n Some(Deprecation::Function { .. }) => unreachable!(),\n },\n Deprecation::Function {\n span: ref fspan, ..\n } => {\n if let Some(Deprecation::Module {\n span: ref mspan, ..\n }) = module.deprecation\n {\n errs.error(ParserError::ShowDiagnostic {\n diagnostic: Diagnostic::warning()\n .with_message(\"redundant deprecation\")\n .with_labels(vec![\n Label::primary(fspan.source_id(), *fspan)\n .with_message(\"module is deprecated, so deprecating functions is redundant\"),\n Label::secondary(mspan.source_id(), mspan.clone())\n .with_message(\"module deprecation occurs here\")\n ]),\n });\n continue;\n }\n\n match module.deprecations.get(&deprecation) {\n None => {\n module.deprecations.insert(deprecation);\n }\n Some(Deprecation::Function {\n span: ref prev_span,\n ..\n }) => {\n errs.error(ParserError::ShowDiagnostic {\n diagnostic: Diagnostic::warning()\n .with_message(\"redundant deprecation\")\n .with_labels(vec![\n Label::primary(fspan.source_id(), *fspan)\n .with_message(\"this function is already deprecated by a previous declaration\"),\n Label::secondary(prev_span.source_id(), prev_span.clone())\n .with_message(\"deprecation first declared here\")\n ])\n });\n }\n Some(Deprecation::Module { .. }) => unreachable!(),\n }\n }\n }\n }\n }\n TopLevel::Attribute(Attribute::Custom(attr)) => {\n match attr.name.name.as_str().get() {\n \"module\" => {\n errs.error(ParserError::ShowDiagnostic {\n diagnostic: Diagnostic::error()\n .with_message(\"multiple module declarations\")\n .with_labels(vec![\n Label::primary(attr.span.source_id(), attr.span.clone())\n .with_message(\"invalid declaration occurs here\"),\n Label::secondary(\n module.name.span.source_id(),\n module.name.span.clone(),\n )\n .with_message(\"module first declared here\"),\n ]),\n });\n continue;\n }\n \"optional_callbacks\" => {\n //if let Some(callback) = module.callbacks.get_mut()\n continue;\n }\n \"dialyzer\" => {\n // Drop dialyzer attributes as they are unused\n continue;\n }\n _ => (),\n }\n match module.attributes.get(&attr.name) {\n None => {\n module.attributes.insert(attr.name.clone(), attr);\n }\n Some(UserAttribute {\n span: ref prev_span,\n ..\n }) => {\n errs.error(ParserError::ShowDiagnostic {\n diagnostic: Diagnostic::warning()\n .with_message(\"redefined attribute\")\n .with_labels(vec![\n Label::primary(attr.span.source_id(), attr.span.clone())\n .with_message(\"redefinition occurs here\"),\n Label::secondary(prev_span.source_id(), prev_span.clone())\n .with_message(\"previously defined here\"),\n ]),\n });\n module.attributes.insert(attr.name.clone(), attr);\n }\n }\n }\n TopLevel::Record(mut record) => {\n let name = record.name.name.clone();\n match module.records.get(&name) {\n None => {\n // FIXME: Remove the set when hashmap gets api\n // for getting keys.\n let mut fields = HashSet::::new();\n let mut field_idx_map = HashMap::::new();\n for (idx, field) in record.fields.iter_mut().enumerate() {\n if field.value.is_none() {\n field.value = Some(atom!(nid, undefined));\n }\n if let Some(prev) = fields.get(&field.name) {\n errs.error(ParserError::ShowDiagnostic {\n diagnostic: Diagnostic::error()\n .with_message(\"duplicate field in record\")\n .with_labels(vec![\n Label::primary(\n field.name.span.source_id(),\n field.name.span,\n )\n .with_message(\"duplicate field occurs here\"),\n Label::secondary(prev.span.source_id(), prev.span)\n .with_message(\"previous field\"),\n ]),\n });\n }\n fields.insert(field.name);\n field_idx_map.insert(field.name, idx);\n }\n module.records.insert(\n name,\n DefinedRecord {\n record,\n field_idx_map,\n },\n );\n }\n Some(prev) => {\n errs.error(ParserError::ShowDiagnostic {\n diagnostic: Diagnostic::error()\n .with_message(\"record already defined\")\n .with_labels(vec![\n Label::primary(record.span.source_id(), record.span)\n .with_message(\"duplicate definition occurs here\"),\n Label::secondary(\n prev.record.span.source_id(),\n prev.record.span,\n )\n .with_message(\"previously defined here\"),\n ]),\n });\n }\n }\n }\n TopLevel::Function(mut function @ NamedFunction { .. }) => {\n let name = &function.name;\n let resolved_name = ResolvedFunctionName {\n span: name.span(),\n id: nid.next(),\n module: module.name.clone(),\n function: name.atom(),\n arity: function.arity,\n };\n let warn_missing_specs = module\n .compile\n .as_ref()\n .map(|c| c.warn_missing_spec)\n .unwrap_or(false);\n function.spec = match specs.get(&resolved_name) {\n None if warn_missing_specs => {\n errs.error(ParserError::ShowDiagnostic {\n diagnostic: Diagnostic::warning()\n .with_message(\"missing function spec\")\n .with_labels(vec![Label::primary(\n function.span.source_id(),\n function.span.clone(),\n )\n .with_message(\"expected type spec for this function\")]),\n });\n None\n }\n None => None,\n Some(spec) => Some(spec.clone()),\n };\n match module.functions.entry(resolved_name.to_local()) {\n Entry::Vacant(f) => {\n f.insert(function);\n }\n Entry::Occupied(initial_def) => {\n let def = initial_def.into_mut();\n errs.error(ParserError::ShowDiagnostic {\n diagnostic: Diagnostic::error()\n .with_message(\n \"clauses from the same function should be grouped together\",\n )\n .with_labels(vec![\n Label::primary(\n function.span.source_id(),\n function.span.clone(),\n )\n .with_message(\"found more clauses here\"),\n Label::secondary(def.span.source_id(), def.span.clone())\n .with_message(\"function is first defined here\"),\n ]),\n });\n def.clauses.append(&mut function.clauses);\n }\n }\n }\n }\n }\n\n // Ensure internal pseudo-locals are defined\n module.define_pseudolocals(nid);\n\n // Auto imports\n module.add_auto_imports(nid);\n\n // Verify on_load function exists\n if let Some(ref on_load_name) = module.on_load {\n if !module.functions.contains_key(on_load_name) {\n errs.error(ParserError::ShowDiagnostic {\n diagnostic: Diagnostic::error()\n .with_message(\"invalid on_load function\")\n .with_labels(vec![Label::primary(\n on_load_name.span.source_id(),\n on_load_name.span.clone(),\n )\n .with_message(\"this function is not defined in this module\")]),\n });\n }\n }\n\n // Check for orphaned type specs\n for (spec_name, spec) in &specs {\n if !module.functions.contains_key(&spec_name.to_local()) {\n errs.warning(ParserError::ShowDiagnostic {\n diagnostic: Diagnostic::warning()\n .with_message(\"type spec for undefined function\")\n .with_labels(vec![Label::primary(\n spec.span.source_id(),\n spec.span.clone(),\n )\n .with_message(\"this type spec has no corresponding function definition\")]),\n });\n }\n }\n\n module\n }\n\n fn add_auto_imports(&mut self, nid: &mut NodeIdGenerator) {\n macro_rules! auto_imports {\n ($($m:ident : $f:ident / $a:expr),*) => {\n [\n $(\n ResolvedFunctionName {\n span: self.name.span,\n id: nid.next(),\n module: Ident::from_str(stringify!($m)),\n function: Ident::from_str(stringify!($f)),\n arity: $a,\n },\n )*\n ]\n }\n }\n\n let autos = auto_imports! {\n erlang:abs/1,\n erlang:apply/2,\n erlang:apply/3,\n erlang:atom_to_binary/2,\n erlang:atom_to_list/1,\n erlang:binary_part/2,\n erlang:binary_part/3,\n erlang:binary_to_atom/2,\n erlang:binary_to_existing_atom/2,\n erlang:binary_to_float/1,\n erlang:binary_to_integer/1,\n erlang:binary_to_integer/2,\n erlang:binary_to_list/1,\n erlang:binary_to_list/3,\n erlang:binary_to_term/1,\n erlang:binary_to_term/2,\n erlang:bit_size/1,\n erlang:bitstring_to_list/1,\n erlang:byte_size/1,\n erlang:ceil/1,\n erlang:check_old_code/1,\n erlang:check_process_code/2,\n erlang:check_process_code/3,\n erlang:date/0,\n erlang:delete_module/1,\n erlang:demonitor/1,\n erlang:demonitor/2,\n erlang:disconnect_node/1,\n erlang:element/2,\n erlang:erase/0,\n erlang:erase/1,\n erlang:error/1,\n erlang:error/2,\n erlang:exit/1,\n erlang:exit/2,\n erlang:float/1,\n erlang:float_to_binary/1,\n erlang:float_to_binary/2,\n erlang:float_to_list/1,\n erlang:float_to_list/2,\n erlang:floor/1,\n erlang:garbage_collect/0,\n erlang:garbage_collect/1,\n erlang:garbage_collect/2,\n erlang:get/0,\n erlang:get/1,\n erlang:get_keys/0,\n erlang:get_keys/1,\n erlang:group_leader/0,\n erlang:group_leader/2,\n erlang:halt/0,\n erlang:halt/1,\n erlang:halt/2,\n erlang:hd/1,\n erlang:integer_to_binary/1,\n erlang:integer_to_binary/2,\n erlang:integer_to_list/1,\n erlang:integer_to_list/2,\n erlang:iolist_size/1,\n erlang:iolist_to_binary/1,\n erlang:iolist_to_iovec/1,\n erlang:is_alive/0,\n erlang:is_atom/1,\n erlang:is_binary/1,\n erlang:is_bitstring/1,\n erlang:is_boolean/1,\n erlang:is_float/1,\n erlang:is_function/1,\n erlang:is_function/2,\n erlang:is_integer/1,\n erlang:is_list/1,\n erlang:is_map/1,\n erlang:is_map_key/2,\n erlang:is_number/1,\n erlang:is_pid/1,\n erlang:is_port/1,\n erlang:is_process_alive/1,\n erlang:is_record/2,\n erlang:is_record/3,\n erlang:is_reference/1,\n erlang:is_tuple/1,\n erlang:length/1,\n erlang:link/1,\n erlang:list_to_atom/1,\n erlang:list_to_binary/1,\n erlang:list_to_bitstring/1,\n erlang:list_to_existing_atom/1,\n erlang:list_to_float/1,\n erlang:list_to_integer/1,\n erlang:list_to_integer/2,\n erlang:list_to_pid/1,\n erlang:list_to_port/1,\n erlang:list_to_ref/1,\n erlang:list_to_tuple/1,\n erlang:load_module/2,\n erlang:make_ref/0,\n erlang:map_get/2,\n erlang:map_size/1,\n erlang:max/2,\n erlang:min/2,\n erlang:module_loaded/1,\n erlang:monitor/2,\n erlang:monitor_node/2,\n erlang:node/0,\n erlang:node/1,\n erlang:nodes/0,\n erlang:nodes/1,\n erlang:now/0,\n erlang:open_port/2,\n erlang:pid_to_list/1,\n erlang:port_close/1,\n erlang:port_command/2,\n erlang:port_command/3,\n erlang:port_connect/2,\n erlang:port_control/3,\n erlang:port_to_list/1,\n erlang:pre_loaded/0,\n erlang:process_flag/2,\n erlang:process_flag/3,\n erlang:process_info/1,\n erlang:process_info/2,\n erlang:processes/0,\n erlang:purge_module/1,\n erlang:put/2,\n erlang:ref_to_list/1,\n erlang:register/2,\n erlang:registered/0,\n erlang:round/1,\n erlang:setelement/3,\n erlang:self/0,\n erlang:size/1,\n erlang:spawn/1,\n erlang:spawn/2,\n erlang:spawn/3,\n erlang:spawn/4,\n erlang:spawn_link/1,\n erlang:spawn_link/2,\n erlang:spawn_link/3,\n erlang:spawn_link/4,\n erlang:spawn_monitor/1,\n erlang:spawn_monitor/3,\n erlang:spawn_opt/2,\n erlang:spawn_opt/3,\n erlang:spawn_opt/4,\n erlang:spawn_opt/5,\n erlang:split_binary/2,\n erlang:statistics/1,\n erlang:term_to_binary/1,\n erlang:term_to_binary/2,\n erlang:throw/1,\n erlang:time/0,\n erlang:tl/1,\n erlang:trunc/1,\n erlang:tuple_size/1,\n erlang:tuple_to_list/1,\n erlang:unlink/1,\n erlang:unregister/1,\n erlang:whereis/1\n };\n\n if let Some(compile) = self.compile.as_ref() {\n if compile.no_auto_import {\n return;\n }\n\n for fun in autos.iter() {\n if !compile.no_auto_imports.contains(fun) {\n self.imports.insert(fun.to_local(), fun.clone());\n }\n }\n } else {\n for fun in autos.iter() {\n self.imports.insert(fun.to_local(), fun.clone());\n }\n }\n }\n\n // Every module in Erlang has some functions implicitly defined for internal use:\n //\n // * `module_info/0` (exported)\n // * `module_info/1` (exported)\n // * `record_info/2`\n // * `behaviour_info/1` (optional)\n fn define_pseudolocals(&mut self, nid: &mut NodeIdGenerator) {\n let mod_info_0 = fun!(nid, module_info () ->\n apply!(nid, remote!(nid, erlang, get_module_info), Expr::Literal(Literal::Atom(nid.next(), self.name.clone())))\n );\n let mod_info_1 = fun!(nid, module_info (Key) ->\n apply!(nid, remote!(nid, erlang, get_module_info), Expr::Literal(Literal::Atom(nid.next(), self.name.clone())), var!(nid, Key))\n );\n\n self.define_function(mod_info_0);\n self.define_function(mod_info_1);\n\n if self.callbacks.len() > 0 {\n let callbacks = self.callbacks.iter().fold(nil!(nid), |acc, (cbname, cb)| {\n if cb.optional {\n acc\n } else {\n cons!(\n nid,\n tuple!(\n nid,\n atom_from_sym!(nid, cbname.function.name.clone()),\n int!(nid, (cbname.arity as i64).into())\n ),\n acc\n )\n }\n });\n let opt_callbacks = self.callbacks.iter().fold(nil!(nid), |acc, (cbname, cb)| {\n if cb.optional {\n cons!(\n nid,\n tuple!(\n nid,\n atom_from_sym!(nid, cbname.function.name.clone()),\n int!(nid, (cbname.arity as i64).into())\n ),\n acc\n )\n } else {\n acc\n }\n });\n\n let behaviour_info_1 = fun!(nid, behaviour_info\n (atom!(nid, callbacks)) -> callbacks;\n (atom!(nid, optional_callbacks)) -> opt_callbacks);\n\n self.define_function(behaviour_info_1);\n }\n }\n\n fn define_function(&mut self, f: NamedFunction) {\n let name = ResolvedFunctionName {\n span: f.span.clone(),\n id: f.id,\n module: self.name.clone(),\n function: f.name.atom(),\n arity: f.arity,\n };\n self.functions.insert(name.to_local(), f);\n }\n}\nimpl PartialEq for Module {\n fn eq(&self, other: &Module) -> bool {\n if self.name != other.name {\n return false;\n }\n if self.vsn != other.vsn {\n return false;\n }\n if self.on_load != other.on_load {\n return false;\n }\n if self.imports != other.imports {\n return false;\n }\n if self.exports != other.exports {\n return false;\n }\n if self.types != other.types {\n return false;\n }\n if self.exported_types != other.exported_types {\n return false;\n }\n if self.behaviours != other.behaviours {\n return false;\n }\n if self.callbacks != other.callbacks {\n return false;\n }\n if self.records != other.records {\n return false;\n }\n if self.attributes != other.attributes {\n return false;\n }\n if self.functions != other.functions {\n return false;\n }\n true\n }\n}\n\n/// This structure holds all module-specific compiler options\n/// and configuration; it is passed through all phases of\n/// compilation and is a superset of options in CompilerSettings\n/// where applicable\n#[derive(Debug, Clone)]\npub struct CompileOptions {\n // Same as erlc, prints informational warnings about\n // binary matching optimizations\n pub compile_info: HashMap,\n // Used to override the filename used in errors/warnings\n pub file: Option,\n pub verbose: bool,\n pub report_errors: bool,\n pub report_warnings: bool,\n // Treats all warnings as errors\n pub warnings_as_errors: bool,\n // Disables warnings\n pub no_warn: bool,\n // Exports all functions\n pub export_all: bool,\n // Prevents auto importing any functions\n pub no_auto_import: bool,\n // Prevents auto importing the specified functions\n pub no_auto_imports: HashSet,\n // Warns if export_all is used\n pub warn_export_all: bool,\n // Warns when exported variables are used\n pub warn_export_vars: bool,\n // Warns when variables are shadowed\n pub warn_shadow_vars: bool,\n // Warns when a function is unused\n pub warn_unused_function: bool,\n // Disables the unused function warning for the specified functions\n pub no_warn_unused_functions: HashSet,\n // Warns about unused imports\n pub warn_unused_import: bool,\n // Warns about unused variables\n pub warn_unused_var: bool,\n // Warns about unused records\n pub warn_unused_record: bool,\n pub warn_untyped_record: bool,\n pub warn_unused_type: bool,\n pub warn_removed: bool,\n pub warn_nif_inline: bool,\n pub warn_bif_clash: bool,\n // Warns about missing type specs\n pub warn_missing_spec: bool,\n pub warn_missing_spec_all: bool,\n pub warn_deprecated_function: bool,\n pub warn_deprecated_type: bool,\n pub warn_obsolete_guard: bool,\n pub inline: bool,\n // Inlines the given functions\n pub inline_functions: HashSet,\n}\nimpl Default for CompileOptions {\n fn default() -> Self {\n CompileOptions {\n compile_info: HashMap::new(),\n file: None,\n verbose: true,\n report_errors: true,\n report_warnings: true,\n warnings_as_errors: false,\n no_warn: false,\n export_all: false,\n no_auto_import: false,\n no_auto_imports: HashSet::new(),\n inline: false,\n inline_functions: HashSet::new(),\n\n // Warning toggles\n warn_export_all: true,\n warn_export_vars: true,\n warn_shadow_vars: true,\n warn_unused_function: true,\n no_warn_unused_functions: HashSet::new(),\n warn_unused_import: true,\n warn_unused_var: true,\n warn_unused_record: true,\n warn_untyped_record: false,\n warn_unused_type: true,\n warn_removed: true,\n warn_nif_inline: true,\n warn_bif_clash: true,\n warn_missing_spec: false,\n warn_missing_spec_all: false,\n warn_deprecated_function: true,\n warn_deprecated_type: true,\n warn_obsolete_guard: true,\n }\n }\n}\nimpl CompileOptions {\n pub fn from_expr(module: &Ident, expr: &Expr) -> (Self, Vec) {\n let mut opts = CompileOptions::default();\n match opts.merge_from_expr(module, expr) {\n Ok(_) => (opts, Vec::new()),\n Err(errs) => (opts, errs),\n }\n }\n\n pub fn merge_from_expr(&mut self, module: &Ident, expr: &Expr) -> Result<(), Vec> {\n self.set_option(module, expr)\n }\n\n fn set_option(&mut self, module: &Ident, expr: &Expr) -> Result<(), Vec> {\n let mut diagnostics = Vec::new();\n match expr {\n // e.g. -compile(export_all).\n &Expr::Literal(Literal::Atom(id, ref option_name)) => {\n match option_name.as_str().get() {\n \"no_native\" => (), // Disables hipe compilation, not relevant for us\n \"inline\" => self.inline = true,\n\n \"export_all\" => self.export_all = true,\n\n \"no_auto_import\" => self.no_auto_import = true,\n\n \"report_errors\" => self.report_errors = true,\n \"report_warnings\" => self.report_errors = true,\n \"verbose\" => self.verbose = true,\n\n \"inline_list_funcs\" => {\n let funs = [\n (\"lists\", \"all\", 2),\n (\"lists\", \"any\", 2),\n (\"lists\", \"foreach\", 2),\n (\"lists\", \"map\", 2),\n (\"lists\", \"flatmap\", 2),\n (\"lists\", \"filter\", 2),\n (\"lists\", \"foldl\", 3),\n (\"lists\", \"foldr\", 3),\n (\"lists\", \"mapfoldl\", 3),\n (\"lists\", \"mapfoldr\", 3),\n ];\n for (m, f, a) in funs.iter() {\n self.inline_functions.insert(ResolvedFunctionName {\n span: option_name.span,\n id: id,\n module: Ident::from_str(m),\n function: Ident::from_str(f),\n arity: *a,\n });\n }\n }\n\n // Warning toggles\n \"warn_export_all\" => self.warn_export_all = true,\n \"nowarn_export_all\" => self.warn_export_all = false,\n\n \"warn_shadow_vars\" => self.warn_shadow_vars = true,\n \"nowarn_shadow_vars\" => self.warn_shadow_vars = false,\n\n \"warn_unused_function\" => self.warn_unused_function = true,\n \"nowarn_unused_function\" => self.warn_unused_function = false,\n\n \"warn_unused_import\" => self.warn_unused_import = true,\n \"nowarn_unused_import\" => self.warn_unused_import = false,\n\n \"warn_unused_type\" => self.warn_unused_type = true,\n \"nowarn_unused_type\" => self.warn_unused_type = false,\n\n \"warn_export_vars\" => self.warn_export_vars = true,\n \"nowarn_export_vars\" => self.warn_export_vars = false,\n\n \"warn_unused_vars\" => self.warn_unused_var = true,\n \"nowarn_unused_vars\" => self.warn_unused_var = false,\n\n \"warn_bif_clash\" => self.warn_bif_clash = true,\n \"nowarn_bif_clash\" => self.warn_bif_clash = false,\n\n \"warn_unused_record\" => self.warn_unused_record = true,\n \"nowarn_unused_record\" => self.warn_unused_record = false,\n\n \"warn_deprecated_function\" => self.warn_deprecated_function = true,\n \"nowarn_deprecated_function\" => self.warn_deprecated_function = false,\n\n \"warn_deprecated_type\" => self.warn_deprecated_type = true,\n \"nowarn_deprecated_type\" => self.warn_deprecated_type = false,\n\n \"warn_obsolete_guard\" => self.warn_obsolete_guard = true,\n \"nowarn_obsolete_guard\" => self.warn_obsolete_guard = false,\n\n \"warn_untyped_record\" => self.warn_untyped_record = true,\n \"nowarn_untyped_record\" => self.warn_untyped_record = false,\n\n \"warn_missing_spec\" => self.warn_missing_spec = true,\n \"nowarn_missing_spec\" => self.warn_missing_spec = false,\n\n \"warn_missing_spec_all\" => self.warn_missing_spec_all = true,\n \"nowarn_missing_spec_all\" => self.warn_missing_spec_all = false,\n\n \"warn_removed\" => self.warn_removed = true,\n \"nowarn_removed\" => self.warn_removed = false,\n\n \"warn_nif_inline\" => self.warn_nif_inline = true,\n \"nowarn_nif_inline\" => self.warn_nif_inline = false,\n\n _name => {\n diagnostics.push(\n Diagnostic::warning()\n .with_message(\"invalid compile option\")\n .with_labels(vec![Label::primary(\n option_name.span.source_id(),\n option_name.span,\n )\n .with_message(\n \"this option is either unsupported or unrecognized\",\n )]),\n );\n }\n }\n }\n // e.g. -compile([export_all, nowarn_unused_function]).\n &Expr::Cons(Cons {\n ref head, ref tail, ..\n }) => self.compiler_opts_from_list(&mut diagnostics, module, to_list(head, tail)),\n // e.g. -compile({nowarn_unused_function, [some_fun/0]}).\n &Expr::Tuple(Tuple { ref elements, .. }) if elements.len() == 2 => {\n //if let Some((head, tail)) = elements.split_first() {\n if let &Expr::Literal(Literal::Atom(_id, ref option_name)) = &elements[0] {\n let list = to_list_simple(&elements[1]);\n match option_name.as_str().get() {\n \"no_auto_import\" => {\n self.no_auto_imports(&mut diagnostics, module, &list);\n }\n \"nowarn_unused_function\" => {\n self.no_warn_unused_functions(&mut diagnostics, module, &list);\n }\n \"inline\" => {\n self.inline_functions(&mut diagnostics, module, &list);\n }\n \"hipe\" => {\n // Should we warn about this? I'm inclined to think\n // not, since we want to ignore warning spam.\n }\n _name => {\n diagnostics.push(\n Diagnostic::warning()\n .with_message(\"invalid compile option\")\n .with_labels(vec![Label::primary(\n option_name.span.source_id(),\n option_name.span,\n )\n .with_message(\n \"this option is either unsupported or unrecognized\",\n )]),\n );\n }\n }\n }\n //}\n }\n term => {\n let term_span = term.span();\n diagnostics.push(\n Diagnostic::warning()\n .with_message(\"invalid compile option\")\n .with_labels(vec![Label::primary(term_span.source_id(), term_span)\n .with_message(\n \"unexpected expression: expected atom, list, or tuple\",\n )]),\n );\n }\n }\n\n if diagnostics.len() > 0 {\n return Err(diagnostics);\n }\n\n Ok(())\n }\n\n fn compiler_opts_from_list(\n &mut self,\n diagnostics: &mut Vec,\n module: &Ident,\n options: Vec,\n ) {\n for option in options {\n match self.set_option(module, &option) {\n Ok(_) => continue,\n Err(mut diags) => diagnostics.append(&mut diags),\n }\n }\n }\n\n fn no_auto_imports(\n &mut self,\n diagnostics: &mut Vec,\n module: &Ident,\n imports: &[Expr],\n ) {\n for import in imports {\n match import {\n Expr::FunctionName(FunctionName::PartiallyResolved(name)) => {\n self.no_auto_imports.insert(name.resolve(module.clone()));\n }\n Expr::Tuple(tup) if tup.elements.len() == 2 => {\n match (&tup.elements[0], &tup.elements[1]) {\n (\n Expr::Literal(Literal::Atom(_, name)),\n Expr::Literal(Literal::Integer(_, _, arity)),\n ) => {\n let local = PartiallyResolvedFunctionName {\n span: tup.span,\n id: tup.id,\n function: *name,\n arity: (*arity).to_usize().unwrap(),\n };\n self.no_auto_imports.insert(local.resolve(*module));\n continue;\n }\n _ => (),\n }\n }\n other => {\n let other_span = other.span();\n diagnostics.push(\n Diagnostic::warning()\n .with_message(\"invalid compile option\")\n .with_labels(vec![Label::primary(other_span.source_id(), other_span)\n .with_message(\n \"expected function name/arity term for no_auto_imports\",\n )]),\n );\n }\n }\n }\n }\n\n fn no_warn_unused_functions(\n &mut self,\n diagnostics: &mut Vec,\n _module: &Ident,\n funs: &[Expr],\n ) {\n for fun in funs {\n match fun {\n Expr::FunctionName(FunctionName::PartiallyResolved(name)) => {\n self.no_warn_unused_functions.insert(name.to_local());\n }\n other => {\n let other_span = other.span();\n diagnostics.push(\n Diagnostic::warning()\n .with_message(\"invalid compile option\")\n .with_labels(vec![Label::primary(other_span.source_id(), other_span)\n .with_message(\n \"expected function name/arity term for no_warn_unused_functions\",\n )]),\n );\n }\n }\n }\n }\n\n fn inline_functions(\n &mut self,\n diagnostics: &mut Vec,\n module: &Ident,\n funs: &[Expr],\n ) {\n for fun in funs {\n match fun {\n Expr::FunctionName(FunctionName::PartiallyResolved(name)) => {\n self.inline_functions.insert(name.resolve(*module));\n continue;\n }\n Expr::Tuple(tup) if tup.elements.len() == 2 => {\n match (&tup.elements[0], &tup.elements[1]) {\n (\n Expr::Literal(Literal::Atom(_, name)),\n Expr::Literal(Literal::Integer(_, _, arity)),\n ) => {\n let local = PartiallyResolvedFunctionName {\n span: tup.span,\n id: tup.id,\n function: *name,\n arity: (*arity).to_usize().unwrap(),\n };\n self.inline_functions.insert(local.resolve(*module));\n continue;\n }\n _ => (),\n }\n }\n _ => (),\n }\n\n let fun_span = fun.span();\n diagnostics.push(\n Diagnostic::warning()\n .with_message(\"invalid compile option\")\n .with_labels(vec![Label::primary(fun_span.source_id(), fun_span)\n .with_message(\"expected function name/arity term for inline\")]),\n );\n }\n }\n}\n\nfn to_list_simple(mut expr: &Expr) -> Vec {\n let mut list = Vec::new();\n loop {\n match expr {\n Expr::Cons(cons) => {\n list.push((*cons.head).clone());\n expr = &cons.tail;\n }\n Expr::Nil(_) => {\n return list;\n }\n _ => {\n list.push(expr.clone());\n return list;\n }\n }\n }\n}\n\nfn to_list(head: &Expr, tail: &Expr) -> Vec {\n let mut list = Vec::new();\n match head {\n &Expr::Cons(Cons {\n head: ref head2,\n tail: ref tail2,\n ..\n }) => {\n let mut h = to_list(head2, tail2);\n list.append(&mut h);\n }\n expr => list.push(expr.clone()),\n }\n match tail {\n &Expr::Cons(Cons {\n head: ref head2,\n tail: ref tail2,\n ..\n }) => {\n let mut t = to_list(head2, tail2);\n list.append(&mut t);\n }\n &Expr::Nil(_) => (),\n expr => list.push(expr.clone()),\n }\n\n list\n}\n" }, { "path": "libeir_syntax_erl/src/parser/ast/types.rs", "content": "use std::collections::HashSet;\n\nuse lazy_static::lazy_static;\n\nuse libeir_diagnostics::SourceSpan;\nuse libeir_util_number::Integer;\n\nuse super::{BinaryOp, UnaryOp};\nuse super::{Ident, Name, Symbol};\n\nlazy_static! {\n pub static ref BUILTIN_TYPES: HashSet<(Symbol, usize)> = {\n let mut bts = HashSet::new();\n bts.insert((Symbol::intern(\"any\"), 0));\n bts.insert((Symbol::intern(\"arity\"), 0));\n bts.insert((Symbol::intern(\"atom\"), 0));\n bts.insert((Symbol::intern(\"binary\"), 0));\n bts.insert((Symbol::intern(\"bitstring\"), 0));\n bts.insert((Symbol::intern(\"bool\"), 0));\n bts.insert((Symbol::intern(\"boolean\"), 0));\n bts.insert((Symbol::intern(\"byte\"), 0));\n bts.insert((Symbol::intern(\"char\"), 0));\n bts.insert((Symbol::intern(\"float\"), 0));\n bts.insert((Symbol::intern(\"function\"), 0));\n bts.insert((Symbol::intern(\"identifier\"), 0));\n bts.insert((Symbol::intern(\"integer\"), 0));\n bts.insert((Symbol::intern(\"iodata\"), 0));\n bts.insert((Symbol::intern(\"iolist\"), 0));\n bts.insert((Symbol::intern(\"list\"), 0));\n bts.insert((Symbol::intern(\"list\"), 1));\n bts.insert((Symbol::intern(\"map\"), 0));\n bts.insert((Symbol::intern(\"maybe_improper_list\"), 0));\n bts.insert((Symbol::intern(\"maybe_improper_list\"), 2));\n bts.insert((Symbol::intern(\"mfa\"), 0));\n bts.insert((Symbol::intern(\"module\"), 0));\n bts.insert((Symbol::intern(\"neg_integer\"), 0));\n bts.insert((Symbol::intern(\"nil\"), 0));\n bts.insert((Symbol::intern(\"no_return\"), 0));\n bts.insert((Symbol::intern(\"node\"), 0));\n bts.insert((Symbol::intern(\"non_neg_integer\"), 0));\n bts.insert((Symbol::intern(\"none\"), 0));\n bts.insert((Symbol::intern(\"nonempty_improper_list\"), 2));\n bts.insert((Symbol::intern(\"nonempty_list\"), 0));\n bts.insert((Symbol::intern(\"nonempty_list\"), 1));\n bts.insert((Symbol::intern(\"nonempty_maybe_improper_list\"), 0));\n bts.insert((Symbol::intern(\"nonempty_maybe_improper_list\"), 2));\n bts.insert((Symbol::intern(\"nonempty_string\"), 0));\n bts.insert((Symbol::intern(\"number\"), 0));\n bts.insert((Symbol::intern(\"pid\"), 0));\n bts.insert((Symbol::intern(\"port\"), 0));\n bts.insert((Symbol::intern(\"pos_integer\"), 0));\n bts.insert((Symbol::intern(\"reference\"), 0));\n bts.insert((Symbol::intern(\"string\"), 0));\n bts.insert((Symbol::intern(\"term\"), 0));\n bts.insert((Symbol::intern(\"timeout\"), 0));\n bts.insert((Symbol::intern(\"tuple\"), 0));\n bts\n };\n}\n\n#[derive(Debug, Clone)]\npub enum Type {\n Name(Name),\n Annotated {\n span: SourceSpan,\n name: Name,\n ty: Box,\n },\n Union {\n span: SourceSpan,\n types: Vec,\n },\n Range {\n span: SourceSpan,\n start: Box,\n end: Box,\n },\n BinaryOp {\n span: SourceSpan,\n lhs: Box,\n op: BinaryOp,\n rhs: Box,\n },\n UnaryOp {\n span: SourceSpan,\n op: UnaryOp,\n rhs: Box,\n },\n Generic {\n span: SourceSpan,\n fun: Ident,\n params: Vec,\n },\n Remote {\n span: SourceSpan,\n module: Ident,\n fun: Ident,\n args: Vec,\n },\n Nil(SourceSpan),\n List(SourceSpan, Box),\n NonEmptyList(SourceSpan, Box),\n Map(SourceSpan, Vec),\n Tuple(SourceSpan, Vec),\n Record(SourceSpan, Ident, Vec),\n Binary(SourceSpan, Box, Box),\n Integer(SourceSpan, Integer),\n Char(SourceSpan, char),\n AnyFun {\n span: SourceSpan,\n ret: Option>,\n },\n Fun {\n span: SourceSpan,\n params: Vec,\n ret: Box,\n },\n KeyValuePair(SourceSpan, Box, Box),\n Field(SourceSpan, Ident, Box),\n}\nimpl Type {\n pub fn union(span: SourceSpan, lhs: Type, rhs: Type) -> Self {\n let mut types = match lhs {\n Type::Union { types, .. } => types,\n ty => vec![ty],\n };\n let mut rest = match rhs {\n Type::Union { types, .. } => types,\n ty => vec![ty],\n };\n types.append(&mut rest);\n Type::Union { span, types }\n }\n\n pub fn is_builtin_type(&self) -> bool {\n match self {\n &Type::Name(Name::Atom(Ident { ref name, .. })) => BUILTIN_TYPES.contains(&(*name, 0)),\n &Type::Annotated { ref name, .. } => match name {\n Name::Atom(v) => BUILTIN_TYPES.contains(&(v.name, 0)),\n Name::Var(v) => BUILTIN_TYPES.contains(&(v.name, 0)),\n },\n &Type::Generic {\n ref fun,\n ref params,\n ..\n } => BUILTIN_TYPES.contains(&(fun.name, params.len())),\n &Type::Nil(_) => true,\n &Type::List(_, _) => true,\n &Type::NonEmptyList(_, _) => true,\n &Type::Map(_, _) => true,\n &Type::Tuple(_, _) => true,\n &Type::Record(_, _, _) => true,\n &Type::Binary(_, _, _) => true,\n &Type::Integer(_, _) => true,\n &Type::Char(_, _) => true,\n &Type::AnyFun { .. } => true,\n &Type::Fun { .. } => true,\n &Type::KeyValuePair(_, _, _) => true,\n &Type::Field(_, _, _) => true,\n _ => false,\n }\n }\n}\nimpl PartialEq for Type {\n fn eq(&self, other: &Type) -> bool {\n let left = std::mem::discriminant(self);\n let right = std::mem::discriminant(other);\n if left != right {\n return false;\n }\n\n match (self, other) {\n (\n Type::Annotated {\n name: ref x1,\n ty: ref x2,\n ..\n },\n Type::Annotated {\n name: ref y1,\n ty: ref y2,\n ..\n },\n ) => (x1 == y1) && (x2 == y2),\n (\n Type::Union {\n types: ref types1, ..\n },\n Type::Union {\n types: ref types2, ..\n },\n ) => types1 == types2,\n (\n Type::Range {\n start: ref x1,\n end: ref x2,\n ..\n },\n Type::Range {\n start: ref y1,\n end: ref y2,\n ..\n },\n ) => (x1 == y1) && (x2 == y2),\n (\n Type::BinaryOp {\n lhs: ref x1,\n op: ref x2,\n rhs: ref x3,\n ..\n },\n Type::BinaryOp {\n lhs: ref y1,\n op: ref y2,\n rhs: ref y3,\n ..\n },\n ) => (x1 == y1) && (x2 == y2) && (x3 == y3),\n (\n Type::UnaryOp {\n op: ref x1,\n rhs: ref x2,\n ..\n },\n Type::UnaryOp {\n op: ref y1,\n rhs: ref y2,\n ..\n },\n ) => (x1 == y1) && (x2 == y2),\n (\n Type::Generic {\n fun: ref x1,\n params: ref x2,\n ..\n },\n Type::Generic {\n fun: ref y1,\n params: ref y2,\n ..\n },\n ) => (x1 == y1) && (x2 == y2),\n (\n Type::Remote {\n module: ref x1,\n fun: ref x2,\n args: ref x3,\n ..\n },\n Type::Remote {\n module: ref y1,\n fun: ref y2,\n args: ref y3,\n ..\n },\n ) => (x1 == y1) && (x2 == y2) && (x3 == y3),\n (Type::Nil(_), Type::Nil(_)) => true,\n (Type::List(_, ref x), Type::List(_, ref y)) => x == y,\n (Type::NonEmptyList(_, ref x), Type::List(_, ref y)) => x == y,\n (Type::Map(_, ref x), Type::Map(_, ref y)) => x == y,\n (Type::Tuple(_, ref x), Type::Tuple(_, ref y)) => x == y,\n (Type::Record(_, ref x1, ref x2), Type::Record(_, ref y1, ref y2)) => {\n (x1 == y1) && (x2 == y2)\n }\n (Type::Binary(_, ref m1, ref n1), Type::Binary(_, ref m2, ref n2)) => {\n (m1 == m2) && (n1 == n2)\n }\n (Type::Integer(_, x), Type::Integer(_, y)) => x == y,\n (Type::Char(_, x), Type::Char(_, y)) => x == y,\n (Type::AnyFun { ret: x, .. }, Type::AnyFun { ret: y, .. }) => x == y,\n (\n Type::Fun {\n params: ref x1,\n ret: ref x2,\n ..\n },\n Type::Fun {\n params: ref y1,\n ret: ref y2,\n ..\n },\n ) => (x1 == y1) && (x2 == y2),\n (Type::KeyValuePair(_, ref x1, ref x2), Type::KeyValuePair(_, ref y1, ref y2)) => {\n (x1 == y1) && (x2 == y2)\n }\n (Type::Field(_, ref x1, ref x2), Type::Field(_, ref y1, ref y2)) => {\n (x1 == y1) && (x2 == y2)\n }\n _ => false,\n }\n }\n}\n" }, { "path": "libeir_syntax_erl/src/parser/binary.rs", "content": "use snafu::Snafu;\npub use libeir_ir::binary::{BinaryEntrySpecifier, Endianness};\nuse libeir_diagnostics::{SourceSpan, ToDiagnostic, Diagnostic, Label};\nuse super::ast::{BitType, BinaryElement, Expr, Literal};\nuse crate::lower::LowerError;\n\n#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]\npub enum TypeName {\n Integer,\n Float,\n Bytes,\n Bits,\n Utf8,\n Utf16,\n Utf32,\n}\nimpl std::fmt::Display for TypeName {\n fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {\n match self {\n TypeName::Integer => write!(f, \"integer\"),\n TypeName::Float => write!(f, \"float\"),\n TypeName::Bytes => write!(f, \"binary\"),\n TypeName::Bits => write!(f, \"bitstring\"),\n TypeName::Utf8 => write!(f, \"utf8\"),\n TypeName::Utf16 => write!(f, \"utf16\"),\n TypeName::Utf32 => write!(f, \"utf32\"),\n }\n }\n}\n\npub fn default_specifier() -> BinaryEntrySpecifier {\n BinaryEntrySpecifier::Integer {\n signed: false,\n endianness: Endianness::Big,\n unit: 1,\n }\n}\n\n#[derive(Debug, Snafu)]\npub enum SpecifierError {\n #[snafu(display(\"unknown specifier in binary entry\"))]\n BinaryUnknownSpecifier {\n span: SourceSpan,\n },\n #[snafu(display(\"conflicting specifiers in binary entry\"))]\n BinaryConflictingSpecifier {\n new: SourceSpan,\n old: SourceSpan,\n },\n #[snafu(display(\"invalid specifier for {} in binary entry\", typ))]\n BinaryInvalidSpecifier {\n span: SourceSpan,\n typ: TypeName,\n },\n #[snafu(display(\"size is not allowed for {}\", typ))]\n BinarySizeNotAllowed {\n span: SourceSpan,\n typ: TypeName,\n },\n}\n\nimpl ToDiagnostic for SpecifierError {\n fn to_diagnostic(&self) -> Diagnostic {\n let msg = self.to_string();\n match self {\n SpecifierError::BinaryUnknownSpecifier { span } => Diagnostic::error()\n .with_message(msg)\n .with_labels(vec![\n Label::primary(span.source_id(), *span).with_message(\"specifier is not known\")\n ]),\n SpecifierError::BinaryConflictingSpecifier { new, old } => {\n Diagnostic::error().with_message(msg).with_labels(vec![\n Label::primary(new.source_id(), *new).with_message(\"specifier 1\"),\n Label::primary(old.source_id(), *old).with_message(\"specifier 2\"),\n ])\n }\n SpecifierError::BinaryInvalidSpecifier { span, typ } => Diagnostic::error()\n .with_message(msg)\n .with_labels(vec![Label::primary(span.source_id(), *span)\n .with_message(format!(\"specifier is not valid for {} entries\", typ))]),\n SpecifierError::BinarySizeNotAllowed { span, typ } => Diagnostic::error()\n .with_message(msg)\n .with_labels(vec![Label::primary(span.source_id(), *span)\n .with_message(format!(\"size is not allowed for {} entries\", typ))]),\n }\n }\n}\n\nmacro_rules! try_specifier {\n ($field:expr, $entry:expr, $spec:expr) => {{\n let spec = $spec;\n match $field {\n Some((f, _)) if f == spec => (),\n Some((_, old)) => {\n return Err(SpecifierError::BinaryConflictingSpecifier {\n old,\n new: $entry.span(),\n });\n }\n None => $field = Some((spec, $entry.span())),\n }\n }};\n}\n\nmacro_rules! test_none {\n ($field:expr, $typ:expr) => {{\n if let Some((_, span)) = $field {\n return Err(SpecifierError::BinaryInvalidSpecifier {\n span: span,\n typ: $typ,\n });\n }\n }};\n}\n\npub fn specifier_from_parsed(parsed: &[BitType], has_size: bool) -> Result {\n let mut raw_typ = None;\n let mut signed = None;\n let mut endianness = None;\n let mut unit = None;\n\n for entry in parsed {\n match entry {\n // Types\n BitType::Name(_id, _span, ident) if ident.as_str() == \"integer\" => {\n try_specifier!(raw_typ, entry, TypeName::Integer)\n }\n BitType::Name(_id, _span, ident) if ident.as_str() == \"float\" => {\n try_specifier!(raw_typ, entry, TypeName::Float)\n }\n BitType::Name(_id, _span, ident) if ident.as_str() == \"binary\" => {\n try_specifier!(raw_typ, entry, TypeName::Bytes)\n }\n BitType::Name(_id, _span, ident) if ident.as_str() == \"bytes\" => {\n try_specifier!(raw_typ, entry, TypeName::Bytes)\n }\n BitType::Name(_id, _span, ident) if ident.as_str() == \"bitstring\" => {\n try_specifier!(raw_typ, entry, TypeName::Bits)\n }\n BitType::Name(_id, _span, ident) if ident.as_str() == \"bits\" => {\n try_specifier!(raw_typ, entry, TypeName::Bits)\n }\n BitType::Name(_id, _span, ident) if ident.as_str() == \"utf8\" => {\n try_specifier!(raw_typ, entry, TypeName::Utf8)\n }\n BitType::Name(_id, _span, ident) if ident.as_str() == \"utf16\" => {\n try_specifier!(raw_typ, entry, TypeName::Utf16)\n }\n BitType::Name(_id, _span, ident) if ident.as_str() == \"utf32\" => {\n try_specifier!(raw_typ, entry, TypeName::Utf32)\n }\n\n // Signed\n BitType::Name(_id, _span, ident) if ident.as_str() == \"signed\" => {\n try_specifier!(signed, entry, true)\n }\n BitType::Name(_id, _span, ident) if ident.as_str() == \"unsigned\" => {\n try_specifier!(signed, entry, false)\n }\n\n // Endianness\n BitType::Name(_id, _span, ident) if ident.as_str() == \"big\" => {\n try_specifier!(endianness, entry, Endianness::Big)\n }\n BitType::Name(_id, _span, ident) if ident.as_str() == \"little\" => {\n try_specifier!(endianness, entry, Endianness::Little)\n }\n BitType::Name(_id, _span, ident) if ident.as_str() == \"native\" => {\n try_specifier!(endianness, entry, Endianness::Native)\n }\n\n // Unit\n BitType::Sized(_id, _span, ident, num) if ident.as_str() == \"unit\" => {\n try_specifier!(unit, entry, *num)\n }\n\n entry => {\n return Err(SpecifierError::BinaryUnknownSpecifier { span: entry.span() });\n }\n }\n }\n\n let typ = raw_typ.map(|(t, _)| t).unwrap_or(TypeName::Integer);\n\n let size_not_allowed_err = || Err(SpecifierError::BinarySizeNotAllowed {\n typ,\n span: raw_typ.unwrap().1,\n });\n\n let spec = match typ {\n TypeName::Integer => {\n // Default is signed-big-unit:1\n let signed = signed.map(|(t, _)| t).unwrap_or(false);\n let endianness = endianness.map(|(t, _)| t).unwrap_or(Endianness::Big);\n let unit = unit.map(|(t, _)| t).unwrap_or(1);\n\n BinaryEntrySpecifier::Integer {\n signed,\n endianness,\n unit,\n }\n }\n TypeName::Float => {\n // Default is big-unit:1\n test_none!(signed, typ);\n let endianness = endianness.map(|(t, _)| t).unwrap_or(Endianness::Big);\n let unit = unit.map(|(t, _)| t).unwrap_or(1);\n\n BinaryEntrySpecifier::Float { endianness, unit }\n }\n TypeName::Bytes => {\n // Default is unit:8\n test_none!(signed, typ);\n test_none!(endianness, typ);\n let unit = unit.map(|(t, _)| t).unwrap_or(8);\n\n BinaryEntrySpecifier::Bytes { unit }\n }\n TypeName::Bits => {\n // Default is unit:1\n test_none!(signed, typ);\n test_none!(endianness, typ);\n let unit = unit.map(|(t, _)| t).unwrap_or(1);\n\n BinaryEntrySpecifier::Bits { unit }\n }\n TypeName::Utf8 => {\n test_none!(signed, typ);\n test_none!(endianness, typ);\n test_none!(unit, typ);\n\n if has_size {\n return size_not_allowed_err();\n }\n\n BinaryEntrySpecifier::Utf8\n }\n TypeName::Utf16 => {\n test_none!(signed, typ);\n let endianness = endianness.map(|(t, _)| t).unwrap_or(Endianness::Big);\n test_none!(unit, typ);\n\n if has_size {\n return size_not_allowed_err();\n }\n\n BinaryEntrySpecifier::Utf16 { endianness }\n }\n TypeName::Utf32 => {\n test_none!(signed, typ);\n let endianness = endianness.map(|(t, _)| t).unwrap_or(Endianness::Big);\n test_none!(unit, typ);\n\n if has_size {\n return size_not_allowed_err();\n }\n\n BinaryEntrySpecifier::Utf32 { endianness }\n }\n };\n\n Ok(spec)\n}\n\npub fn specifier_to_typename(specifier: &BinaryEntrySpecifier) -> TypeName {\n match specifier {\n BinaryEntrySpecifier::Integer { .. } => TypeName::Integer,\n BinaryEntrySpecifier::Float { .. } => TypeName::Float,\n BinaryEntrySpecifier::Bytes { .. } => TypeName::Bytes,\n BinaryEntrySpecifier::Bits { .. } => TypeName::Bits,\n BinaryEntrySpecifier::Utf8 => TypeName::Utf8,\n BinaryEntrySpecifier::Utf16 { .. } => TypeName::Utf16,\n BinaryEntrySpecifier::Utf32 { .. } => TypeName::Utf32,\n }\n}\n\npub fn specifier_can_have_size(specifier: &BinaryEntrySpecifier) -> bool {\n match specifier {\n BinaryEntrySpecifier::Utf8 => false,\n BinaryEntrySpecifier::Utf16 { .. } => false,\n BinaryEntrySpecifier::Utf32 { .. } => false,\n _ => true,\n }\n}\n" }, { "path": "libeir_syntax_erl/src/parser/errors.rs", "content": "use std::convert::From;\n\nuse libeir_diagnostics::*;\nuse libeir_util_parse::SourceError;\nuse snafu::Snafu;\n\nuse crate::lexer::Token;\nuse crate::preprocessor::PreprocessorError;\n\npub type ParseError = lalrpop_util::ParseError;\n\n#[derive(Debug, Snafu)]\npub enum ParserError {\n #[snafu(display(\"{} occurred while reading {:?}\", source, path))]\n RootFile {\n source: std::io::Error,\n path: std::path::PathBuf,\n },\n\n #[snafu(visibility(pub), display(\"{}\", source))]\n Preprocessor { source: PreprocessorError },\n\n #[snafu(display(\"{}\", source))]\n Source { source: SourceError },\n\n #[snafu(display(\"{}\", diagnostic.message))]\n ShowDiagnostic { diagnostic: Diagnostic },\n\n #[snafu(display(\"invalid token\"))]\n InvalidToken { location: SourceIndex },\n\n #[snafu(display(\"unrecognized token\"))]\n UnrecognizedToken {\n span: SourceSpan,\n expected: Vec,\n },\n\n #[snafu(display(\"extra token\"))]\n ExtraToken { span: SourceSpan },\n\n #[snafu(display(\"unexpected eof\"))]\n UnexpectedEOF {\n location: SourceIndex,\n expected: Vec,\n },\n}\n\nimpl From for ParserError {\n fn from(err: Diagnostic) -> Self {\n ParserError::ShowDiagnostic {\n diagnostic: err,\n }\n }\n}\n\nimpl From for ParserError {\n fn from(err: ParseError) -> Self {\n use lalrpop_util::ParseError::*;\n match err {\n InvalidToken { location } => Self::InvalidToken { location },\n UnrecognizedEOF { location, expected } => Self::UnexpectedEOF { location, expected },\n UnrecognizedToken {\n token: (l, _, r),\n expected,\n } => Self::UnrecognizedToken {\n span: SourceSpan::new(l, r),\n expected,\n },\n ExtraToken { token: (l, _, r) } => Self::ExtraToken {\n span: SourceSpan::new(l, r),\n },\n User { .. } => panic!(),\n }\n }\n}\n\nimpl ToDiagnostic for ParserError {\n fn to_diagnostic(&self) -> Diagnostic {\n match self {\n Self::RootFile { .. } => Diagnostic::error().with_message(self.to_string()),\n Self::ShowDiagnostic { diagnostic } => diagnostic.clone(),\n Self::Preprocessor { source } => source.to_diagnostic(),\n Self::Source { source } => source.to_diagnostic(),\n Self::UnrecognizedToken {\n ref span,\n ref expected,\n } => Diagnostic::error()\n .with_message(\"unrecognized token\")\n .with_labels(vec![Label::primary(span.source_id(), *span)\n .with_message(format!(\"expected: {}\", expected.join(\", \")))]),\n Self::InvalidToken { location } => {\n let index = *location;\n Diagnostic::error()\n .with_message(\"unexpected token\")\n .with_labels(vec![Label::primary(\n index.source_id(),\n SourceSpan::new(index, index),\n )\n .with_message(\"did not expect this token\")])\n }\n Self::UnexpectedEOF {\n location,\n ref expected,\n } => {\n let index = *location;\n Diagnostic::error()\n .with_message(\"unexpected end of file\")\n .with_labels(vec![Label::primary(\n index.source_id(),\n SourceSpan::new(index, index),\n )\n .with_message(format!(\"expected: {}\", expected.join(\", \")))])\n }\n Self::ExtraToken { span } => Diagnostic::error()\n .with_message(\"unexpected token\")\n .with_labels(vec![Label::primary(span.source_id(), *span)\n .with_message(\"did not expect this token\")]),\n }\n }\n}\n\nimpl From for ParserError {\n fn from(source: SourceError) -> Self {\n Self::Source { source }\n }\n}\nimpl From for ParserError {\n fn from(source: PreprocessorError) -> Self {\n Self::Preprocessor { source }\n }\n}\n" }, { "path": "libeir_syntax_erl/src/parser/grammar.lalrpop", "content": "//-*- mode: rust -*-\nuse libeir_diagnostics::*;\n\nuse libeir_util_number::{Integer, ToPrimitive, Float};\n\nuse libeir_ir::binary::BinaryEntrySpecifier;\nuse crate::parser::binary::specifier_from_parsed;\n\nuse crate::lexer::{Token, DelayedSubstitution, Symbol, Ident};\nuse crate::preprocessor::PreprocessorError;\n\nuse super::{ParserError, ParserErrorReceiver};\nuse super::ast::*;\ngrammar<'a>(\n errs: &'a mut ParserErrorReceiver<'a>,\n nid: &mut NodeIdGenerator,\n);\n\n\n// The following are _not_ non-terminals, but macros\n// which can be identified by the generic type parameter,\n//\n// Currently all of the macros expect the name of the corresponding\n// non-terminal to have a type of the same name, a macro can\n// be written to handle differing non-terminal/type combinations by\n// adding a second type parameter used only in the type signature\n\n// Semicolon-delimited with at least one element\nSemi: Vec = {\n \";\")*> => {\n let mut v = v;\n v.push(e);\n v\n }\n};\n\n// Comma-delimited with at least one element\nComma: Vec = {\n \",\")*> => {\n let mut v = v;\n v.push(e);\n v\n }\n};\n\n// Comma-delimited with zero or more elements\nCommaOpt: Vec = {\n \",\")*> => {\n let mut vals = vals;\n vals.extend(last);\n vals\n },\n};\n\n// Dash-delimited with at least one element\nDash: Vec = {\n \"-\")*> => {\n let mut v = v;\n v.push(e);\n v\n }\n};\n\npub Module: Module = {\n \"COMMENT\"* \"-\" \"module\" \"(\" \")\" \".\" \"COMMENT\"* => {\n let body = match body {\n None => Vec::new(),\n Some(body) => body,\n };\n Module::new(errs, span!(l, r), nid, name, body)\n }\n};\n\nModuleBody: Vec = TopLevel+;\n\nTopLevel: TopLevel = {\n \n => TopLevel::Function(<>),\n \n => TopLevel::Record(<>),\n \n => TopLevel::Attribute(<>),\n};\n\n// Top-level Functions\n\nFunctionDefinition: NamedFunction = {\n > \".\" \n =>? match NamedFunction::new(errs, span!(l, r), nid, clauses) {\n Ok(inner) => Ok(inner),\n Err(()) => Err(to_lalrpop_err!(())),\n },\n};\n\nFunctionHead: FunctionClause = {\n \"(\" > \")\" \"->\" > => {\n FunctionClause::new(span!(l, r), Some(Name::Atom(a)), params, g, body)\n }\n};\n\nFunctionClause: FunctionClause = {\n \"(\" > \")\" \"->\" > => {\n FunctionClause::new(span!(l, r), a.map(Name::Var), params, g, body)\n }\n};\n\nGuards: Vec = \"when\" ;\nBaseGuards: Vec = >;\n\nGuard: Guard = > \n => Guard { span: span!(l, r), conditions };\n\n\nFunctionName: PartiallyResolvedFunctionName = {\n \"/\" => {\n PartiallyResolvedFunctionName {\n span: span!(l, r),\n id: nid.next(),\n function,\n arity,\n }\n }\n};\n\n// Attributes\n\nAttributeDefinition: Attribute = {\n \"-\" \"vsn\" \"(\" \")\" \".\" \n => Attribute::Vsn(span!(l, r), vsn),\n \"-\" \"author\" \"(\" \")\" \".\" \n => Attribute::Author(span!(l, r), author),\n \"-\" \"compile\" \"(\" \")\" \".\" \n => Attribute::Compile(span!(l, r), opts),\n \"-\" \"import\" \"(\" \",\" \"[\" > \"]\" \")\" \".\" \n => Attribute::Import(span!(l, r), module, imports),\n \"-\" \"export\" \"(\" \"[\" > \"]\" \")\" \".\" \n => Attribute::Export(span!(l, r), exports),\n \"-\" \"export_type\" \"(\" \"[\" > \"]\" \")\" \".\" \n => Attribute::ExportType(span!(l, r), exports),\n \"-\" \"behaviour\" \"(\" \")\" \".\" \n => Attribute::Behaviour(span!(l, r), module),\n \"-\" \"on_load\" \"(\" \")\" \".\" \n => Attribute::OnLoad(span!(l, r), fun),\n TypeAttribute,\n TypeSpecAttribute,\n CallbackAttribute,\n DeprecatedAttribute,\n RemovedAttribute,\n UserAttribute,\n};\n\nRecordDeclaration: Record = {\n \"-\" \"record\" \"(\" \",\" \")\" \".\" \n => Record { span: span!(l, r), id: nid.next(), name, fields },\n};\n\nRemovedAttribute: Attribute = {\n \"-\" \"removed\" \"(\" \"[\" > \"]\" \")\" \".\" \n => Attribute::Removed(span!(l, r), rs),\n};\n\nRemoved: (PartiallyResolvedFunctionName, Ident) = {\n \"{\" \",\" \",\" \"}\" => {\n let span = span!(l, r);\n let f = PartiallyResolvedFunctionName {\n span: span.clone(),\n id: nid.next(),\n function,\n arity,\n };\n\n (f, descr)\n },\n};\n\nTypeAttribute: Attribute = {\n \"-\" \"type\" => {\n let mut def = def;\n def.span = span!(l, r);\n Attribute::Type(def)\n },\n \"-\" \"opaque\" => {\n let mut def = def;\n def.span = span!(l, r);\n def.opaque = true;\n Attribute::Type(def)\n },\n};\n\nTypeSpecAttribute: Attribute = {\n \"-\" \"spec\" => {\n let mut spec = spec;\n spec.span = span!(l, r);\n Attribute::Spec(spec)\n }\n};\n\nCallbackAttribute: Attribute = {\n \"-\" \"callback\" => {\n let callback = Callback {\n span: span!(l, r),\n optional: false,\n module: spec.module,\n function: spec.function,\n sigs: spec.sigs,\n };\n Attribute::Callback(callback)\n },\n \"-\" \"optional_callback\" => {\n let callback = Callback {\n span: span!(l, r),\n optional: true,\n module: spec.module,\n function: spec.function,\n sigs: spec.sigs,\n };\n Attribute::Callback(callback)\n }\n};\n\nDeprecatedAttribute: Attribute = {\n \"-\" \"deprecated\" \"(\" )?> \")\" \".\" =>? {\n match a.as_str().get() {\n \"module\" => {\n Ok(Attribute::Deprecation(vec![\n Deprecation::Module {\n span: span!(l, r),\n flag: flag.unwrap_or(DeprecatedFlag::Eventually),\n }\n ]))\n }\n other => {\n let span = span!(l, r);\n errs.error(PreprocessorError::ShowDiagnostic {\n diagnostic: Diagnostic::warning()\n .with_message(\"invalid deprecated attribute\")\n .with_labels(vec![\n Label::primary(span.source_id(), span)\n .with_message(\"expected 'module', '{module, Flag}', 'Function/Arity', or '{Function/Arity, Flag}'\")\n ])\n }.into());\n Err(to_lalrpop_err!(()))\n }\n }\n },\n \"-\" \"deprecated\" \"(\" \")\" \".\"\n => Attribute::Deprecation(vec![d]),\n \"-\" \"deprecated\" \"(\" \"[\" > \"]\" \")\" \".\"\n => Attribute::Deprecation(ds),\n};\n\nDeprecation: Deprecation = {\n \n => Deprecation::Function { span: span!(l, r), function, flag: DeprecatedFlag::Eventually },\n \"{\" \",\" \"}\" \n => Deprecation::Function { span: span!(l, r), function, flag },\n \"{\" \",\" \",\" \"}\" => {\n let span = span!(l, r);\n let f = PartiallyResolvedFunctionName {\n span: span.clone(),\n id: nid.next(),\n function,\n arity,\n };\n Deprecation::Function { span, function: f, flag }\n }\n};\n\nDeprecatedFlag: DeprecatedFlag = {\n => DeprecatedFlag::Description(s),\n => {\n match flag.as_str().get() {\n \"eventually\" => DeprecatedFlag::Eventually,\n \"next_version\" => DeprecatedFlag::NextVersion,\n \"next_major_release\" => DeprecatedFlag::NextMajorRelease,\n other => {\n let span = span!(l, r);\n errs.warning(ParserError::ShowDiagnostic {\n diagnostic: Diagnostic::warning()\n .with_message(\"invalid deprecation flag\")\n .with_labels(vec![\n Label::primary(span.source_id(), span)\n .with_message(format!(\"expected one of 'eventually', 'next_version', or 'next_major_release', got '{}'\", other))\n ]),\n });\n DeprecatedFlag::Eventually\n }\n }\n },\n};\n\nUserAttribute: Attribute = {\n \"-\" \"(\" \")\" \".\" \n => Attribute::Custom(UserAttribute { span: span!(l, r), name, value }),\n};\n\nTypedRecordFields: Vec = {\n \"{\" > \"}\"\n};\n\nTypedRecordField: RecordField = {\n )?> )?> \n => RecordField { span: span!(l, r), id: nid.next(), name: name, value, ty },\n};\n\n// Type Specifications\n\nTypeDef: TypeDef = {\n \"(\" \")\" => (<>),\n TypeDef100,\n};\n\nTypeDef100: TypeDef = {\n \"(\" > \")\" \"::\" \".\" \n => TypeDef { span: span!(l, r), name, params, ty, opaque: false },\n};\n\nTypeSpec: TypeSpec = {\n \"(\" \":\")?> > \")\" \".\" \n => TypeSpec { span: span!(l, r), module, function, sigs },\n \":\")?> > \".\" \n => TypeSpec { span: span!(l, r), module, function, sigs },\n};\n\nTypeSig: TypeSig = {\n \"(\" > \")\" \"->\" >)?> \n => TypeSig { span: span!(l, r), params, ret: Box::new(ret), guards },\n};\n\nTypeGuard: TypeGuard = {\n // is_subtype is not supported >OTP 19, but is allowed for backwards compatibility\n \"(\" \",\" \")\" =>? {\n match name.name.as_str().get() {\n \"is_subtype\" =>\n Ok(TypeGuard { span: span!(l, r), var, ty }),\n name => {\n let span = span!(l, r);\n errs.error(PreprocessorError::ShowDiagnostic {\n diagnostic: Diagnostic::error()\n .with_message(\"invalid type constraint\")\n .with_labels(vec![\n Label::primary(span.source_id(), span)\n .with_message(\"expected constraint in the form `Name :: Type`\")\n ]),\n }.into());\n Err(to_lalrpop_err!(()))\n }\n }\n },\n \"::\" \n => TypeGuard { span: span!(l, r), var, ty },\n};\n\nTopType: Type = {\n \"|\" \n => Type::union(span!(l, r), lhs, rhs),\n Type100,\n};\n\nType100: Type = {\n \"::\" \n => Type::Annotated { span: span!(l, r), name, ty: Box::new(ty) },\n Type200,\n};\n\nType200: Type = {\n \"..\" \n => Type::Range { span: span!(l, r), start: Box::new(lhs), end: Box::new(rhs) },\n Type300,\n};\n\nType300: Type = {\n \n => Type::BinaryOp { span: span!(l, r), lhs: Box::new(lhs), op, rhs: Box::new(rhs) },\n Type400,\n};\n\nType400: Type = {\n \n => Type::BinaryOp { span: span!(l, r), lhs: Box::new(lhs), op, rhs: Box::new(rhs) },\n Type500,\n};\n\nType500: Type = {\n \n => Type::UnaryOp { span: span!(l, r), op, rhs: Box::new(rhs) },\n Type600,\n};\n\nType600: Type = {\n \"(\" > \")\" \n => Type::Generic { span: span!(l, r), fun, params },\n \":\" \"(\" > \")\" \n => Type::Remote { span: span!(l, r), module, fun, args },\n TypeMax,\n};\n\nTypeMax: Type = {\n \"(\" \")\"\n => ty,\n \"[\" \"]\" \n => Type::Nil(span!(l, r)),\n \"[\" \"]\" \n => Type::List(span!(l, r), Box::new(lt)),\n \"[\" \",\" \"...\" \"]\" \n => Type::NonEmptyList(span!(l, r), Box::new(lt)),\n \"{\" > \"}\" \n => Type::Tuple(span!(l, r), et),\n \"#\" \"{\" > \"}\" \n => Type::Map(span!(l, r), ft),\n \"#\" \"{\" > \"}\" \n => Type::Record(span!(l, r), record, ft),\n BinaryType,\n \n => Type::Name(name),\n \n => Type::Integer(span!(l, r), i),\n \n => Type::Char(span!(l, r), c),\n FunType,\n};\n\nTypeName: Name = {\n \n => name,\n // While this is stupid, generated code by elixir\n // uses 'fun' as a variable a lot in in typespecs.\n // Hack to make this work.\n \"fun\" \n => Name::Var(Ident::new(Symbol::intern(\"fun\"), span!(l, r))),\n};\n\nBinaryType: Type = {\n \"<<\" \">>\" \n => Type::Binary(span!(l, r), Box::new(Type::Integer(span!(l, r), 0.into())), Box::new(Type::Integer(span!(l, r), 0.into()))),\n \"<<\" ident \":\" \">>\" \n => Type::Binary(span!(l, r), Box::new(m), Box::new(Type::Integer(span!(l, r), 0.into()))),\n \"<<\" ident \":\" \",\" ident \":\" \">>\" \n => Type::Binary(span!(l, r), Box::new(m), Box::new(n)),\n};\n\nFunType: Type = {\n \"fun\" \"(\" \")\" \n => Type::AnyFun { span: span!(l, r), ret: None },\n \"fun\" \"(\" \"(\" \"...\" \")\" \"->\" \")\" \n => Type::AnyFun { span: span!(l, r), ret: Some(Box::new(ret)) },\n \"fun\" \"(\" \"(\" > \")\" \"->\" \")\" \n => Type::Fun { span: span!(l, r), params, ret: Box::new(ret) },\n};\n\nMapFieldType: Type = {\n \"=>\" \n => Type::KeyValuePair(span!(l, r), Box::new(key), Box::new(val)),\n \":=\" \n => Type::KeyValuePair(span!(l, r), Box::new(key), Box::new(val)),\n};\n\nRecordFieldType: Type = {\n \"::\" \n => Type::Field(span!(l, r), key, Box::new(val)),\n};\n\n// Pattern Matching\n\nPattern: Expr = {\n \"=\" \n => Expr::Match(Match { span: span!(l, r), id: nid.next(), pattern: Box::new(lhs), expr: Box::new(rhs) }),\n Pattern200\n};\n\nPattern200: Expr = {\n \n => Expr::BinaryExpr(BinaryExpr { span: span!(l, r), id: nid.next(), lhs: Box::new(lhs), op, rhs: Box::new(rhs) }),\n Pattern300\n};\n\nPattern300: Expr = {\n \n => Expr::BinaryExpr(BinaryExpr { span: span!(l, r), id: nid.next(), lhs: Box::new(lhs), op, rhs: Box::new(rhs) }),\n Pattern400\n};\n\nPattern400: Expr = {\n \n => Expr::BinaryExpr(BinaryExpr { span: span!(l, r), id: nid.next(), lhs: Box::new(lhs), op, rhs: Box::new(rhs) }),\n Pattern500\n};\n\nPattern500: Expr = {\n \n => Expr::BinaryExpr(BinaryExpr { span: span!(l, r), id: nid.next(), lhs: Box::new(lhs), op, rhs: Box::new(rhs) }),\n Pattern600\n};\n\nPattern600: Expr = {\n \n => Expr::UnaryExpr(UnaryExpr { span: span!(l, r), id: nid.next(), op, operand: Box::new(rhs) }),\n MapPattern,\n Pattern700\n};\n\nPattern700: Expr = {\n RecordPattern,\n PatternMax\n};\n\nPatternMax: Expr = {\n => Expr::Var(Var(nid.next(), i)),\n Atomic,\n ListPattern,\n Binary,\n Tuple,\n \"(\" \")\"\n};\n\nListPattern: Expr = {\n \"[\" \"]\" \n => Expr::Nil(Nil(span!(l, r), nid.next())),\n \"[\" \n => Expr::Cons(Cons { span: span!(l, r), id: nid.next(), head: Box::new(head), tail: Box::new(tail) })\n};\n\nTailPattern: Expr = {\n \"]\" \n => Expr::Nil(Nil(span!(l, r), nid.next())),\n \"|\" \"]\",\n \",\" \n => Expr::Cons(Cons { span: span!(l, r), id: nid.next(), head: Box::new(head), tail: Box::new(tail) })\n};\n\nMapPattern: Expr = {\n \"#\" \n => Expr::Map(Map { span: span!(l, r), id: nid.next(), fields }),\n \"#\" \n => Expr::MapProjection(MapProjection { span: span!(l, r), id: nid.next(), map: Box::new(lhs), fields }),\n \"#\" \n => Expr::MapProjection(MapProjection { span: span!(l, r), id: nid.next(), map: Box::new(lhs), fields }),\n};\n\nMapTuplePattern: Vec = {\n \"{\" > \"}\"\n};\n\nMapFieldPattern: MapField = {\n \"=>\" \n => MapField::Assoc { span: span!(l, r), id: nid.next(), key, value },\n \":=\" \n => MapField::Exact { span: span!(l, r), id: nid.next(), key, value },\n};\n\nRecordPattern: Expr = {\n \"#\" \".\" \n => Expr::RecordIndex(RecordIndex { span: span!(l, r), id: nid.next(), name, field }),\n \"#\" \n => Expr::Record(Record { span: span!(l, r), id: nid.next(), name, fields }),\n};\n\nRecordTuplePattern: Vec = {\n \"{\" > \"}\"\n};\n\nRecordFieldPattern: RecordField = {\n \"=\" \n => RecordField { span: span!(l, r), id: nid.next(), name, value: Some(value), ty: None },\n};\n\n// Expressions\n\npub Expr: Expr = {\n \"catch\" \n => Expr::Catch(Catch { span: span!(l, r), id: nid.next(), expr: Box::new(e) }),\n Expr100,\n};\n\nExpr100: Expr = {\n // We would like to use Pattern200 here, but this leads to an ambiguity conflict\n // between non-terminals which are same in structure but different type, e.g. Tuple/TuplePattern,\n // so we just need to be aware that Expr::Match is really a pattern expression\n \"=\" \n => Expr::Match(Match { span: span!(l, r), id: nid.next(), pattern: Box::new(lhs), expr: Box::new(rhs) }),\n Expr140,\n};\n\nExpr140: Expr = {\n \"!\" \n => Expr::BinaryExpr(BinaryExpr { span: span!(l, r), id: nid.next(), lhs: Box::new(lhs), op: BinaryOp::Send, rhs: Box::new(rhs) }),\n Expr150\n};\n\nExpr150: Expr = {\n \"orelse\" \n => Expr::BinaryExpr(BinaryExpr { span: span!(l, r), id: nid.next(), lhs: Box::new(lhs), op: BinaryOp::OrElse, rhs: Box::new(rhs) }),\n Expr160\n};\n\nExpr160: Expr = {\n \"andalso\" \n => Expr::BinaryExpr(BinaryExpr { span: span!(l, r), id: nid.next(), lhs: Box::new(lhs), op: BinaryOp::AndAlso, rhs: Box::new(rhs) }),\n Expr200\n};\n\nExpr200: Expr = {\n \n => Expr::BinaryExpr(BinaryExpr { span: span!(l, r), id: nid.next(), lhs: Box::new(lhs), op, rhs: Box::new(rhs) }),\n Expr300\n};\n\nExpr300: Expr = {\n \n => Expr::BinaryExpr(BinaryExpr { span: span!(l, r), id: nid.next(), lhs: Box::new(lhs), op, rhs: Box::new(rhs) }),\n Expr400\n};\n\nExpr400: Expr = {\n \n => Expr::BinaryExpr(BinaryExpr { span: span!(l, r), id: nid.next(), lhs: Box::new(lhs), op, rhs: Box::new(rhs) }),\n Expr500\n};\n\nExpr500: Expr = {\n \n => Expr::BinaryExpr(BinaryExpr { span: span!(l, r), id: nid.next(), lhs: Box::new(lhs), op, rhs: Box::new(rhs) }),\n Expr600\n};\n\nExpr600: Expr = {\n \n => Expr::UnaryExpr(UnaryExpr { span: span!(l, r), id: nid.next(), op, operand: Box::new(rhs) }),\n MapExpr,\n Expr700\n};\n\nExpr700: Expr = {\n Apply,\n RecordExpr,\n Expr800\n};\n\nExpr800: Expr = {\n \":\" \n => Expr::Remote(Remote { span: span!(l, r), id: nid.next(), module: Box::new(lhs), function: Box::new(rhs) }),\n ExprMax\n};\n\nExprMax: Expr = {\n => Expr::Var(Var(nid.next(), i)),\n Atomic,\n Tuple,\n List,\n Binary,\n ListComprehension,\n BinaryComprehension,\n \"(\" \")\",\n \"begin\" > \"end\" \n => Expr::Begin(Begin { span: span!(l, r), id: nid.next(), body }),\n If,\n Case,\n Receive,\n Try,\n Fun,\n DelayedSubstitution,\n};\n\nFun: Expr = {\n \"fun\" \n => Expr::FunctionName(FunctionName::PartiallyResolved(fun)),\n \"fun\" \":\" \"/\" =>\n Expr::FunctionName(FunctionName::detect(span!(l, r), nid, Some(module), function, arity)),\n \"fun\" > \"end\" =>? {\n match Function::new(errs, span!(l, r), nid, clauses) {\n Ok(fun) => Ok(Expr::Fun(fun)),\n Err(()) => Err(to_lalrpop_err!(())),\n }\n },\n};\n\nIf: Expr = {\n \"if\" > \"end\" \n => Expr::If(If { span: span!(l, r), id: nid.next(), clauses })\n};\nIfClause: IfClause = {\n \"->\" > \n => IfClause { span: span!(l, r), id: nid.next(), guards, body }\n};\n\nCase: Expr = {\n \"case\" \"of\" > \"end\" \n => Expr::Case(Case { span: span!(l, r), id: nid.next(), expr: Box::new(input), clauses })\n};\n\nReceive: Expr = {\n \"receive\" \"end\" \n => Expr::Receive(Receive { span: span!(l, r), id: nid.next(), clauses: None, after: Some(after) }),\n \"receive\" > \"end\" \n => Expr::Receive(Receive { span: span!(l, r), id: nid.next(), clauses: Some(clauses), after })\n};\n\nAfter: After = {\n \"after\" \"->\" > \n => After { span: span!(l, r), id: nid.next(), timeout: Box::new(timeout), body }\n};\n\nTry: Expr = {\n \"try\" > \"of\" > \n => Expr::Try(Try { span: span!(l, catch.2), id: nid.next(), exprs, clauses: Some(clauses), catch_clauses: catch.0, after: catch.1 }),\n \"try\" > \n => Expr::Try(Try { span: span!(l, catch.2), id: nid.next(), exprs, clauses: None, catch_clauses: catch.0, after: catch.1 })\n};\n\nTryCatch: (Option>, Option>, SourceIndex) = {\n \"catch\" > \"end\" \n => (Some(clauses), None, r),\n \"catch\" > \"after\" > \"end\" \n => (Some(clauses), Some(body), r),\n \"after\" > \"end\" \n => (None, Some(body), r)\n};\n\nTryClause: TryClause = {\n \"->\" > \n => TryClause { span: span!(l, r), id: nid.next(), kind: Name::Atom(Ident::from_str(\"throw\")), error, guard, trace: Ident::from_str(\"_\"), body },\n \":\" \"->\" > \n => TryClause { span: span!(l, r), id: nid.next(), kind, error, guard, trace: Ident::from_str(\"_\"), body },\n \":\" \":\" \"->\" > \n => TryClause { span: span!(l, r), id: nid.next(), kind, error, guard, trace, body },\n};\n\nClause: Clause = {\n \"->\" > \n => Clause { span: span!(l, r), id: nid.next(), pattern, guard, body } \n};\n\nApply: Expr = {\n \"(\" > \")\" \n => Expr::Apply(Apply { span: span!(l, r), id: nid.next(), callee: Box::new(lhs), args })\n};\n\nListComprehension: Expr = {\n \"[\" \"||\" > \"]\" \n => Expr::ListComprehension(ListComprehension { span: span!(l, r), id: nid.next(), body: Box::new(body), qualifiers }),\n};\n\nBinaryComprehension: Expr = {\n \"<<\" \"||\" > \">>\" \n => Expr::BinaryComprehension(BinaryComprehension { span: span!(l, r), id: nid.next(), body: Box::new(body), qualifiers }),\n};\n\nComprehensionExpr: Expr = {\n \"<=\" \n => Expr::BinaryGenerator(BinaryGenerator { span: span!(l, r), id: nid.next(), pattern: Box::new(lhs), expr: Box::new(rhs) }),\n \"<-\" \n => Expr::Generator(Generator { span: span!(l, r), id: nid.next(), pattern: Box::new(lhs), expr: Box::new(rhs) }),\n Expr,\n};\n\nBinary: Expr = {\n \"<<\" > \">>\" \n => Expr::Binary(Binary { span: span!(l, r), id: nid.next(), elements }),\n};\n\nBinaryElement: BinaryElement = {\n => {\n let spec = bts.as_ref().map(|b| match specifier_from_parsed(b, bs.is_some()) {\n Ok(specifier) => specifier,\n Err(error) => {\n // TODO\n errs.error(error.to_diagnostic().into());\n BinaryEntrySpecifier::default()\n },\n });\n BinaryElement { span: span!(l, r), id: nid.next(), bit_expr: be, bit_size: bs, specifier: spec }\n }\n};\n\nBitExpr: Expr = {\n \n => Expr::UnaryExpr(UnaryExpr { span: span!(l, r), id: nid.next(), op, operand: Box::new(rhs) }),\n ExprMax,\n};\n\nBitSize: Expr = {\n \":\" ,\n};\n\nBitTypeList: Vec = {\n \"/\" > => bts,\n};\n\nBitType: BitType = {\n \":\" \n => BitType::Sized(span!(l, r), nid.next(), ty, i.to_i64().unwrap()),\n \n => BitType::Name(span!(l, r), nid.next(), ty)\n};\n\nTuple: Expr = {\n \"{\" > \"}\" \n => Expr::Tuple(Tuple { span: span!(l, r), id: nid.next(), elements })\n};\n\nList: Expr = {\n \"[\" \"]\" \n => Expr::Nil(Nil(span!(l, r), nid.next())),\n \"[\" \n => Expr::Cons(Cons { span: span!(l, r), id: nid.next(), head: Box::new(head), tail: Box::new(tail) })\n};\n\nTail: Expr = {\n \"]\" \n => Expr::Nil(Nil(span!(l, r), nid.next())),\n \"|\" \"]\",\n \",\" \n => Expr::Cons(Cons { span: span!(l, r), id: nid.next(), head: Box::new(head), tail: Box::new(tail) })\n};\n\nMapExpr: Expr = {\n \"#\" \n => Expr::Map(Map { span: span!(l, r), id: nid.next(), fields }),\n \"#\" \n => Expr::MapUpdate(MapUpdate { span: span!(l, r), id: nid.next(), map: Box::new(map), updates }),\n \"#\" \n => Expr::MapUpdate(MapUpdate { span: span!(l, r), id: nid.next(), map: Box::new(map), updates }),\n};\n\nMapTuple: Vec = {\n \"{\" > \"}\"\n};\n\nMapField: MapField = {\n MapFieldAssoc,\n MapFieldExact\n};\nMapFieldAssoc: MapField = {\n \"=>\" \n => MapField::Assoc { span: span!(l, r), id: nid.next(), key, value }\n};\nMapFieldExact: MapField = {\n \":=\" \n => MapField::Exact { span: span!(l, r), id: nid.next(), key, value }\n};\n\nMapKey: Expr = Expr;\n\nRecordExpr: Expr = {\n \"#\" \".\" \n => Expr::RecordIndex(RecordIndex { span: span!(l, r), id: nid.next(), name, field }),\n \"#\" \n => Expr::Record(Record { span: span!(l, r), id: nid.next(), name, fields }),\n\n \"#\" \".\" \n => Expr::RecordAccess(RecordAccess { span: span!(l, r), id: nid.next(), record: Box::new(lhs), name, field }),\n \"#\" \n => Expr::RecordUpdate(RecordUpdate { span: span!(l, r), id: nid.next(), record: Box::new(lhs), name, updates }),\n\n \"#\" \".\" \n => Expr::RecordAccess(RecordAccess { span: span!(l, r), id: nid.next(), record: Box::new(lhs), name, field }),\n \"#\" \n => Expr::RecordUpdate(RecordUpdate { span: span!(l, r), id: nid.next(), record: Box::new(lhs), name, updates }),\n};\n\nRecordTuple: Vec = {\n \"{\" > \"}\"\n};\n\nRecordField: RecordField = {\n \"=\" \n => RecordField { span: span!(l, r), id: nid.next(), name, value: Some(value), ty: None },\n};\n\nConstant: Expr = {\n ConstantTuple,\n ConstantList,\n ConstantMapExpr,\n =>\n Expr::FunctionName(FunctionName::PartiallyResolved(<>)),\n Atomic,\n};\n\n\nConstantTuple: Expr = {\n \"{\" > \"}\" \n => Expr::Tuple(Tuple { span: span!(l, r), id: nid.next(), elements })\n};\n\nConstantList: Expr = {\n \"[\" \"]\" \n => Expr::Nil(Nil(span!(l, r), nid.next())),\n \"[\" \n => Expr::Cons(Cons { span: span!(l, r), id: nid.next(), head: Box::new(head), tail: Box::new(tail) })\n};\n\nConstantTail: Expr = {\n \"]\" \n => Expr::Nil(Nil(span!(l, r), nid.next())),\n \"|\" \"]\",\n \",\" \n => Expr::Cons(Cons { span: span!(l, r), id: nid.next(), head: Box::new(head), tail: Box::new(tail) })\n};\n\nConstantMapExpr: Expr = {\n \"#\" \n => Expr::Map(Map { span: span!(l, r), id: nid.next(), fields }),\n};\n\nConstantMapTuple: Vec = {\n \"{\" > \"}\"\n};\n\nConstantMapField: MapField = {\n \"=>\" \n => MapField::Assoc { span: span!(l, r), id: nid.next(), key, value }\n};\n\nConstantMapKey: Expr = Constant;\n\nAtomic: Expr = {\n \n => Expr::Literal(Literal::Char(span!(l, r), nid.next(), c)),\n \n => Expr::Literal(<>),\n \n => Expr::Literal(Literal::Float(span!(l, r), nid.next(), f)),\n \n => Expr::Literal(Literal::Atom(nid.next(), <>)),\n \n => Expr::Literal(Literal::String(nid.next(), s)),\n};\n\nStringLiteral: Ident = => {\n let span = span!(l, r);\n if s.len() == 1 {\n Ident::new(s[0], span)\n } else {\n let mut buf = String::new();\n for frag in s.iter() {\n buf.push_str(&frag.as_str());\n }\n let symbol = Symbol::intern(&buf);\n\n Ident::new(symbol, span)\n }\n};\n\nDelayedSubstitution: Expr = {\n =>\n Expr::DelayedSubstitution(span!(l, r), nid.next(), subs),\n};\n\n#[inline]\natom_or_var: Name = {\n => Name::Atom(a),\n => Name::Var(i),\n};\n\n#[inline]\natom: Ident = \n => Ident::new(a, span!(l, r));\n\n#[inline]\nIdent: Ident = \n => Ident::new(i, span!(l, r));\n\n#[inline]\nInteger: Literal = {\n \n => Literal::Integer(span!(l, r), nid.next(), i),\n};\n\n#[inline]\narity_or_var: Arity = {\n => Arity::Int(i.to_usize().unwrap()),\n => Arity::Var(i),\n};\n\n#[inline]\narity: usize = => i.to_usize().unwrap();\n\n#[inline]\nident_or_integer: Expr = {\n => Expr::Var(Var(nid.next(), i)),\n => Expr::Literal(i)\n}\n\nPrefixOp: UnaryOp = {\n \"+\" => UnaryOp::Plus,\n \"-\" => UnaryOp::Minus,\n \"bnot\" => UnaryOp::Bnot,\n \"not\" => UnaryOp::Not,\n};\n\nMultOp: BinaryOp = {\n \"/\" => BinaryOp::Divide,\n \"*\" => BinaryOp::Multiply,\n \"div\" => BinaryOp::Div,\n \"rem\" => BinaryOp::Rem,\n \"band\" => BinaryOp::Band,\n \"and\" => BinaryOp::And,\n};\n\nAddOp: BinaryOp = {\n \"+\" => BinaryOp::Add,\n \"-\" => BinaryOp::Sub,\n \"bor\" => BinaryOp::Bor,\n \"bxor\" => BinaryOp::Bxor,\n \"bsl\" => BinaryOp::Bsl,\n \"bsr\" => BinaryOp::Bsr,\n \"or\" => BinaryOp::Or,\n \"xor\" => BinaryOp::Xor,\n};\n\nTypeMultOp: BinaryOp = {\n \"*\" => BinaryOp::Multiply,\n \"div\" => BinaryOp::Div,\n \"rem\" => BinaryOp::Rem,\n \"band\" => BinaryOp::Band,\n};\n\nTypeAddOp: BinaryOp = {\n \"+\" => BinaryOp::Add,\n \"-\" => BinaryOp::Sub,\n \"bor\" => BinaryOp::Bor,\n \"bxor\" => BinaryOp::Bxor,\n \"bsl\" => BinaryOp::Bsl,\n \"bsr\" => BinaryOp::Bsr,\n};\n\nTypeUnaryOp: UnaryOp = {\n \"+\" => UnaryOp::Plus,\n \"-\" => UnaryOp::Minus,\n \"bnot\" => UnaryOp::Bnot,\n};\n\nListOp: BinaryOp = {\n \"++\" => BinaryOp::Append,\n \"--\" => BinaryOp::Remove,\n};\n\nCompOp: BinaryOp = {\n \"==\" => BinaryOp::Equal,\n \"/=\" => BinaryOp::NotEqual,\n \"=<\" => BinaryOp::Lte,\n \"<\" => BinaryOp::Lt,\n \">=\" => BinaryOp::Gte,\n \">\" => BinaryOp::Gt,\n \"=:=\" => BinaryOp::StrictEqual,\n \"=/=\" => BinaryOp::StrictNotEqual\n};\n\nBaseInt: Integer = {\n \"-\" => -i,\n => i,\n};\nFloat: Float = {\n \"-\" => -i,\n => i,\n};\n\nextern {\n type Location = SourceIndex;\n type Error = ();\n\n enum Token {\n // Docs\n \"COMMENT\" => Token::Comment,\n // Literals\n char => Token::Char(),\n int => Token::Integer(),\n float => Token::Float(),\n \"atom\" => Token::Atom(),\n string => Token::String(),\n ident => Token::Ident(),\n delayed_substitution => Token::DelayedSubstitution(),\n // Keywords and Symbols\n \"(\" => Token::LParen,\n \")\" => Token::RParen,\n \",\" => Token::Comma,\n \"->\" => Token::RightStab,\n \"{\" => Token::LBrace,\n \"}\" => Token::RBrace,\n \"[\" => Token::LBracket,\n \"]\" => Token::RBracket,\n \"|\" => Token::Bar,\n \"||\" => Token::BarBar,\n \"<-\" => Token::LeftStab,\n \";\" => Token::Semicolon,\n \":\" => Token::Colon,\n \"#\" => Token::Pound,\n \".\" => Token::Dot,\n \"after\" => Token::After,\n \"begin\" => Token::Begin,\n \"case\" => Token::Case,\n \"try\" => Token::Try,\n \"catch\" => Token::Catch,\n \"end\" => Token::End,\n \"fun\" => Token::Fun,\n \"if\" => Token::If,\n \"of\" => Token::Of,\n \"receive\" => Token::Receive,\n \"when\" => Token::When,\n \"record\" => Token::Record,\n \"spec\" => Token::Spec,\n \"callback\" => Token::Callback,\n \"optional_callback\" => Token::OptionalCallback,\n \"import\" => Token::Import,\n \"export\" => Token::Export,\n \"removed\" => Token::Removed,\n \"export_type\" => Token::ExportType,\n \"module\" => Token::Module,\n \"compile\" => Token::Compile,\n \"vsn\" => Token::Vsn,\n \"author\" => Token::Author,\n \"on_load\" => Token::OnLoad,\n \"behaviour\" => Token::Behaviour,\n \"deprecated\" => Token::Deprecated,\n \"type\" => Token::Type,\n \"opaque\" => Token::Opaque,\n \"file\" => Token::File,\n \"andalso\" => Token::AndAlso,\n \"orelse\" => Token::OrElse,\n \"bnot\" => Token::Bnot,\n \"not\" => Token::Not,\n \"*\" => Token::Star,\n \"/\" => Token::Slash,\n \"div\" => Token::Div,\n \"rem\" => Token::Rem,\n \"band\" => Token::Band,\n \"and\" => Token::And,\n \"+\" => Token::Plus,\n \"-\" => Token::Minus,\n \"bor\" => Token::Bor,\n \"bxor\" => Token::Bxor,\n \"bsl\" => Token::Bsl,\n \"bsr\" => Token::Bsr,\n \"or\" => Token::Or,\n \"xor\" => Token::Xor,\n \"++\" => Token::PlusPlus,\n \"--\" => Token::MinusMinus,\n \"==\" => Token::IsEqual,\n \"/=\" => Token::IsNotEqual,\n \"=<\" => Token::IsLessThanOrEqual,\n \"<\" => Token::IsLessThan,\n \">=\" => Token::IsGreaterThanOrEqual,\n \">\" => Token::IsGreaterThan,\n \"=:=\" => Token::IsExactlyEqual,\n \"=/=\" => Token::IsExactlyNotEqual,\n \"<=\" => Token::LeftArrow,\n \"=>\" => Token::RightArrow,\n \":=\" => Token::ColonEqual,\n \"<<\" => Token::BinaryStart,\n \">>\" => Token::BinaryEnd,\n \"!\" => Token::Bang,\n \"=\" => Token::Equals,\n \"::\" => Token::ColonColon,\n \"..\" => Token::DotDot,\n \"...\" => Token::DotDotDot,\n \"?\" => Token::Question,\n }\n}\n" }, { "path": "libeir_syntax_erl/src/parser/macros.rs", "content": "/// Construct a keyword list AST from a list of expressions, e.g.:\n///\n/// kwlist!(tuple!(atom!(key), var!(Value)))\n///\n/// It is required that elements are two-tuples, but no checking is done\n/// to make sure that the first element in each tuple is an atom\n#[allow(unused_macros)]\nmacro_rules! kwlist {\n ($nid:expr, $($element:expr),*) => {\n let mut elements = vec![$($element),*];\n elements.reverse();\n elements.fold(nil!($nid), |acc, (key, val)| {\n cons!($nid, Expr::Tuple(Tuple { span: SourceSpan::UNKNOWN, id: $nid.next(), elements: vec![key, val] }), acc)\n })\n }\n}\n\n/// Like `kwlist!`, but produces a list of elements produced by any arbitrary expression\n///\n/// list!(atom!(foo), tuple!(atom!(bar), atom!(baz)))\n///\n/// Like `kwlist!`, this produces a proper list\n#[allow(unused_macros)]\nmacro_rules! list {\n ($nid:expr, $($element:expr),*) => {\n {\n let mut elements = vec![$($element),*];\n elements.reverse();\n elements.iter().fold(nil!($nid), |acc, el| {\n cons!($nid, *el, acc)\n })\n }\n }\n}\n\n/// A lower-level primitive for constructing lists, via cons cells.\n/// Given the following:\n///\n/// cons!(atom!(a), cons!(atom!(b), nil!()))\n///\n/// This is equivalent to `[a | [b | []]]`, which is in turn equivalent\n/// to `[a, b]`. You are better off using `list!` unless you explicitly\n/// need to construct an improper list\n#[allow(unused_macros)]\nmacro_rules! cons {\n ($nid:expr, $head:expr, $tail:expr) => {\n Expr::Cons(Cons {\n span: SourceSpan::UNKNOWN,\n id: $nid.next(),\n head: Box::new($head),\n tail: Box::new($tail),\n })\n };\n}\n\nmacro_rules! nil {\n ($nid:expr) => {\n Expr::Nil(Nil(SourceSpan::UNKNOWN, $nid.next()))\n };\n}\n\n/// Produces a tuple expression with the given elements\nmacro_rules! tuple {\n ($nid:expr, $($element:expr),*) => {\n Expr::Tuple(Tuple{\n span: SourceSpan::UNKNOWN,\n id: $nid.next(),\n elements: vec![$($element),*],\n })\n }\n}\n\n/// Produces an integer literal expression\nmacro_rules! int {\n ($nid:expr, $i:expr) => {\n Expr::Literal(Literal::Integer(SourceSpan::UNKNOWN, $nid.next(), $i))\n };\n}\n\n/// Produces a literal expression which evaluates to an atom\nmacro_rules! atom {\n ($nid:expr, $sym:ident) => {\n Expr::Literal(Literal::Atom(\n $nid.next(),\n Ident::with_empty_span(Symbol::intern(stringify!($sym))),\n ))\n };\n ($nid:expr, $sym:expr) => {\n Expr::Literal(Literal::Atom(\n $nid.next(),\n Ident::with_empty_span(Symbol::intern($sym)),\n ))\n };\n}\n\nmacro_rules! atom_from_sym {\n ($nid:expr, $sym:expr) => {\n Expr::Literal(Literal::Atom($nid.next(), Ident::with_empty_span($sym)))\n };\n}\n\n/// Produces an Ident from an expression, meant to be used to simplify generating\n/// identifiers in the AST from strings or symbols\nmacro_rules! ident {\n ($sym:ident) => {\n Ident::with_empty_span(Symbol::intern(stringify!($sym)))\n };\n ($sym:expr) => {\n Ident::with_empty_span(Symbol::intern($sym))\n };\n (_) => {\n Ident::with_empty_span(Symbol::intern(\"_\"))\n };\n}\n\n/// Produces an Option from an expression, meant to be used to simplify generating\n/// identifiers in the AST from strings or symbols\n#[allow(unused_macros)]\nmacro_rules! ident_opt {\n ($sym:ident) => {\n Some(Ident::with_empty_span(Symbol::intern(stringify!($sym))))\n };\n ($sym:expr) => {\n Some(Ident::with_empty_span(Symbol::intern($sym)))\n };\n (_) => {\n Ident::with_empty_span(Symbol::intern(\"_\"))\n };\n}\n\n/// Produces a variable expression\nmacro_rules! var {\n ($nid:expr, $name:ident) => {\n Expr::Var(Var($nid.next(), ident!(stringify!($name))))\n };\n ($nid:expr, _) => {\n Expr::Var(Var($nid.next(), ident!(_)))\n };\n}\n\n/// Produces a remote expression, e.g. `erlang:get_module_info`\n///\n/// Expects the module/function to be identifier symbols\nmacro_rules! remote {\n ($nid: expr, $module:ident, $function:ident) => {\n Expr::Remote(Remote {\n span: SourceSpan::UNKNOWN,\n id: $nid.next(),\n module: Box::new(atom!($nid, $module)),\n function: Box::new(atom!($nid, $function)),\n })\n };\n ($nid:expr, $module:expr, $function:expr) => {\n Expr::Remote(Remote {\n span: SourceSpan::UNKNOWN,\n id: $nid.next(),\n module: Box::new($module),\n function: Box::new($function),\n })\n };\n}\n\n/// Produces a function application expression\nmacro_rules! apply {\n ($nid:expr, $callee:expr, $($args:expr),*) => {\n Expr::Apply(Apply {\n span: SourceSpan::UNKNOWN,\n id: $nid.next(),\n callee: Box::new($callee),\n args: vec![$($args),*]\n })\n }\n}\n\n/// Produces a function definition\nmacro_rules! fun {\n ($nid:expr, $name:ident ($($params:ident),*) -> $body:expr) => {\n {\n let params = vec![$(var!($nid, $params)),*];\n let arity = params.len();\n NamedFunction {\n span: SourceSpan::UNKNOWN,\n id: $nid.next(),\n name: Name::Atom(ident!($name)),\n arity,\n clauses: vec![\n FunctionClause{\n span: SourceSpan::UNKNOWN,\n name: Some(Name::Atom(ident!($name))),\n params,\n guard: None,\n body: vec![$body],\n }\n ],\n spec: None,\n }\n }\n };\n ($nid:expr, $name:ident $(($($params:expr),*) -> $body:expr);*) => {\n {\n let mut clauses = Vec::new();\n $(\n clauses.push(FunctionClause {\n span: SourceSpan::UNKNOWN,\n name: Some(Name::Atom(ident!($name))),\n params: vec![$($params),*],\n guard: None,\n body: vec![$body],\n });\n )*\n let arity = clauses.first().as_ref().unwrap().params.len();\n NamedFunction {\n span: SourceSpan::UNKNOWN,\n id: $nid.next(),\n name: Name::Atom(ident!($name)),\n arity,\n clauses,\n spec: None,\n }\n }\n }\n}\n" }, { "path": "libeir_syntax_erl/src/parser/mod.rs", "content": "/// Used in the grammar for easy span creation\nmacro_rules! span {\n ($l:expr, $r:expr) => {\n SourceSpan::new($l, $r)\n };\n ($i:expr) => {\n SourceSpan::new($i, $i)\n };\n}\n\n/// Convenience function for building parser errors\nmacro_rules! to_lalrpop_err (\n ($error:expr) => (lalrpop_util::ParseError::User { error: $error })\n);\n\ntype ParserErrorReceiver<'a> = dyn ErrorReceiver + 'a;\n\n#[cfg_attr(rustfmt, rustfmt_skip)]\n#[allow(unknown_lints)]\n#[allow(clippy)]\n#[allow(unused_parens)]\npub(crate) mod grammar {\n // During the build step, `build.rs` will output the generated parser to `OUT_DIR` to avoid\n // adding it to the source directory, so we just directly include the generated parser here.\n //\n // Even with `.gitignore` and the `exclude` in the `Cargo.toml`, the generated parser can still\n // end up in the source directory. This could happen when `cargo build` builds the file out of\n // the Cargo cache (`$HOME/.cargo/registrysrc`), and the build script would then put its output\n // in that cached source directory because of https://github.com/lalrpop/lalrpop/issues/280.\n // Later runs of `cargo vendor` then copy the source from that directory, including the\n // generated file.\n include!(concat!(env!(\"OUT_DIR\"), \"/parser/grammar.rs\"));\n}\n\n#[macro_use]\nmod macros;\n\npub mod ast;\nmod errors;\n\npub mod binary;\n\nuse std::collections::VecDeque;\nuse std::path::PathBuf;\n\nuse libeir_util_parse::{error_tee, ErrorReceiver, Scanner, Source, SourceError};\nuse libeir_util_parse::{Parse as GParse, Parser as GParser};\n\npub type Parser = GParser;\npub trait Parse = GParse;\n\nuse crate::lexer::Lexer;\nuse crate::preprocessor::{MacroContainer, Preprocessed, Preprocessor};\n\npub use self::ast::{NodeId, NodeIdGenerator};\npub use self::errors::*;\n\n/// The type of result returned from parsing functions\npub type ParseResult = Result>;\n\n#[derive(Debug, Clone, PartialEq, Eq)]\npub struct ParseConfig {\n pub warnings_as_errors: bool,\n pub no_warn: bool,\n pub include_paths: VecDeque,\n pub code_paths: VecDeque,\n pub macros: Option,\n}\nimpl ParseConfig {\n pub fn new() -> Self {\n ParseConfig::default()\n }\n}\nimpl Default for ParseConfig {\n fn default() -> Self {\n ParseConfig {\n warnings_as_errors: false,\n no_warn: false,\n include_paths: VecDeque::new(),\n code_paths: VecDeque::new(),\n macros: None,\n }\n }\n}\n\nimpl GParse for ast::Module {\n type Parser = grammar::ModuleParser;\n type Error = ParserError;\n type Config = ParseConfig;\n type Token = Preprocessed;\n\n fn root_file_error(source: std::io::Error, path: std::path::PathBuf) -> Self::Error {\n ParserError::RootFile { source, path }\n }\n\n fn parse<'a, S>(\n parser: &Parser,\n err: &'a mut ParserErrorReceiver<'a>,\n source: S,\n ) -> Result\n where\n S: Source,\n {\n error_tee(err, |mut errors| {\n let scanner = Scanner::new(source);\n let lexer = Lexer::new(scanner);\n error_tee(&mut errors.clone().make_into_adapter(), |preproc_errors| {\n let tokens = Preprocessor::new(parser, lexer, preproc_errors);\n Self::parse_tokens(&mut errors, tokens)\n })\n })\n }\n\n fn parse_tokens<'a, S: IntoIterator>(\n err: &'a mut ParserErrorReceiver<'a>,\n tokens: S,\n ) -> Result {\n let mut nid = NodeIdGenerator::new();\n let result = Self::Parser::new().parse(err, &mut nid, tokens);\n to_parse_result(err, result)\n }\n}\n\nimpl GParse for ast::Expr {\n type Parser = grammar::ExprParser;\n type Error = ParserError;\n type Config = ParseConfig;\n type Token = Preprocessed;\n\n fn root_file_error(source: std::io::Error, path: std::path::PathBuf) -> Self::Error {\n ParserError::RootFile { source, path }\n }\n\n fn parse(parser: &Parser, err: &mut ParserErrorReceiver, source: S) -> Result\n where\n S: Source,\n {\n error_tee(err, |mut errors| {\n let scanner = Scanner::new(source);\n let lexer = Lexer::new(scanner);\n error_tee(&mut errors.clone().make_into_adapter(), |preproc_errors| {\n let tokens = Preprocessor::new(parser, lexer, preproc_errors);\n Self::parse_tokens(&mut errors, tokens)\n })\n })\n }\n\n fn parse_tokens>(\n err: &mut ParserErrorReceiver,\n tokens: S,\n ) -> Result {\n let mut nid = NodeIdGenerator::new();\n let result = Self::Parser::new().parse(err, &mut nid, tokens);\n to_parse_result(err, result)\n }\n}\n\nfn to_parse_result(\n errs: &mut ParserErrorReceiver,\n result: Result,\n) -> Result {\n match result {\n Ok(ast) => {\n if (*errs).is_failed() {\n return Err(());\n }\n Ok(ast)\n }\n Err(lalrpop_util::ParseError::User { .. }) => Err(()),\n Err(err) => {\n errs.error(err.into());\n Err(())\n }\n }\n}\n\n#[cfg(test)]\nmod test {\n use std::sync::Arc;\n\n use pretty_assertions::assert_eq;\n\n use super::ast::*;\n use super::*;\n\n use libeir_diagnostics::*;\n use libeir_util_parse::{ErrorOrWarning, Errors};\n\n use crate::lexer::{Ident, Symbol};\n use crate::preprocessor::PreprocessorError;\n\n fn fail_with(errors: &Errors, codemap: &CodeMap, message: &'static str) -> !\n where\n E: ToDiagnostic,\n W: ToDiagnostic,\n {\n use term::termcolor::{ColorChoice, StandardStream};\n\n let config = term::Config::default();\n let mut out = StandardStream::stderr(ColorChoice::Always);\n for diagnostic in errors.iter_diagnostics() {\n term::emit(&mut out, &config, codemap, &diagnostic).unwrap();\n }\n panic!(message);\n }\n\n fn parse(config: ParseConfig, codemap: Arc, input: S) -> T\n where\n T: Parse,\n S: AsRef,\n {\n let mut errors = Errors::new();\n let parser = Parser::new(config, codemap);\n match parser.parse_string::(&mut errors, input) {\n Ok(ast) => return ast,\n Err(_errs) => fail_with(&errors, &parser.codemap, \"parse failed\"),\n }\n }\n\n fn parse_fail(\n config: ParseConfig,\n codemap: Arc,\n input: S,\n ) -> Errors\n where\n T: Parse,\n S: AsRef,\n {\n let mut errors = Errors::new();\n let parser = Parser::new(config, codemap);\n match parser.parse_string::(&mut errors, input) {\n Err(()) => errors,\n _ => panic!(\"expected parse to fail, but it succeeded!\"),\n }\n }\n\n macro_rules! module {\n ($codemap:expr, $nid:expr, $name:expr, $body:expr) => {{\n let mut errs = Errors::new();\n let module = Module::new(&mut errs, SourceSpan::UNKNOWN, $nid, $name, $body);\n if errs.is_failed() {\n fail_with(&errs, $codemap, \"failed to create expected module!\");\n }\n module\n }};\n }\n\n #[test]\n fn parse_empty_module() {\n let codemap = Arc::new(CodeMap::new());\n let config = ParseConfig::default();\n let result: Module = parse(config, codemap.clone(), \"-module(foo).\");\n let mut nid = NodeIdGenerator::new();\n let expected = module!(&codemap, &mut nid, ident!(\"foo\"), vec![]);\n assert_eq!(result, expected);\n }\n\n #[test]\n fn parse_module_with_multi_clause_function() {\n let codemap = Arc::new(CodeMap::new());\n let config = ParseConfig::default();\n let result: Module = parse(\n config,\n codemap.clone(),\n \"-module(foo).\n\nfoo([], Acc) -> Acc;\nfoo([H|T], Acc) -> foo(T, [H|Acc]).\n\",\n );\n\n let mut id_gen = NodeIdGenerator::new();\n let nid = &mut id_gen;\n\n let mut clauses = Vec::new();\n clauses.push(FunctionClause {\n span: SourceSpan::UNKNOWN,\n name: ident_opt!(foo).map(Name::Atom),\n params: vec![nil!(nid), var!(nid, Acc)],\n guard: None,\n body: vec![var!(nid, Acc)],\n });\n clauses.push(FunctionClause {\n span: SourceSpan::UNKNOWN,\n name: ident_opt!(foo).map(Name::Atom),\n params: vec![cons!(nid, var!(nid, H), var!(nid, T)), var!(nid, Acc)],\n guard: None,\n body: vec![apply!(\n nid,\n atom!(nid, foo),\n var!(nid, T),\n cons!(nid, var!(nid, H), var!(nid, Acc))\n )],\n });\n let mut body = Vec::new();\n body.push(TopLevel::Function(NamedFunction {\n span: SourceSpan::UNKNOWN,\n id: nid.next(),\n name: Name::Atom(ident!(\"foo\")),\n arity: 2,\n clauses,\n spec: None,\n }));\n let expected = module!(&codemap, nid, ident!(foo), body);\n assert_eq!(result, expected);\n }\n\n #[test]\n fn parse_if_expressions() {\n let codemap = Arc::new(CodeMap::new());\n let config = ParseConfig::default();\n let result: Module = parse(\n config,\n codemap.clone(),\n \"-module(foo).\n\nunless(false) ->\n true;\nunless(true) ->\n false;\nunless(Value) ->\n if\n Value == 0 -> true;\n Value -> false;\n else -> true\n end.\n\n\",\n );\n\n let mut id_gen = NodeIdGenerator::new();\n let nid = &mut id_gen;\n\n let mut clauses = Vec::new();\n clauses.push(FunctionClause {\n span: SourceSpan::UNKNOWN,\n name: ident_opt!(unless).map(Name::Atom),\n params: vec![atom!(nid, false)],\n guard: None,\n body: vec![atom!(nid, true)],\n });\n clauses.push(FunctionClause {\n span: SourceSpan::UNKNOWN,\n name: ident_opt!(unless).map(Name::Atom),\n params: vec![atom!(nid, true)],\n guard: None,\n body: vec![atom!(nid, false)],\n });\n clauses.push(FunctionClause {\n span: SourceSpan::UNKNOWN,\n name: ident_opt!(unless).map(Name::Atom),\n params: vec![var!(nid, Value)],\n guard: None,\n body: vec![Expr::If(If {\n span: SourceSpan::UNKNOWN,\n id: nid.next(),\n clauses: vec![\n IfClause {\n span: SourceSpan::UNKNOWN,\n id: nid.next(),\n guards: vec![Guard {\n span: SourceSpan::UNKNOWN,\n conditions: vec![Expr::BinaryExpr(BinaryExpr {\n span: SourceSpan::UNKNOWN,\n id: nid.next(),\n lhs: Box::new(var!(nid, Value)),\n op: BinaryOp::Equal,\n rhs: Box::new(int!(nid, 0.into())),\n })],\n }],\n body: vec![atom!(nid, true)],\n },\n IfClause {\n span: SourceSpan::UNKNOWN,\n id: nid.next(),\n guards: vec![Guard {\n span: SourceSpan::UNKNOWN,\n conditions: vec![var!(nid, Value)],\n }],\n body: vec![atom!(nid, false)],\n },\n IfClause {\n span: SourceSpan::UNKNOWN,\n id: nid.next(),\n guards: vec![Guard {\n span: SourceSpan::UNKNOWN,\n conditions: vec![atom!(nid, else)],\n }],\n body: vec![atom!(nid, true)],\n },\n ],\n })],\n });\n let mut body = Vec::new();\n body.push(TopLevel::Function(NamedFunction {\n span: SourceSpan::UNKNOWN,\n id: nid.next(),\n name: Name::Atom(ident!(unless)),\n arity: 1,\n clauses,\n spec: None,\n }));\n let expected = module!(&codemap, nid, ident!(foo), body);\n assert_eq!(result, expected);\n }\n\n #[test]\n fn parse_case_expressions() {\n let codemap = Arc::new(CodeMap::new());\n let config = ParseConfig::default();\n let result: Module = parse(\n config,\n codemap.clone(),\n \"-module(foo).\n\ntypeof(Value) ->\n case Value of\n [] -> nil;\n [_|_] -> list;\n N when is_number(N) -> N;\n _ -> other\n end.\n\n\",\n );\n\n let mut id_gen = NodeIdGenerator::new();\n let nid = &mut id_gen;\n\n let mut clauses = Vec::new();\n clauses.push(FunctionClause {\n span: SourceSpan::UNKNOWN,\n name: ident_opt!(typeof).map(Name::Atom),\n params: vec![var!(nid, Value)],\n guard: None,\n body: vec![Expr::Case(Case {\n span: SourceSpan::UNKNOWN,\n id: nid.next(),\n expr: Box::new(var!(nid, Value)),\n clauses: vec![\n Clause {\n span: SourceSpan::UNKNOWN,\n id: nid.next(),\n pattern: nil!(nid),\n guard: None,\n body: vec![atom!(nid, nil)],\n },\n Clause {\n span: SourceSpan::UNKNOWN,\n id: nid.next(),\n pattern: cons!(nid, var!(nid, _), var!(nid, _)),\n guard: None,\n body: vec![atom!(nid, list)],\n },\n Clause {\n span: SourceSpan::UNKNOWN,\n id: nid.next(),\n pattern: var!(nid, N),\n guard: Some(vec![Guard {\n span: SourceSpan::UNKNOWN,\n conditions: vec![apply!(nid, atom!(nid, is_number), var!(nid, N))],\n }]),\n body: vec![var!(nid, N)],\n },\n Clause {\n span: SourceSpan::UNKNOWN,\n id: nid.next(),\n pattern: var!(nid, _),\n guard: None,\n body: vec![atom!(nid, other)],\n },\n ],\n })],\n });\n let mut body = Vec::new();\n body.push(TopLevel::Function(NamedFunction {\n span: SourceSpan::UNKNOWN,\n id: nid.next(),\n name: Name::Atom(ident!(typeof)),\n arity: 1,\n clauses,\n spec: None,\n }));\n let expected = module!(&codemap, nid, ident!(foo), body);\n assert_eq!(result, expected);\n }\n\n #[test]\n fn parse_receive_expressions() {\n let codemap = Arc::new(CodeMap::new());\n let config = ParseConfig::default();\n let result: Module = parse(\n config,\n codemap.clone(),\n \"-module(foo).\n\nloop(State, Timeout) ->\n receive\n {From, {Ref, Msg}} ->\n From ! {Ref, ok},\n handle_info(Msg, State);\n _ ->\n exit(io_lib:format(\\\"unexpected message: ~p~n\\\", [Msg]))\n after\n Timeout ->\n timeout\n end.\n\",\n );\n\n let mut id_gen = NodeIdGenerator::new();\n let nid = &mut id_gen;\n\n let mut clauses = Vec::new();\n clauses.push(FunctionClause {\n span: SourceSpan::UNKNOWN,\n name: ident_opt!(loop).map(Name::Atom),\n params: vec![var!(nid, State), var!(nid, Timeout)],\n guard: None,\n body: vec![Expr::Receive(Receive {\n span: SourceSpan::UNKNOWN,\n id: nid.next(),\n clauses: Some(vec![\n Clause {\n span: SourceSpan::UNKNOWN,\n id: nid.next(),\n pattern: tuple!(\n nid,\n var!(nid, From),\n tuple!(nid, var!(nid, Ref), var!(nid, Msg))\n ),\n guard: None,\n body: vec![\n Expr::BinaryExpr(BinaryExpr {\n span: SourceSpan::UNKNOWN,\n id: nid.next(),\n lhs: Box::new(var!(nid, From)),\n op: BinaryOp::Send,\n rhs: Box::new(tuple!(nid, var!(nid, Ref), atom!(nid, ok))),\n }),\n apply!(\n nid,\n atom!(nid, handle_info),\n var!(nid, Msg),\n var!(nid, State)\n ),\n ],\n },\n Clause {\n span: SourceSpan::UNKNOWN,\n id: nid.next(),\n pattern: var!(nid, _),\n guard: None,\n body: vec![apply!(\n nid,\n atom!(nid, exit),\n apply!(\n nid,\n remote!(nid, io_lib, format),\n Expr::Literal(Literal::String(\n nid.next(),\n ident!(\"unexpected message: ~p~n\")\n )),\n cons!(nid, var!(nid, Msg), nil!(nid))\n )\n )],\n },\n ]),\n after: Some(After {\n span: SourceSpan::UNKNOWN,\n id: nid.next(),\n timeout: Box::new(var!(nid, Timeout)),\n body: vec![atom!(nid, timeout)],\n }),\n })],\n });\n let mut body = Vec::new();\n body.push(TopLevel::Function(NamedFunction {\n span: SourceSpan::UNKNOWN,\n id: nid.next(),\n name: Name::Atom(ident!(loop)),\n arity: 2,\n clauses,\n spec: None,\n }));\n let expected = module!(&codemap, nid, ident!(foo), body);\n assert_eq!(result, expected);\n }\n\n #[test]\n fn parse_preprocessor_if() {\n let codemap = Arc::new(CodeMap::new());\n let config = ParseConfig::default();\n let result: Module = parse(\n config,\n codemap.clone(),\n \"-module(foo).\n-define(TEST, true).\n-define(OTP_VERSION, 21).\n\n-ifdef(TEST).\nenv() ->\n test.\n-else.\nenv() ->\n release.\n-endif.\n\n-if(?OTP_VERSION > 21).\nsystem_version() ->\n future.\n-elif(?OTP_VERSION == 21).\nsystem_version() ->\n ?OTP_VERSION.\n-else.\nsystem_version() ->\n old.\n-endif.\n\",\n );\n\n let mut id_gen = NodeIdGenerator::new();\n let nid = &mut id_gen;\n\n let mut body = Vec::new();\n let mut clauses = Vec::new();\n clauses.push(FunctionClause {\n span: SourceSpan::UNKNOWN,\n name: ident_opt!(env).map(Name::Atom),\n params: vec![],\n guard: None,\n body: vec![atom!(nid, test)],\n });\n let env_fun = NamedFunction {\n span: SourceSpan::UNKNOWN,\n id: nid.next(),\n name: Name::Atom(ident!(env)),\n arity: 0,\n clauses,\n spec: None,\n };\n body.push(TopLevel::Function(env_fun));\n\n let mut clauses = Vec::new();\n clauses.push(FunctionClause {\n span: SourceSpan::UNKNOWN,\n name: ident_opt!(system_version).map(Name::Atom),\n params: vec![],\n guard: None,\n body: vec![int!(nid, 21.into())],\n });\n let system_version_fun = NamedFunction {\n span: SourceSpan::UNKNOWN,\n id: nid.next(),\n name: Name::Atom(ident!(system_version)),\n arity: 0,\n clauses,\n spec: None,\n };\n body.push(TopLevel::Function(system_version_fun));\n let expected = module!(&codemap, nid, ident!(foo), body);\n assert_eq!(result, expected);\n }\n\n #[test]\n fn parse_preprocessor_warning_error() {\n // NOTE: Warnings are not printed with cfg(test), as we\n // cannot control where they end up without refactoring to pass\n // a writer everywhere. You can change this for testing by\n // going to the Preprocessor and finding the line where we handle\n // the warning directive and toggle the config flag\n let codemap = Arc::new(CodeMap::default());\n let config = ParseConfig::default();\n let mut errs = parse_fail::(\n config,\n codemap.clone(),\n \"-module(foo).\n-warning(\\\"this is a compiler warning\\\").\n-error(\\\"this is a compiler error\\\").\n\",\n );\n match errs.errors.pop() {\n Some(ErrorOrWarning::Error(ParserError::Preprocessor {\n source: PreprocessorError::CompilerError { .. },\n })) => (),\n Some(err) => panic!(\n \"expected compiler error, but got a different error instead: {:?}\",\n err\n ),\n None => panic!(\"expected compiler error, but didn't get any errors!\"),\n }\n\n match errs.errors.pop() {\n Some(ErrorOrWarning::Warning(ParserError::Preprocessor {\n source: PreprocessorError::WarningDirective { .. },\n })) => (),\n Some(err) => panic!(\n \"expected warning directive, but got a different error instead: {:?}\",\n err\n ),\n None => panic!(\"expected compiler error, but didn't get any errors!\"),\n }\n }\n\n #[test]\n fn parse_try() {\n let codemap = Arc::new(CodeMap::default());\n let config = ParseConfig::default();\n let result: Module = parse(\n config,\n codemap.clone(),\n \"-module(foo).\n\nexample(File) ->\n try read(File) of\n {ok, Contents} ->\n {ok, Contents}\n catch\n error:{Mod, Code} ->\n {error, Mod:format_error(Code)};\n Reason ->\n {error, Reason}\n after\n close(File)\n end.\n\",\n );\n\n let mut id_gen = NodeIdGenerator::new();\n let nid = &mut id_gen;\n\n let mut clauses = Vec::new();\n clauses.push(FunctionClause {\n span: SourceSpan::UNKNOWN,\n name: ident_opt!(example).map(Name::Atom),\n params: vec![var!(nid, File)],\n guard: None,\n body: vec![Expr::Try(Try {\n span: SourceSpan::UNKNOWN,\n id: nid.next(),\n exprs: vec![apply!(nid, atom!(nid, read), var!(nid, File))],\n clauses: Some(vec![Clause {\n span: SourceSpan::UNKNOWN,\n id: nid.next(),\n pattern: tuple!(nid, atom!(nid, ok), var!(nid, Contents)),\n guard: None,\n body: vec![tuple!(nid, atom!(nid, ok), var!(nid, Contents))],\n }]),\n catch_clauses: Some(vec![\n TryClause {\n span: SourceSpan::UNKNOWN,\n id: nid.next(),\n kind: Name::Atom(ident!(error)),\n error: tuple!(nid, var!(nid, Mod), var!(nid, Code)),\n trace: ident!(_),\n guard: None,\n body: vec![tuple!(\n nid,\n atom!(nid, error),\n apply!(\n nid,\n remote!(nid, var!(nid, Mod), atom!(nid, format_error)),\n var!(nid, Code)\n )\n )],\n },\n TryClause {\n span: SourceSpan::UNKNOWN,\n id: nid.next(),\n kind: Name::Atom(ident!(throw)),\n error: var!(nid, Reason),\n trace: ident!(_),\n guard: None,\n body: vec![tuple!(nid, atom!(nid, error), var!(nid, Reason))],\n },\n ]),\n after: Some(vec![apply!(nid, atom!(nid, close), var!(nid, File))]),\n })],\n });\n let mut body = Vec::new();\n body.push(TopLevel::Function(NamedFunction {\n span: SourceSpan::UNKNOWN,\n id: nid.next(),\n name: Name::Atom(ident!(example)),\n arity: 1,\n clauses,\n spec: None,\n }));\n let expected = module!(&codemap, nid, ident!(foo), body);\n assert_eq!(result, expected);\n }\n\n #[test]\n fn parse_try2() {\n let codemap = Arc::new(CodeMap::default());\n let config = ParseConfig::default();\n let _result: Module = parse(\n config,\n codemap.clone(),\n \"-module(foo).\n\nexample(File < 2) ->\n try read(File) of\n {ok, Contents} ->\n {ok, Contents}\n catch\n error:{Mod, Code} ->\n {error, Mod:format_error(Code)};\n Reason ->\n {error, Reason}\n after\n close(File)\n end.\n\nexw(File) ->\n case File of\n File < 2 ->\n ok\n end.\n\",\n );\n }\n\n #[test]\n fn parse_numbers() {\n let _result: Module = parse(\n ParseConfig::default(),\n Arc::new(CodeMap::new()),\n \"-module(foo).\n\nfoo(F) -> F-1+1/1*1.\n\nbar() -> - 2.\n\",\n );\n }\n\n #[test]\n fn parse_spec() {\n let _result: Module = parse(\n ParseConfig::default(),\n Arc::new(CodeMap::new()),\n \"-module(foo).\n\n-spec bar() -> number.\nbar() -> 2.\n\",\n );\n }\n\n #[test]\n fn parse_binary_spec_constant() {\n let _result: Module = parse(\n ParseConfig::default(),\n Arc::new(CodeMap::new()),\n \"-module(foo).\n\n-type txs_hash() :: <<_:(32 * 8)>>.\n-type a() :: <<_:A * (12 * 8)>>.\n\",\n );\n }\n\n #[test]\n fn parse_multi_line_string() {\n let _result: Module = parse(\n ParseConfig::default(),\n Arc::new(CodeMap::new()),\n r#\"-module(foo).\n\n-deprecated([{woo, 0,\n\"testing testing\"\n\"testing testing\"}]).\nwoo() -> 2.\n\"#,\n );\n }\n\n #[test]\n fn parse_multi_line_record() {\n let _result: Module = parse(\n ParseConfig::default(),\n Arc::new(CodeMap::new()),\n r#\"-module(foo).\n\n-record(some_record,\n {\n woohoo\n }).\n\"#,\n );\n }\n\n #[test]\n fn parse_removed_attribute() {\n let _result: Module = parse(\n ParseConfig::default(),\n Arc::new(CodeMap::new()),\n r#\"-module(foo).\n\n-removed([{foo, 0, \"we don't support this anymore!\"}]).\n\"#,\n );\n }\n\n #[test]\n fn parse_on_load() {\n let _result: Module = parse(\n ParseConfig::default(),\n Arc::new(CodeMap::new()),\n r#\"-module(foo).\n-on_load(bar/0).\n\nbar() -> yay.\n\"#,\n );\n }\n\n #[test]\n fn parse_elixir_enum_erl() {\n use std::io::Read;\n\n let file = std::fs::File::open(\"../test_data/Elixir.Enum.erl\");\n let mut string = String::new();\n file.unwrap().read_to_string(&mut string).unwrap();\n\n let codemap = Arc::new(CodeMap::new());\n let _result: Module = parse(ParseConfig::default(), codemap, &string);\n }\n}\n" }, { "path": "libeir_syntax_erl/src/preprocessor/directive.rs", "content": "use std::fmt;\n\nuse libeir_diagnostics::SourceSpan;\n\nuse crate::lexer::{AtomToken, LexicalToken, SymbolToken, Token};\n\nuse super::Result;\n\nuse super::directives;\nuse super::token_reader::{ReadFrom, TokenReader};\n\n/// Macro directive\n#[derive(Debug, Clone)]\npub enum Directive {\n Module(directives::Module),\n Include(directives::Include),\n IncludeLib(directives::IncludeLib),\n Define(directives::Define),\n Undef(directives::Undef),\n Ifdef(directives::Ifdef),\n Ifndef(directives::Ifndef),\n If(directives::If),\n Else(directives::Else),\n Elif(directives::Elif),\n Endif(directives::Endif),\n Error(directives::Error),\n Warning(directives::Warning),\n File(directives::File),\n}\nimpl Directive {\n pub fn span(&self) -> SourceSpan {\n match *self {\n Directive::Module(ref t) => t.span(),\n Directive::Include(ref t) => t.span(),\n Directive::IncludeLib(ref t) => t.span(),\n Directive::Define(ref t) => t.span(),\n Directive::Undef(ref t) => t.span(),\n Directive::Ifdef(ref t) => t.span(),\n Directive::Ifndef(ref t) => t.span(),\n Directive::If(ref t) => t.span(),\n Directive::Else(ref t) => t.span(),\n Directive::Elif(ref t) => t.span(),\n Directive::Endif(ref t) => t.span(),\n Directive::Error(ref t) => t.span(),\n Directive::Warning(ref t) => t.span(),\n Directive::File(ref t) => t.span(),\n }\n }\n}\nimpl fmt::Display for Directive {\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n match *self {\n Directive::Module(ref t) => t.fmt(f),\n Directive::Include(ref t) => t.fmt(f),\n Directive::IncludeLib(ref t) => t.fmt(f),\n Directive::Define(ref t) => t.fmt(f),\n Directive::Undef(ref t) => t.fmt(f),\n Directive::Ifdef(ref t) => t.fmt(f),\n Directive::Ifndef(ref t) => t.fmt(f),\n Directive::If(ref t) => t.fmt(f),\n Directive::Else(ref t) => t.fmt(f),\n Directive::Elif(ref t) => t.fmt(f),\n Directive::Endif(ref t) => t.fmt(f),\n Directive::Error(ref t) => t.fmt(f),\n Directive::Warning(ref t) => t.fmt(f),\n Directive::File(ref t) => t.fmt(f),\n }\n }\n}\nimpl ReadFrom for Directive {\n fn try_read_from(reader: &mut R) -> Result>\n where\n R: TokenReader,\n {\n macro_rules! unread_token {\n ($reader:expr, $hyphen:expr, $source:expr, $tok:expr) => {{\n $reader.unread_token(LexicalToken($source.0, $tok, $source.2));\n $reader.unread_token($hyphen);\n return Ok(None);\n }};\n }\n\n let _hyphen: SymbolToken = if let Some(_hyphen) = reader.try_read_expected(&Token::Minus)? {\n _hyphen\n } else {\n return Ok(None);\n };\n\n let name: AtomToken = if let Some(name) = reader.try_read()? {\n name\n } else {\n reader.unread_token(_hyphen.into());\n return Ok(None);\n };\n\n let name_sym = name.symbol().as_str().get();\n // Replace atoms with more concrete tokens for special attributes,\n // but otherwise do nothing else with them\n match name_sym {\n \"compile\" => unread_token!(reader, _hyphen.into(), name, Token::Compile),\n \"record\" => unread_token!(reader, _hyphen.into(), name, Token::Record),\n \"spec\" => unread_token!(reader, _hyphen.into(), name, Token::Spec),\n \"callback\" => unread_token!(reader, _hyphen.into(), name, Token::Callback),\n \"optional_callback\" => {\n unread_token!(reader, _hyphen.into(), name, Token::OptionalCallback)\n }\n \"import\" => unread_token!(reader, _hyphen.into(), name, Token::Import),\n \"export\" => unread_token!(reader, _hyphen.into(), name, Token::Export),\n \"export_type\" => unread_token!(reader, _hyphen.into(), name, Token::ExportType),\n \"removed\" => unread_token!(reader, _hyphen.into(), name, Token::Removed),\n \"vsn\" => unread_token!(reader, _hyphen.into(), name, Token::Vsn),\n \"author\" => unread_token!(reader, _hyphen.into(), name, Token::Author),\n \"on_load\" => unread_token!(reader, _hyphen.into(), name, Token::OnLoad),\n \"behaviour\" => unread_token!(reader, _hyphen.into(), name, Token::Behaviour),\n \"deprecated\" => unread_token!(reader, _hyphen.into(), name, Token::Deprecated),\n \"type\" => unread_token!(reader, _hyphen.into(), name, Token::Type),\n \"opaque\" => unread_token!(reader, _hyphen.into(), name, Token::Opaque),\n _ => {\n reader.unread_token(name.clone().into());\n reader.unread_token(_hyphen.into());\n }\n }\n\n match name.symbol().as_str().get() {\n // -module(name) is treated as equivalent to -define(?MODULE, name)\n \"module\" => reader.read().map(Directive::Module).map(Some),\n // Actual preprocessor directives\n \"include\" => reader.read().map(Directive::Include).map(Some),\n \"include_lib\" => reader.read().map(Directive::IncludeLib).map(Some),\n \"define\" => reader.read().map(Directive::Define).map(Some),\n \"undef\" => reader.read().map(Directive::Undef).map(Some),\n \"ifdef\" => reader.read().map(Directive::Ifdef).map(Some),\n \"ifndef\" => reader.read().map(Directive::Ifndef).map(Some),\n \"if\" => reader.read().map(Directive::If).map(Some),\n \"else\" => reader.read().map(Directive::Else).map(Some),\n \"elif\" => reader.read().map(Directive::Elif).map(Some),\n \"endif\" => reader.read().map(Directive::Endif).map(Some),\n \"error\" => reader.read().map(Directive::Error).map(Some),\n \"warning\" => reader.read().map(Directive::Warning).map(Some),\n \"file\" => reader.read().map(Directive::File).map(Some),\n _ => Ok(None),\n }\n }\n}\n" }, { "path": "libeir_syntax_erl/src/preprocessor/directives.rs", "content": "use std::collections::VecDeque;\nuse std::fmt;\nuse std::path::{Component, PathBuf};\n\nuse snafu::{ResultExt, Snafu};\n\nuse libeir_diagnostics::{Diagnostic, Label, SourceSpan};\nuse libeir_util_parse::substitute_path_variables;\nuse libeir_util_parse::PathVariableSubstituteError;\n\nuse crate::lexer::{symbols, Lexed, LexicalToken, Symbol, Token};\nuse crate::lexer::{AtomToken, IntegerToken, StringToken, SymbolToken};\n\nuse super::token_reader::{ReadFrom, TokenReader};\nuse super::types::{MacroName, MacroVariables};\nuse super::{PreprocessorError, Result};\n\n#[derive(Debug)]\npub enum IncludeLibErrorVariant {\n NoAppNameComponent,\n NotFound {\n searched: Vec,\n },\n}\n\n#[derive(Debug, Snafu)]\npub enum DirectiveError {\n #[snafu(display(\"{}\", source))]\n PathSubstitute {\n span: SourceSpan,\n source: PathVariableSubstituteError,\n },\n\n #[snafu(display(\"could not find file\"))]\n FileNotFound {\n span: SourceSpan,\n searched: Vec,\n },\n\n #[snafu(display(\"include_lib could not find file\"))]\n IncludeLibError {\n span: SourceSpan,\n first_searched: Vec,\n second: IncludeLibErrorVariant,\n },\n}\nimpl DirectiveError {\n pub fn to_diagnostic(&self) -> Diagnostic {\n match self {\n DirectiveError::PathSubstitute { span, source } => Diagnostic::error()\n .with_message(source.to_string())\n .with_labels(vec![Label::primary(span.source_id(), *span)\n .with_message(\"in expansion of this path\")]),\n DirectiveError::FileNotFound { span, searched } => {\n let aux_msg = if searched.is_empty() {\n format!(\"attempted searching include paths, but none were specified\\n\")\n } else {\n let mut msg = format!(\"attempted searching search paths:\\n\");\n for path in searched.iter() {\n msg.push_str(path);\n msg.push('\\n');\n }\n msg\n };\n\n Diagnostic::error()\n .with_message(\"could not find file\")\n .with_labels(vec![\n Label::primary(span.source_id(), *span).with_message(\"failed to find file\")\n ])\n .with_notes(vec![aux_msg])\n }\n DirectiveError::IncludeLibError { span, first_searched, second } => {\n let aux_msg_1 = if first_searched.is_empty() {\n format!(\"first, attempted searching include paths, but none were specified\\n\")\n } else {\n let mut msg = format!(\"first, attempted searching include paths:\\n\");\n for path in first_searched.iter() {\n msg.push_str(\" - \");\n msg.push_str(path);\n msg.push('\\n');\n }\n msg\n };\n\n let aux_msg_2 = match second {\n IncludeLibErrorVariant::NoAppNameComponent => {\n format!(\"then, attempted searching codepath, but first path component wasn't an application directory!\")\n },\n IncludeLibErrorVariant::NotFound { searched } if searched.is_empty() => {\n format!(\"then, attempted searching codepath, but none were specified\\n\")\n },\n IncludeLibErrorVariant::NotFound { searched } => {\n let mut msg = format!(\"then, attempted include from codepath:\\n\");\n\n if searched.is_empty() {\n msg.push_str(\"[]\\n\");\n }\n for path in searched.iter() {\n msg.push_str(\" - \");\n msg.push_str(path);\n msg.push('\\n');\n }\n \n msg\n },\n };\n\n Diagnostic::error()\n .with_message(\"could not find file\")\n .with_labels(vec![\n Label::primary(span.source_id(), *span).with_message(\"failed to find file\")\n ])\n .with_notes(vec![aux_msg_1, aux_msg_2])\n }\n }\n }\n}\n\ntype DirectiveResult = std::result::Result;\n\n/// `module` directive.\n///\n/// Not really a directive, but we need it for the ?MODULE macro\n#[derive(Debug, Clone)]\npub struct Module {\n pub _hyphen: SymbolToken,\n pub _module: AtomToken,\n pub _open_paren: SymbolToken,\n pub name: AtomToken,\n pub _close_paren: SymbolToken,\n pub _dot: SymbolToken,\n}\nimpl Module {\n pub fn span(&self) -> SourceSpan {\n let start = self._hyphen.0;\n let end = self._dot.2;\n SourceSpan::new(start, end)\n }\n\n pub fn expand(&self) -> VecDeque {\n let mod_span = self._module.span();\n vec![\n self._hyphen.clone().into(),\n LexicalToken(mod_span.start(), Token::Module, mod_span.end()),\n self._open_paren.clone().into(),\n self.name.clone().into(),\n self._close_paren.clone().into(),\n self._dot.clone().into(),\n ]\n .into()\n }\n}\nimpl Eq for Module {}\nimpl PartialEq for Module {\n fn eq(&self, other: &Self) -> bool {\n self.name.symbol() == other.name.symbol()\n }\n}\nimpl fmt::Display for Module {\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n write!(f, \"-module({}).\", self.name.symbol())\n }\n}\nimpl ReadFrom for Module {\n fn read_from(reader: &mut R) -> Result\n where\n R: TokenReader,\n {\n Ok(Module {\n _hyphen: reader.read_expected(&Token::Minus)?,\n _module: reader.read_expected(&symbols::Module)?,\n _open_paren: reader.read_expected(&Token::LParen)?,\n name: reader.read()?,\n _close_paren: reader.read_expected(&Token::RParen)?,\n _dot: reader.read_expected(&Token::Dot)?,\n })\n }\n}\n\nfn do_include(subs_path: &PathBuf, include_paths: &VecDeque) -> std::result::Result> {\n let mut tmp_path = PathBuf::new();\n for include_path in include_paths.iter() {\n tmp_path.push(include_path);\n tmp_path.push(subs_path);\n if tmp_path.exists() {\n return Ok(tmp_path);\n }\n tmp_path.clear();\n }\n\n let searched: Vec = include_paths\n .iter()\n .map(|path| {\n path.to_str()\n .map(|v| v.to_owned())\n .unwrap_or_else(|| path.to_string_lossy().chars().collect())\n })\n .collect();\n Err(searched)\n}\n\n/// `include` directive.\n///\n/// See [9.1 File Inclusion](http://erlang.org/doc/reference_manual/macros.html#id85412)\n/// for detailed information.\n#[derive(Debug, Clone)]\npub struct Include {\n pub _hyphen: SymbolToken,\n pub _include: AtomToken,\n pub _open_paren: SymbolToken,\n pub path: StringToken,\n pub _close_paren: SymbolToken,\n pub _dot: SymbolToken,\n}\nimpl Include {\n /// Executes file inclusion.\n pub fn include(&self, include_paths: &VecDeque) -> DirectiveResult {\n let path = substitute_path_variables(self.path.symbol().as_str().get()).context(\n PathSubstitute {\n span: self.path.span(),\n },\n )?;\n\n match do_include(&path, include_paths) {\n Ok(path) => Ok(path),\n Err(searched) => Err(DirectiveError::FileNotFound {\n span: self.span(),\n searched,\n }),\n }\n }\n\n pub fn span(&self) -> SourceSpan {\n let start = self._hyphen.0;\n let end = self._dot.2;\n SourceSpan::new(start, end)\n }\n}\nimpl Eq for Include {}\nimpl PartialEq for Include {\n fn eq(&self, other: &Self) -> bool {\n self.path.symbol() == other.path.symbol()\n }\n}\nimpl fmt::Display for Include {\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n write!(f, \"-include({}).\", self.path.symbol())\n }\n}\nimpl ReadFrom for Include {\n fn read_from(reader: &mut R) -> Result\n where\n R: TokenReader,\n {\n Ok(Include {\n _hyphen: reader.read_expected(&Token::Minus)?,\n _include: reader.read_expected(&symbols::Include)?,\n _open_paren: reader.read_expected(&Token::LParen)?,\n path: reader.read()?,\n _close_paren: reader.read_expected(&Token::RParen)?,\n _dot: reader.read_expected(&Token::Dot)?,\n })\n }\n}\n\n/// `include_lib` directive.\n///\n/// See [9.1 File Inclusion](http://erlang.org/doc/reference_manual/macros.html#id85412)\n/// for detailed information.\n#[derive(Debug, Clone)]\n#[allow(missing_docs)]\npub struct IncludeLib {\n pub _hyphen: SymbolToken,\n pub _include_lib: AtomToken,\n pub _open_paren: SymbolToken,\n pub path: StringToken,\n pub _close_paren: SymbolToken,\n pub _dot: SymbolToken,\n}\nimpl IncludeLib {\n /// Executes file inclusion.\n pub fn include_lib(&self, include_paths: &VecDeque, code_paths: &VecDeque) -> DirectiveResult {\n let path = substitute_path_variables(self.path.symbol().as_str().get()).context(\n PathSubstitute {\n span: self.path.span(),\n },\n )?;\n\n let first_searched = match do_include(&path, include_paths) {\n Ok(path) => return Ok(path),\n Err(searched) => searched,\n };\n\n let mut second_searched = Vec::new();\n\n let components: Vec<_> = path.components().collect();\n if let Component::Normal(_app_name) = &components[0] {\n for root in code_paths.iter() {\n let full_path = root.join(&path);\n if full_path.exists() {\n return Ok(full_path);\n }\n\n let string = full_path.to_str()\n .map(|v| v.to_owned())\n .unwrap_or_else(|| path.to_string_lossy().chars().collect());\n second_searched.push(string);\n }\n\n Err(DirectiveError::IncludeLibError {\n span: self.span(),\n first_searched,\n second: IncludeLibErrorVariant::NotFound {\n searched: second_searched,\n },\n })\n } else {\n Err(DirectiveError::IncludeLibError {\n span: self.span(),\n first_searched,\n second: IncludeLibErrorVariant::NoAppNameComponent,\n })\n }\n }\n\n pub fn span(&self) -> SourceSpan {\n let start = self._hyphen.0;\n let end = self._dot.2;\n SourceSpan::new(start, end)\n }\n}\nimpl Eq for IncludeLib {}\nimpl PartialEq for IncludeLib {\n fn eq(&self, other: &Self) -> bool {\n self.path.symbol() == other.path.symbol()\n }\n}\nimpl fmt::Display for IncludeLib {\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n write!(f, \"-include_lib({}).\", self.path.symbol())\n }\n}\nimpl ReadFrom for IncludeLib {\n fn read_from(reader: &mut R) -> Result\n where\n R: TokenReader,\n {\n Ok(IncludeLib {\n _hyphen: reader.read_expected(&Token::Minus)?,\n _include_lib: reader.read_expected(&symbols::IncludeLib)?,\n _open_paren: reader.read_expected(&Token::LParen)?,\n path: reader.read()?,\n _close_paren: reader.read_expected(&Token::RParen)?,\n _dot: reader.read_expected(&Token::Dot)?,\n })\n }\n}\n\n/// `error` directive.\n///\n/// See [9.6 -error() and -warning() directives][error_and_warning]\n/// for detailed information.\n///\n/// [error_and_warning]: http://erlang.org/doc/reference_manual/macros.html#id85997\n#[derive(Debug, Clone)]\npub struct Error {\n pub _hyphen: SymbolToken,\n pub _error: AtomToken,\n pub _open_paren: SymbolToken,\n pub message: StringToken,\n pub _close_paren: SymbolToken,\n pub _dot: SymbolToken,\n}\nimpl Error {\n pub fn span(&self) -> SourceSpan {\n let start = self._hyphen.0;\n let end = self._dot.2;\n SourceSpan::new(start, end)\n }\n}\nimpl Eq for Error {}\nimpl PartialEq for Error {\n fn eq(&self, other: &Self) -> bool {\n self.message.symbol() == other.message.symbol()\n }\n}\nimpl fmt::Display for Error {\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n write!(f, \"-error({}).\", self.message.symbol())\n }\n}\nimpl ReadFrom for Error {\n fn read_from(reader: &mut R) -> Result\n where\n R: TokenReader,\n {\n Ok(Error {\n _hyphen: reader.read_expected(&Token::Minus)?,\n _error: reader.read_expected(&symbols::Error)?,\n _open_paren: reader.read_expected(&Token::LParen)?,\n message: reader.read()?,\n _close_paren: reader.read_expected(&Token::RParen)?,\n _dot: reader.read_expected(&Token::Dot)?,\n })\n }\n}\n\n/// `warning` directive.\n///\n/// See [9.6 -error() and -warning() directives][error_and_warning]\n/// for detailed information.\n///\n/// [error_and_warning]: http://erlang.org/doc/reference_manual/macros.html#id85997\n#[derive(Debug, Clone)]\npub struct Warning {\n pub _hyphen: SymbolToken,\n pub _warning: AtomToken,\n pub _open_paren: SymbolToken,\n pub message: StringToken,\n pub _close_paren: SymbolToken,\n pub _dot: SymbolToken,\n}\nimpl Warning {\n pub fn span(&self) -> SourceSpan {\n let start = self._hyphen.0;\n let end = self._dot.2;\n SourceSpan::new(start, end)\n }\n}\nimpl Eq for Warning {}\nimpl PartialEq for Warning {\n fn eq(&self, other: &Self) -> bool {\n self.message.symbol() == other.message.symbol()\n }\n}\nimpl fmt::Display for Warning {\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n write!(f, \"-warning({}).\", self.message.symbol())\n }\n}\nimpl ReadFrom for Warning {\n fn read_from(reader: &mut R) -> Result\n where\n R: TokenReader,\n {\n Ok(Warning {\n _hyphen: reader.read_expected(&Token::Minus)?,\n _warning: reader.read_expected(&symbols::Warning)?,\n _open_paren: reader.read_expected(&Token::LParen)?,\n message: reader.read()?,\n _close_paren: reader.read_expected(&Token::RParen)?,\n _dot: reader.read_expected(&Token::Dot)?,\n })\n }\n}\n\n/// `endif` directive.\n///\n/// See [9.5 Flow Control in Macros][flow_control] for detailed information.\n///\n/// [flow_control]: http://erlang.org/doc/reference_manual/macros.html#id85859\n#[derive(Debug, Clone)]\npub struct Endif {\n pub _hyphen: SymbolToken,\n pub _endif: AtomToken,\n pub _dot: SymbolToken,\n}\nimpl Endif {\n pub fn span(&self) -> SourceSpan {\n let start = self._hyphen.0;\n let end = self._dot.2;\n SourceSpan::new(start, end)\n }\n}\nimpl Eq for Endif {}\nimpl PartialEq for Endif {\n fn eq(&self, _other: &Self) -> bool {\n true\n }\n}\nimpl fmt::Display for Endif {\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n write!(f, \"-endif.\")\n }\n}\nimpl ReadFrom for Endif {\n fn read_from(reader: &mut R) -> Result\n where\n R: TokenReader,\n {\n Ok(Endif {\n _hyphen: reader.read_expected(&Token::Minus)?,\n _endif: reader.read_expected(&symbols::Endif)?,\n _dot: reader.read_expected(&Token::Dot)?,\n })\n }\n}\n\n/// `else` directive.\n///\n/// See [9.5 Flow Control in Macros][flow_control] for detailed information.\n///\n/// [flow_control]: http://erlang.org/doc/reference_manual/macros.html#id85859\n#[derive(Debug, Clone)]\npub struct Else {\n pub _hyphen: SymbolToken,\n pub _else: AtomToken,\n pub _dot: SymbolToken,\n}\nimpl Else {\n pub fn span(&self) -> SourceSpan {\n let start = self._hyphen.0;\n let end = self._dot.2;\n SourceSpan::new(start, end)\n }\n}\nimpl Eq for Else {}\nimpl PartialEq for Else {\n fn eq(&self, _other: &Self) -> bool {\n true\n }\n}\nimpl fmt::Display for Else {\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n write!(f, \"-else.\")\n }\n}\nimpl ReadFrom for Else {\n fn read_from(reader: &mut R) -> Result\n where\n R: TokenReader,\n {\n Ok(Else {\n _hyphen: reader.read_expected(&Token::Minus)?,\n _else: reader.read_expected(&symbols::Else)?,\n _dot: reader.read_expected(&Token::Dot)?,\n })\n }\n}\n\n/// `undef` directive.\n///\n/// See [9.5 Flow Control in Macros][flow_control] for detailed information.\n///\n/// [flow_control]: http://erlang.org/doc/reference_manual/macros.html#id85859\n#[derive(Debug, Clone)]\npub struct Undef {\n pub _hyphen: SymbolToken,\n pub _undef: AtomToken,\n pub _open_paren: SymbolToken,\n pub name: MacroName,\n pub _close_paren: SymbolToken,\n pub _dot: SymbolToken,\n}\nimpl Undef {\n pub fn span(&self) -> SourceSpan {\n let start = self._hyphen.0;\n let end = self._dot.2;\n SourceSpan::new(start, end)\n }\n pub fn name(&self) -> Symbol {\n self.name.symbol()\n }\n}\nimpl Eq for Undef {}\nimpl PartialEq for Undef {\n fn eq(&self, other: &Self) -> bool {\n self.name == other.name\n }\n}\nimpl fmt::Display for Undef {\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n write!(f, \"-undef({}).\", self.name.symbol())\n }\n}\nimpl ReadFrom for Undef {\n fn read_from(reader: &mut R) -> Result\n where\n R: TokenReader,\n {\n Ok(Undef {\n _hyphen: reader.read_expected(&Token::Minus)?,\n _undef: reader.read_expected(&symbols::Undef)?,\n _open_paren: reader.read_expected(&Token::LParen)?,\n name: reader.read()?,\n _close_paren: reader.read_expected(&Token::RParen)?,\n _dot: reader.read_expected(&Token::Dot)?,\n })\n }\n}\n\n/// `if` directive.\n///\n/// See [9.5 Flow Control in Macros][flow_control] for detailed information.\n///\n/// [flow_control]: http://erlang.org/doc/reference_manual/macros.html#id85859\n#[derive(Debug, Clone)]\npub struct If {\n pub _hyphen: SymbolToken,\n pub _if: AtomToken,\n pub _open_paren: SymbolToken,\n pub condition: VecDeque,\n pub _close_paren: SymbolToken,\n pub _dot: SymbolToken,\n}\nimpl If {\n pub fn span(&self) -> SourceSpan {\n let start = self._hyphen.0;\n let end = self._dot.2;\n SourceSpan::new(start, end)\n }\n}\nimpl Eq for If {}\nimpl PartialEq for If {\n fn eq(&self, other: &Self) -> bool {\n self.condition == other.condition\n }\n}\nimpl fmt::Display for If {\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n write!(f, \"-if({:?}).\", self.condition)\n }\n}\nimpl ReadFrom for If {\n fn read_from(reader: &mut R) -> Result\n where\n R: TokenReader,\n {\n Ok(If {\n _hyphen: reader.read_expected(&Token::Minus)?,\n _if: reader.read_expected(&symbols::If)?,\n _open_paren: reader.read_expected(&Token::LParen)?,\n condition: read_condition(reader)?,\n _close_paren: reader.read_expected(&Token::RParen)?,\n _dot: reader.read_expected(&Token::Dot)?,\n })\n }\n}\n\n/// `elif` directive.\n///\n/// See [9.5 Flow Control in Macros][flow_control] for detailed information.\n///\n/// [flow_control]: http://erlang.org/doc/reference_manual/macros.html#id85859\n#[derive(Debug, Clone)]\npub struct Elif {\n pub _hyphen: SymbolToken,\n pub _elif: AtomToken,\n pub _open_paren: SymbolToken,\n pub condition: VecDeque,\n pub _close_paren: SymbolToken,\n pub _dot: SymbolToken,\n}\nimpl Elif {\n pub fn span(&self) -> SourceSpan {\n let start = self._hyphen.0;\n let end = self._dot.2;\n SourceSpan::new(start, end)\n }\n}\nimpl Eq for Elif {}\nimpl PartialEq for Elif {\n fn eq(&self, other: &Self) -> bool {\n self.condition == other.condition\n }\n}\nimpl fmt::Display for Elif {\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n write!(f, \"-elif({:?}).\", self.condition)\n }\n}\nimpl ReadFrom for Elif {\n fn read_from(reader: &mut R) -> Result\n where\n R: TokenReader,\n {\n Ok(Elif {\n _hyphen: reader.read_expected(&Token::Minus)?,\n _elif: reader.read_expected(&symbols::Elif)?,\n _open_paren: reader.read_expected(&Token::LParen)?,\n condition: read_condition(reader)?,\n _close_paren: reader.read_expected(&Token::RParen)?,\n _dot: reader.read_expected(&Token::Dot)?,\n })\n }\n}\n\nfn read_condition(reader: &mut R) -> Result>\nwhere\n R: TokenReader,\n{\n let mut open = 0;\n let mut condition = VecDeque::new();\n\n loop {\n match reader.try_read_token()? {\n None => return Err(PreprocessorError::UnexpectedEOF),\n Some(token) => match token {\n LexicalToken(_, Token::LParen, _) => {\n open = open + 1;\n condition.push_back(Ok(token));\n }\n LexicalToken(_, Token::RParen, _) if open == 0 => {\n reader.unread_token(token);\n break;\n }\n LexicalToken(_, Token::RParen, _) => {\n open = open - 1;\n condition.push_back(Ok(token));\n }\n _ => {\n condition.push_back(Ok(token));\n }\n },\n }\n }\n\n Ok(condition)\n}\n\n/// `ifdef` directive.\n///\n/// See [9.5 Flow Control in Macros][flow_control] for detailed information.\n///\n/// [flow_control]: http://erlang.org/doc/reference_manual/macros.html#id85859\n#[derive(Debug, Clone)]\npub struct Ifdef {\n pub _hyphen: SymbolToken,\n pub _ifdef: AtomToken,\n pub _open_paren: SymbolToken,\n pub name: MacroName,\n pub _close_paren: SymbolToken,\n pub _dot: SymbolToken,\n}\nimpl Ifdef {\n pub fn span(&self) -> SourceSpan {\n let start = self._hyphen.0;\n let end = self._dot.2;\n SourceSpan::new(start, end)\n }\n pub fn name(&self) -> Symbol {\n self.name.symbol()\n }\n}\nimpl Eq for Ifdef {}\nimpl PartialEq for Ifdef {\n fn eq(&self, other: &Self) -> bool {\n self.name == other.name\n }\n}\nimpl fmt::Display for Ifdef {\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n write!(f, \"-ifdef({}).\", self.name.symbol())\n }\n}\nimpl ReadFrom for Ifdef {\n fn read_from(reader: &mut R) -> Result\n where\n R: TokenReader,\n {\n Ok(Ifdef {\n _hyphen: reader.read_expected(&Token::Minus)?,\n _ifdef: reader.read_expected(&symbols::Ifdef)?,\n _open_paren: reader.read_expected(&Token::LParen)?,\n name: reader.read()?,\n _close_paren: reader.read_expected(&Token::RParen)?,\n _dot: reader.read_expected(&Token::Dot)?,\n })\n }\n}\n\n/// `ifndef` directive.\n///\n/// See [9.5 Flow Control in Macros][flow_control] for detailed information.\n///\n/// [flow_control]: http://erlang.org/doc/reference_manual/macros.html#id85859\n#[derive(Debug, Clone)]\npub struct Ifndef {\n pub _hyphen: SymbolToken,\n pub _ifndef: AtomToken,\n pub _open_paren: SymbolToken,\n pub name: MacroName,\n pub _close_paren: SymbolToken,\n pub _dot: SymbolToken,\n}\nimpl Ifndef {\n pub fn span(&self) -> SourceSpan {\n let start = self._hyphen.0;\n let end = self._dot.2;\n SourceSpan::new(start, end)\n }\n pub fn name(&self) -> Symbol {\n self.name.symbol()\n }\n}\nimpl Eq for Ifndef {}\nimpl PartialEq for Ifndef {\n fn eq(&self, other: &Self) -> bool {\n self.name == other.name\n }\n}\nimpl fmt::Display for Ifndef {\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n write!(f, \"-ifndef({}).\", self.name.symbol())\n }\n}\nimpl ReadFrom for Ifndef {\n fn read_from(reader: &mut R) -> Result\n where\n R: TokenReader,\n {\n Ok(Ifndef {\n _hyphen: reader.read_expected(&Token::Minus)?,\n _ifndef: reader.read_expected(&symbols::Ifndef)?,\n _open_paren: reader.read_expected(&Token::LParen)?,\n name: reader.read()?,\n _close_paren: reader.read_expected(&Token::RParen)?,\n _dot: reader.read_expected(&Token::Dot)?,\n })\n }\n}\n\n/// `define` directive.\n///\n/// See [9.2 Defining and Using Macros][define_and_use] for detailed information.\n///\n/// [define_and_use]: http://erlang.org/doc/reference_manual/macros.html#id85572\n#[derive(Debug, Clone)]\npub struct Define {\n pub _hyphen: SymbolToken,\n pub _define: AtomToken,\n pub _open_paren: SymbolToken,\n pub name: MacroName,\n pub variables: Option,\n pub _comma: SymbolToken,\n pub replacement: Vec,\n pub _close_paren: SymbolToken,\n pub _dot: SymbolToken,\n}\nimpl Define {\n pub fn span(&self) -> SourceSpan {\n let start = self._hyphen.0;\n let end = self._dot.0;\n SourceSpan::new(start, end)\n }\n}\nimpl Eq for Define {}\nimpl PartialEq for Define {\n fn eq(&self, other: &Self) -> bool {\n self.name == other.name\n && self.variables == other.variables\n && self.replacement == other.replacement\n }\n}\nimpl fmt::Display for Define {\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n write!(\n f,\n \"-define({}{}, {}).\",\n self.name,\n self.variables\n .as_ref()\n .map_or(\"\".to_string(), |v| v.to_string(),),\n self.replacement\n .iter()\n .map(|t| t.to_string())\n .collect::()\n )\n }\n}\nimpl ReadFrom for Define {\n fn read_from(reader: &mut R) -> Result\n where\n R: TokenReader,\n {\n let _hyphen = reader.read_expected(&Token::Minus)?;\n let _define = reader.read_expected(&symbols::Define)?;\n let _open_paren = reader.read_expected(&Token::LParen)?;\n let name = reader.read()?;\n let variables =\n if let Some(token) = reader.try_read_expected::(&Token::LParen)? {\n reader.unread_token(token.into());\n Some(reader.read()?)\n } else {\n None\n };\n let _comma = reader.read_expected(&Token::Comma)?;\n\n let mut replacement = Vec::new();\n loop {\n if let Some(_close_paren) = reader.try_read_expected(&Token::RParen)? {\n if let Some(_dot) = reader.try_read_expected(&Token::Dot)? {\n return Ok(Define {\n _hyphen,\n _define,\n _open_paren,\n name,\n variables,\n _comma,\n replacement,\n _close_paren,\n _dot,\n });\n }\n replacement.push(_close_paren.into());\n } else {\n replacement.push(reader.read_token()?);\n //match reader.read_token()? {\n // token @ LexicalToken(_, Token::Dot, _) => {\n // println!(\"yay {:?}\", token);\n // return Err(PreprocessorError::UnexpectedToken(token, Vec::new()));\n // }\n // token => replacement.push(token),\n //}\n }\n }\n }\n}\n\n#[derive(Debug, Clone)]\npub struct File {\n pub _hyphen: SymbolToken,\n pub _file: AtomToken,\n pub _open_paren: SymbolToken,\n pub path: StringToken,\n pub _comma: SymbolToken,\n pub line: IntegerToken,\n pub _close_paren: SymbolToken,\n pub _dot: SymbolToken,\n}\nimpl File {\n pub fn span(&self) -> SourceSpan {\n let start = self._hyphen.0;\n let end = self._dot.0;\n SourceSpan::new(start, end)\n }\n}\nimpl Eq for File {}\nimpl PartialEq for File {\n fn eq(&self, other: &Self) -> bool {\n self.path.symbol() == other.path.symbol() && self.line == other.line\n }\n}\nimpl fmt::Display for File {\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n write!(f, \"-file({}, {}).\", self.path, self.line,)\n }\n}\nimpl ReadFrom for File {\n fn read_from(reader: &mut R) -> Result\n where\n R: TokenReader,\n {\n Ok(File {\n _hyphen: reader.read_expected(&Token::Minus)?,\n _file: reader.read_expected(&symbols::File)?,\n _open_paren: reader.read_expected(&Token::LParen)?,\n path: reader.read()?,\n _comma: reader.read_expected(&Token::Comma)?,\n line: reader.read()?,\n _close_paren: reader.read_expected(&Token::RParen)?,\n _dot: reader.read_expected(&Token::Dot)?,\n })\n }\n}\n" }, { "path": "libeir_syntax_erl/src/preprocessor/errors.rs", "content": "use std;\nuse std::path::PathBuf;\n\nuse itertools::Itertools;\nuse snafu::Snafu;\n\nuse libeir_diagnostics::*;\nuse libeir_intern::Symbol;\nuse libeir_util_number::FloatError;\nuse libeir_util_parse::SourceError;\n\nuse crate::lexer::{LexicalError, LexicalToken, TokenConvertError};\nuse crate::parser::ParserError;\n\nuse super::directive::Directive;\nuse super::directives::DirectiveError;\nuse super::macros::{MacroCall, MacroDef, Stringify};\n\n#[derive(Debug, Snafu)]\npub enum PreprocessorError {\n #[snafu(visibility(pub), display(\"{}\", source))]\n Lexical { source: LexicalError },\n\n #[snafu(visibility(pub), display(\"{}\", source))]\n Source { source: SourceError },\n\n #[snafu(\n visibility(pub),\n display(\"{} occurred while including {:?}\", source, path)\n )]\n IncludeError {\n source: std::io::Error,\n path: PathBuf,\n span: SourceSpan,\n },\n\n #[snafu(display(\"unable to parse constant expression\"))]\n ParseError {\n span: SourceSpan,\n inner: Box,\n },\n\n #[snafu(display(\"{}\", reason))]\n CompilerError {\n span: Option,\n reason: String,\n },\n\n #[snafu(display(\"invalid constant expression found in preprocessor directive\"))]\n InvalidConstExpression { span: SourceSpan },\n\n #[snafu(display(\"constant evaluation error\"))]\n EvalError { source: crate::evaluator::EvalError },\n\n #[snafu(visibility(pub))]\n BadDirective { source: DirectiveError },\n\n #[snafu(display(\"invalid conditional expression\"))]\n InvalidConditional { span: SourceSpan },\n\n #[snafu(visibility(pub), display(\"call to builtin function failed\"))]\n BuiltinFailed {\n span: SourceSpan,\n source: Box,\n },\n\n #[snafu(display(\"found orphaned '-end.' directive\"))]\n OrphanedEnd { directive: Directive },\n\n #[snafu(display(\"found orphaned '-else.' directive\"))]\n OrphanedElse { directive: Directive },\n\n #[snafu(display(\"undefined macro\"))]\n UndefinedStringifyMacro { call: Stringify },\n\n #[snafu(display(\"undefined macro\"))]\n UndefinedMacro { call: MacroCall },\n\n #[snafu(display(\"invalid macro invocation\"))]\n BadMacroCall {\n call: MacroCall,\n def: MacroDef,\n reason: String,\n },\n\n #[snafu(display(\"{}\", diagnostic.message))]\n ShowDiagnostic { diagnostic: Diagnostic },\n\n #[snafu(display(\"unexpected token\"))]\n InvalidTokenType {\n token: LexicalToken,\n expected: String,\n },\n\n #[snafu(display(\"unexpected token\"))]\n UnexpectedToken {\n token: LexicalToken,\n expected: Vec,\n },\n\n #[snafu(display(\"unexpected eof\"))]\n UnexpectedEOF,\n\n #[snafu(display(\"warning directive: {}\", message))]\n WarningDirective {\n span: SourceSpan,\n message: Symbol,\n as_error: bool,\n },\n}\nimpl PreprocessorError {\n pub fn to_diagnostic(&self) -> Diagnostic {\n //let span = self.span();\n //let msg = self.to_string();\n match self {\n PreprocessorError::Lexical { source } => source.to_diagnostic(),\n PreprocessorError::Source { source } => source.to_diagnostic(),\n PreprocessorError::IncludeError { span, .. } => {\n Diagnostic::error()\n .with_message(self.to_string())\n .with_labels(vec![\n Label::primary(span.source_id(), *span)\n .with_message(\"while processing include directive\"),\n ])\n },\n PreprocessorError::ParseError { span, inner } => {\n let err = inner.to_diagnostic();\n let mut labels = vec![\n Label::primary(span.source_id(), *span)\n .with_message(\"invalid constant expression\")\n ];\n for label in err.labels {\n labels.push(label);\n }\n Diagnostic::error()\n .with_message(self.to_string())\n .with_labels(labels)\n }\n PreprocessorError::CompilerError { span: Some(span), reason } =>\n Diagnostic::error()\n .with_message(\"found error directive\")\n .with_labels(vec![\n Label::primary(span.source_id(), *span)\n .with_message(reason)\n ]),\n PreprocessorError::CompilerError { span: None, reason } =>\n Diagnostic::error().with_message(reason),\n PreprocessorError::InvalidConstExpression { span, .. } =>\n Diagnostic::error()\n .with_message(self.to_string())\n .with_labels(vec![\n Label::primary(span.source_id(), *span)\n .with_message(\"expected valid constant expression (example: `?OTP_VERSION >= 21`)\")\n ]),\n PreprocessorError::EvalError { source } => source.to_diagnostic(),\n PreprocessorError::BadDirective { source } => source.to_diagnostic(),\n PreprocessorError::InvalidConditional { span, .. } =>\n Diagnostic::error()\n .with_message(self.to_string())\n .with_labels(vec![\n Label::primary(span.source_id(), *span)\n .with_message(\"expected 'true', 'false', or an expression which can be evaluated to 'true' or 'false'\")\n ]),\n PreprocessorError::BuiltinFailed { span, source } =>\n Diagnostic::error()\n .with_message(self.to_string())\n .with_labels(vec![\n Label::primary(span.source_id(), *span)\n .with_message(source.to_string())\n ]),\n PreprocessorError::OrphanedEnd { directive } => {\n let span = directive.span();\n Diagnostic::error()\n .with_message(self.to_string())\n .with_labels(vec![\n Label::primary(span.source_id(), span)\n ])\n }\n PreprocessorError::OrphanedElse { directive } => {\n let span = directive.span();\n Diagnostic::error()\n .with_message(self.to_string())\n .with_labels(vec![\n Label::primary(span.source_id(), span)\n ])\n }\n PreprocessorError::UndefinedStringifyMacro { call } => {\n let span = call.span();\n Diagnostic::error()\n .with_message(self.to_string())\n .with_labels(vec![\n Label::primary(span.source_id(), span)\n ])\n }\n PreprocessorError::UndefinedMacro { call } => {\n let span = call.span();\n Diagnostic::error()\n .with_message(self.to_string())\n .with_labels(vec![\n Label::primary(span.source_id(), span)\n ])\n }\n PreprocessorError::BadMacroCall { call, def: MacroDef::String(_), reason, .. } => {\n let span = call.span();\n Diagnostic::error()\n .with_message(self.to_string())\n .with_labels(vec![\n Label::primary(span.source_id(), span)\n .with_message(reason.to_owned())\n ])\n }\n PreprocessorError::BadMacroCall { call, def, reason, .. } => {\n let secondary_span = match def {\n MacroDef::Static(ref define) => define.span(),\n MacroDef::Dynamic(ref tokens) => {\n assert!(tokens.len() > 0);\n SourceSpan::new(\n tokens[0].span().start(),\n tokens.last().unwrap().span().end()\n )\n },\n _ => unreachable!()\n };\n let call_span = call.span();\n Diagnostic::error()\n .with_message(self.to_string())\n .with_labels(vec![\n Label::primary(call_span.source_id(), call_span)\n .with_message(\"this macro call does not match its definition\"),\n Label::secondary(secondary_span.source_id(), secondary_span)\n .with_message(reason.to_owned())\n ])\n }\n PreprocessorError::ShowDiagnostic { diagnostic } => diagnostic.clone(),\n PreprocessorError::InvalidTokenType { token, expected } => {\n let token_span = token.span();\n Diagnostic::error()\n .with_message(self.to_string())\n .with_labels(vec![\n Label::primary(token_span.source_id(), token_span)\n .with_message(format!(\"expected \\\"{}\\\"\", expected))\n ])\n }\n PreprocessorError::UnexpectedToken { token, expected } => {\n let token_span = token.span();\n if expected.len() > 0 {\n let expected = expected.iter()\n .map(|t| format!(\"\\\"{}\\\"\", t))\n .join(\", \");\n Diagnostic::error()\n .with_message(self.to_string())\n .with_labels(vec![\n Label::primary(token_span.source_id(), token_span)\n .with_message(format!(\"expected one of {}\", expected))\n ])\n } else {\n Diagnostic::error()\n .with_message(self.to_string())\n .with_labels(vec![\n Label::primary(token_span.source_id(), token_span)\n ])\n }\n }\n PreprocessorError::UnexpectedEOF =>\n Diagnostic::error().with_message(self.to_string()),\n PreprocessorError::WarningDirective { span, message, as_error } => {\n let message_str = message.as_str().get();\n if *as_error { Diagnostic::error() } else { Diagnostic::warning() }\n .with_message(\"found warning directive\")\n .with_labels(vec![\n Label::primary(span.source_id(), *span).with_message(message_str),\n ])\n }\n }\n }\n}\nimpl From for PreprocessorError {\n fn from(source: LexicalError) -> PreprocessorError {\n PreprocessorError::Lexical { source }\n }\n}\nimpl From for PreprocessorError {\n fn from(source: SourceError) -> PreprocessorError {\n PreprocessorError::Source { source }\n }\n}\nimpl From for PreprocessorError {\n fn from(err: TokenConvertError) -> PreprocessorError {\n let span = err.span;\n let token = LexicalToken(span.start(), err.token, span.end());\n PreprocessorError::InvalidTokenType {\n token,\n expected: err.expected.to_string(),\n }\n }\n}\nimpl From for PreprocessorError {\n fn from(diagnostic: Diagnostic) -> Self {\n PreprocessorError::ShowDiagnostic { diagnostic }\n }\n}\n\nimpl From for PreprocessorError {\n fn from(source: crate::evaluator::EvalError) -> Self {\n PreprocessorError::EvalError { source }\n }\n}\n" }, { "path": "libeir_syntax_erl/src/preprocessor/macros.rs", "content": "use std::collections::HashMap;\nuse std::fmt;\n\nuse libeir_diagnostics::SourceSpan;\n\nuse crate::lexer::{DelayedSubstitution, LexicalToken, Symbol, Token};\nuse crate::lexer::{IdentToken, SymbolToken};\n\nuse super::directives::Define;\nuse super::token_reader::{ReadFrom, TokenReader};\nuse super::types::{MacroArgs, MacroName};\nuse super::Result;\n\npub enum MacroIdent {\n Const(Symbol),\n Func(Symbol, usize),\n}\nimpl MacroIdent {\n pub fn ident(&self) -> Symbol {\n match self {\n MacroIdent::Const(sym) => *sym,\n MacroIdent::Func(sym, _) => *sym,\n }\n }\n\n pub fn arity(&self) -> Option {\n match self {\n MacroIdent::Const(_) => None,\n MacroIdent::Func(_, arity) => Some(*arity),\n }\n }\n}\n\nimpl From<&MacroCall> for MacroIdent {\n fn from(call: &MacroCall) -> MacroIdent {\n let ident = match &call.name {\n MacroName::Atom(tok) => tok.symbol(),\n MacroName::Variable(tok) => tok.symbol(),\n };\n\n if let Some(args) = &call.args {\n MacroIdent::Func(ident, args.len())\n } else {\n MacroIdent::Const(ident)\n }\n }\n}\n\nimpl From<&super::directives::Define> for MacroIdent {\n fn from(def: &super::directives::Define) -> MacroIdent {\n let ident = match &def.name {\n MacroName::Atom(tok) => tok.symbol(),\n MacroName::Variable(tok) => tok.symbol(),\n };\n\n if let Some(args) = &def.variables {\n MacroIdent::Func(ident, args.len())\n } else {\n MacroIdent::Const(ident)\n }\n }\n}\n\n#[derive(Debug, Clone, PartialEq, Eq)]\npub struct MacroContainer {\n func_defines: HashMap>,\n const_defines: HashMap,\n}\nimpl MacroContainer {\n pub fn new() -> Self {\n MacroContainer {\n func_defines: HashMap::new(),\n const_defines: HashMap::new(),\n }\n }\n\n pub fn insert(&mut self, key: T, def: MacroDef) -> bool\n where\n T: Into,\n {\n let key: MacroIdent = key.into();\n match key {\n MacroIdent::Const(name) => self.const_defines.insert(name, def).is_some(),\n MacroIdent::Func(name, arity) => {\n if !self.func_defines.contains_key(&name) {\n self.func_defines.insert(name, HashMap::new());\n }\n let container = self.func_defines.get_mut(&name).unwrap();\n container.insert(arity, def).is_some()\n }\n }\n }\n\n pub fn get<'a, T>(&'a self, key: T) -> Option<&'a MacroDef>\n where\n T: Into,\n {\n let key: MacroIdent = key.into();\n match key {\n MacroIdent::Const(name) => self.const_defines.get(&name),\n MacroIdent::Func(name, arity) => {\n self.func_defines.get(&name).and_then(|c| c.get(&arity))\n }\n }\n }\n\n pub fn undef(&mut self, symbol: &Symbol) -> bool {\n let mut res = false;\n res |= self.const_defines.remove(symbol).is_some();\n res |= self.func_defines.remove(symbol).is_some();\n res\n }\n\n pub fn defined(&self, symbol: &Symbol) -> bool {\n self.defined_const(symbol) || self.defined_func(symbol)\n }\n pub fn defined_const(&self, symbol: &Symbol) -> bool {\n self.const_defines.contains_key(symbol)\n }\n pub fn defined_func(&self, symbol: &Symbol) -> bool {\n self.func_defines.contains_key(symbol)\n }\n}\n\n/// Macro Definition.\n#[derive(Debug, Clone, PartialEq, Eq)]\npub enum MacroDef {\n Boolean(bool),\n String(Symbol),\n Static(Define),\n Dynamic(Vec),\n DelayedSubstitution(DelayedSubstitution),\n}\nimpl MacroDef {\n /// Returns `true` if this macro has variables, otherwise `false`.\n pub fn has_variables(&self) -> bool {\n match *self {\n MacroDef::Static(ref d) => d.variables.is_some(),\n MacroDef::Dynamic(_) => false,\n MacroDef::String(_) => false,\n MacroDef::Boolean(_) => false,\n MacroDef::DelayedSubstitution(_) => false,\n }\n }\n}\n\n/// Macro call.\n#[derive(Debug, Clone)]\npub struct MacroCall {\n pub _question: SymbolToken,\n pub name: MacroName,\n pub args: Option,\n}\nimpl MacroCall {\n pub fn span(&self) -> SourceSpan {\n let start = self._question.0;\n let end = self\n .args\n .as_ref()\n .map(|a| a.span().end())\n .unwrap_or_else(|| self.name.span().end());\n SourceSpan::new(start, end)\n }\n\n pub fn name(&self) -> Symbol {\n self.name.symbol()\n }\n}\nimpl fmt::Display for MacroCall {\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n write!(\n f,\n \"?{}{}\",\n self.name.symbol(),\n self.args.as_ref().map_or(\"\".to_string(), |a| a.to_string())\n )\n }\n}\nimpl ReadFrom for MacroCall {\n fn read_from(reader: &mut R) -> Result\n where\n R: TokenReader,\n {\n Ok(MacroCall {\n _question: reader.read_expected(&Token::Question)?,\n name: reader.read()?,\n args: reader.try_read()?,\n })\n }\n}\n\n#[derive(Debug, Clone)]\npub struct NoArgsMacroCall {\n pub _question: SymbolToken,\n pub name: MacroName,\n}\nimpl NoArgsMacroCall {\n pub fn span(&self) -> SourceSpan {\n SourceSpan::new(self._question.span().start(), self.name.span().end())\n }\n}\nimpl ReadFrom for NoArgsMacroCall {\n fn read_from(reader: &mut R) -> Result\n where\n R: TokenReader,\n {\n Ok(NoArgsMacroCall {\n _question: reader.read_expected(&Token::Question)?,\n name: reader.read()?,\n })\n }\n}\n\n#[derive(Debug, Clone)]\npub struct Stringify {\n pub _double_question: SymbolToken,\n pub name: IdentToken,\n}\nimpl Stringify {\n pub fn span(&self) -> SourceSpan {\n let start = self._double_question.0;\n let end = self.name.2;\n SourceSpan::new(start, end)\n }\n}\nimpl fmt::Display for Stringify {\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n write!(f, \"??{}\", self.name)\n }\n}\nimpl ReadFrom for Stringify {\n fn read_from(reader: &mut R) -> Result\n where\n R: TokenReader,\n {\n Ok(Stringify {\n _double_question: reader.read_expected(&Token::DoubleQuestion)?,\n name: reader.read()?,\n })\n }\n}\n" }, { "path": "libeir_syntax_erl/src/preprocessor/mod.rs", "content": "mod directive;\nmod errors;\n//mod evaluator;\nmod macros;\nmod preprocessor;\nmod token_reader;\nmod token_stream;\n\npub mod directives;\npub mod types;\n\npub use self::directive::Directive;\npub use self::errors::PreprocessorError;\npub use self::macros::{MacroCall, MacroContainer, MacroDef, MacroIdent};\npub use self::preprocessor::Preprocessor;\n\nuse libeir_diagnostics::SourceIndex;\n\nuse crate::lexer::Token;\n\n/// The result produced by the preprocessor\npub type Preprocessed = std::result::Result<(SourceIndex, Token, SourceIndex), ()>;\n\ntype Result = std::result::Result;\n" }, { "path": "libeir_syntax_erl/src/preprocessor/preprocessor.rs", "content": "use std::collections::{BTreeMap, HashMap, VecDeque};\nuse std::convert::TryFrom;\nuse std::path::PathBuf;\nuse std::sync::Arc;\n\nuse snafu::ResultExt;\n\nuse libeir_diagnostics::*;\nuse libeir_util_parse::{ErrorReceiver, ErrorReceiverTee, Source};\n\nuse crate::evaluator;\nuse crate::lexer::Lexer;\nuse crate::lexer::{symbols, DelayedSubstitution, IdentToken, Lexed, LexicalToken, Symbol, Token};\nuse crate::parser::Parser;\n\nuse super::errors;\nuse super::macros::Stringify;\nuse super::token_reader::{TokenBufferReader, TokenReader, TokenStreamReader};\nuse super::{Directive, MacroCall, MacroContainer, MacroDef, MacroIdent};\nuse super::{Preprocessed, PreprocessorError, Result as PResult};\n\ntype Errors<'a> = ErrorReceiverTee<'a, PreprocessorError, PreprocessorError>;\n\nmacro_rules! error_into {\n ($errors:expr, $result:expr) => {\n match $result {\n Ok(inner) => Ok(inner),\n Err(error) => {\n $errors.error(error.into());\n Err(())\n }\n }\n };\n}\n\npub struct Preprocessor<'a, Reader: TokenReader> {\n errors: Errors<'a>,\n codemap: Arc,\n reader: Reader,\n can_directive_start: bool,\n directives: BTreeMap,\n code_paths: VecDeque,\n include_paths: VecDeque,\n branches: Vec,\n macros: MacroContainer,\n macro_calls: BTreeMap,\n expanded_tokens: VecDeque,\n warnings_as_errors: bool,\n no_warn: bool,\n}\nimpl<'a, S> Preprocessor<'a, TokenStreamReader>\nwhere\n S: Source,\n{\n pub fn new(parser: &Parser, tokens: Lexer, errors: Errors<'a>) -> Self {\n let reader = TokenStreamReader::new(parser.codemap.clone(), tokens);\n let code_paths = parser.config.code_paths.clone();\n let include_paths = parser.config.include_paths.clone();\n\n let mut macros = match parser.config.macros {\n None => MacroContainer::new(),\n Some(ref macros) => macros.clone(),\n };\n macros.insert(\n MacroIdent::Const(Symbol::intern(\"FUNCTION_NAME\")),\n MacroDef::DelayedSubstitution(DelayedSubstitution::FunctionName),\n );\n macros.insert(\n MacroIdent::Const(Symbol::intern(\"FUNCTION_ARITY\")),\n MacroDef::DelayedSubstitution(DelayedSubstitution::FunctionArity),\n );\n\n Preprocessor {\n errors,\n codemap: parser.codemap.clone(),\n reader,\n can_directive_start: true,\n directives: BTreeMap::new(),\n code_paths,\n include_paths,\n branches: Vec::new(),\n macros,\n macro_calls: BTreeMap::new(),\n expanded_tokens: VecDeque::new(),\n warnings_as_errors: parser.config.warnings_as_errors,\n no_warn: parser.config.no_warn,\n }\n }\n}\nimpl<'a, R, S> Preprocessor<'a, R>\nwhere\n R: TokenReader,\n{\n fn clone_with(&self, tokens: VecDeque) -> Preprocessor {\n let codemap = self.codemap.clone();\n let reader = TokenBufferReader::new(codemap.clone(), tokens);\n Preprocessor {\n errors: self.errors.clone(),\n codemap,\n reader,\n can_directive_start: false,\n directives: BTreeMap::new(),\n code_paths: self.code_paths.clone(),\n include_paths: self.include_paths.clone(),\n branches: Vec::new(),\n macros: self.macros.clone(),\n macro_calls: BTreeMap::new(),\n expanded_tokens: VecDeque::new(),\n warnings_as_errors: self.warnings_as_errors,\n no_warn: self.no_warn,\n }\n }\n\n fn ignore(&self) -> bool {\n self.branches.iter().any(|b| !b.entered)\n }\n\n fn next_token(&mut self) -> Result, ()> {\n loop {\n if let Some(token) = self.expanded_tokens.pop_front() {\n return Ok(Some(token));\n }\n if self.can_directive_start {\n match self.try_read_directive()? {\n Some(Directive::Module(d)) => {\n // We need to expand this directive back to a token stream for the parser\n self.expanded_tokens = d.expand();\n // Otherwise treat it like other directives\n self.directives\n .insert(d.span().start(), Directive::Module(d));\n continue;\n }\n Some(d) => {\n self.directives.insert(d.span().start(), d);\n continue;\n }\n None => (),\n }\n }\n if !self.ignore() {\n if let Some(m) =\n error_into!(self.errors, self.reader.try_read_macro_call(&self.macros))?\n {\n self.macro_calls.insert(m.span().start(), m.clone());\n self.expanded_tokens = error_into!(self.errors, self.expand_macro(m))?;\n continue;\n }\n }\n if let Some(token) = error_into!(self.errors, self.reader.try_read_token())? {\n if self.ignore() {\n continue;\n }\n if let LexicalToken(_, Token::Dot, _) = token {\n self.can_directive_start = true;\n } else {\n self.can_directive_start = false;\n }\n return Ok(Some(token));\n } else {\n break;\n }\n }\n Ok(None)\n }\n\n fn expand_macro(&self, call: MacroCall) -> PResult> {\n if let Some(expanded) = self.try_expand_predefined_macro(&call)? {\n Ok(vec![expanded].into())\n } else {\n self.expand_userdefined_macro(call)\n }\n }\n\n fn try_expand_predefined_macro(&self, call: &MacroCall) -> PResult> {\n let expanded = match call.name().as_str().get() {\n \"FILE\" => {\n let span = call.span();\n let source_id = span.source_id();\n let current = span.start();\n let file = self.codemap.get(source_id).unwrap();\n let filename = file.name().to_string();\n LexicalToken(\n current,\n Token::String(Symbol::intern(&filename)),\n span.end(),\n )\n }\n \"LINE\" => {\n let span = call.span();\n let source_id = span.source_id();\n let current = span.start();\n let file = self.codemap.get(source_id).unwrap();\n let line = file.line_index(current.index()).to_usize() as i64;\n LexicalToken(current, Token::Integer(line.into()), span.end())\n }\n \"MACHINE\" => {\n let span = call.span();\n let current = span.start();\n LexicalToken(current, Token::Atom(Symbol::intern(\"Lumen\")), span.end())\n }\n _ => return Ok(None),\n };\n Ok(Some(expanded))\n }\n\n fn expand_userdefined_macro(&self, call: MacroCall) -> PResult> {\n let span = call.span();\n let definition = match self.macros.get(&call) {\n None => return Err(PreprocessorError::UndefinedMacro { call }),\n Some(def) => def,\n };\n match definition {\n MacroDef::Dynamic(replacement) => {\n let mut replacement = replacement.clone();\n for token in replacement.iter_mut() {\n token.0 = span.start();\n token.2 = span.end();\n }\n Ok(replacement.into())\n },\n MacroDef::String(s) => Ok(vec![LexicalToken(\n span.start(),\n Token::String(s.clone()),\n span.end(),\n )]\n .into()),\n MacroDef::Boolean(true) => Ok(vec![LexicalToken(\n span.start(),\n Token::Atom(symbols::True),\n span.end(),\n )]\n .into()),\n MacroDef::Boolean(false) => Ok(VecDeque::new()),\n MacroDef::Static(def) => {\n let arity = def.variables.as_ref().map(|v| v.len()).unwrap_or(0);\n let argc = call.args.as_ref().map(|a| a.len()).unwrap_or(0);\n if arity != argc {\n let err = format!(\n \"expected {} arguments at call site, but given {}\",\n arity, argc\n );\n return Err(PreprocessorError::BadMacroCall {\n call,\n def: definition.clone(),\n reason: err,\n });\n }\n let bindings = def\n .variables\n .as_ref()\n .iter()\n .flat_map(|i| i.iter().map(|v| v.symbol()))\n .zip(\n call.args\n .iter()\n .flat_map(|i| i.iter().map(|a| &a.tokens[..])),\n )\n .collect::>();\n let mut expanded = self.expand_replacement(bindings, &def.replacement)?;\n for token in expanded.iter_mut() {\n token.0 = span.start();\n token.2 = span.end();\n }\n Ok(expanded)\n }\n MacroDef::DelayedSubstitution(subst) => Ok(vec![LexicalToken(\n span.start(),\n Token::DelayedSubstitution(*subst),\n span.end(),\n )]\n .into()),\n }\n }\n\n fn expand_replacement(\n &self,\n bindings: HashMap,\n replacement: &[LexicalToken],\n ) -> PResult> {\n let mut expanded = VecDeque::new();\n let replacement_tokens: VecDeque<_> = replacement.iter().map(|t| Ok(t.clone())).collect();\n let mut reader = TokenBufferReader::new(self.codemap.clone(), replacement_tokens);\n\n loop {\n if let Some(call) = reader.try_read_macro_call(&self.macros)? {\n let nested = self.expand_macro(call)?;\n for token in nested.into_iter().rev() {\n reader.unread_token(token);\n }\n } else if let Some(stringify) = reader.try_read::()? {\n let tokens = match bindings.get(&stringify.name.symbol()) {\n None => {\n return Err(PreprocessorError::UndefinedStringifyMacro { call: stringify })\n }\n Some(tokens) => tokens,\n };\n let string = tokens.iter().map(|t| t.to_string()).collect::();\n let span = tokens[0].span();\n let start = span.start();\n let end = span.end();\n let token = (start, Token::String(Symbol::intern(&string)), end);\n expanded.push_back(token.into());\n } else if let Some(token) = reader.try_read_token()? {\n match IdentToken::try_from(token.clone()) {\n Ok(ident) => match bindings.get(&ident.symbol()) {\n Some(value) => {\n let nested = self.expand_replacement(HashMap::new(), value)?;\n expanded.extend(nested);\n continue;\n }\n None => (),\n },\n Err(_) => (),\n }\n expanded.push_back(token);\n } else {\n break;\n }\n }\n Ok(expanded)\n }\n\n fn try_read_directive(&mut self) -> Result, ()> {\n let directive: Directive =\n if let Some(directive) = error_into!(self.errors, self.reader.try_read())? {\n directive\n } else {\n return Ok(None);\n };\n\n let ignore = self.ignore();\n match directive {\n Directive::Module(ref d) => {\n self.macros.insert(\n MacroIdent::Const(symbols::ModuleCapital),\n MacroDef::String(d.name.symbol()),\n );\n self.macros.insert(\n MacroIdent::Const(symbols::ModuleStringCapital),\n MacroDef::String(d.name.symbol()),\n );\n }\n Directive::Include(ref d) if !ignore => {\n let path = error_into!(\n self.errors,\n d.include(&self.include_paths).context(errors::BadDirective)\n )?;\n error_into!(self.errors, self.reader.inject_include(path, d.span()))?;\n }\n Directive::IncludeLib(ref d) if !ignore => {\n let path = error_into!(\n self.errors,\n d.include_lib(&self.include_paths, &self.code_paths)\n .context(errors::BadDirective)\n )?;\n error_into!(self.errors, self.reader.inject_include(path, d.span()))?;\n }\n Directive::Define(ref d) if !ignore => {\n self.macros.insert(d, MacroDef::Static(d.clone()));\n }\n Directive::Undef(ref d) if !ignore => {\n self.macros.undef(&d.name());\n }\n Directive::Ifdef(ref d) => {\n let entered = self.macros.defined(&d.name());\n self.branches.push(Branch::new(entered));\n }\n Directive::If(ref d) => {\n let entered = self.eval_conditional(d.span(), d.condition.clone())?;\n self.branches.push(Branch::new(entered));\n }\n Directive::Ifndef(ref d) => {\n let entered = !self.macros.defined(&d.name());\n self.branches.push(Branch::new(entered));\n }\n Directive::Else(_) => match self.branches.last_mut() {\n None => {\n return error_into!(\n self.errors,\n Err(PreprocessorError::OrphanedElse { directive })\n )\n }\n Some(branch) => {\n match branch.switch_to_else_branch() {\n Err(_) => {\n return error_into!(\n self.errors,\n Err(PreprocessorError::OrphanedElse { directive })\n )\n }\n Ok(_) => (),\n };\n }\n },\n Directive::Elif(ref d) => {\n // Treat this like -endif followed by -if(Cond)\n match self.branches.pop() {\n None => {\n return error_into!(\n self.errors,\n Err(PreprocessorError::OrphanedElse { directive })\n )\n }\n Some(_) => {\n let entered = self.eval_conditional(d.span(), d.condition.clone())?;\n self.branches.push(Branch::new(entered));\n }\n }\n }\n Directive::Endif(_) => match self.branches.pop() {\n None => {\n return error_into!(\n self.errors,\n Err(PreprocessorError::OrphanedEnd { directive })\n )\n }\n Some(_) => (),\n },\n Directive::Error(ref d) if !ignore => {\n let span = d.span();\n let err = d.message.symbol().as_str().get().to_string();\n return error_into!(\n self.errors,\n Err(PreprocessorError::CompilerError {\n span: Some(span),\n reason: err\n })\n );\n }\n Directive::Warning(ref d) if !ignore => {\n if self.no_warn {\n return Ok(Some(directive));\n }\n\n if self.warnings_as_errors {\n let err = PreprocessorError::WarningDirective {\n span: d.span(),\n message: d.message.symbol(),\n as_error: true,\n };\n return error_into!(self.errors, Err(err));\n } else {\n let err = PreprocessorError::WarningDirective {\n span: d.span(),\n message: d.message.symbol(),\n as_error: false,\n };\n self.errors.warning(err);\n }\n }\n Directive::File(ref f) if !ignore => {\n // TODO\n println!(\"TODO file directive {}\", f);\n }\n _ => {}\n }\n Ok(Some(directive))\n }\n\n fn eval_conditional(\n &mut self,\n span: SourceSpan,\n condition: VecDeque,\n ) -> Result {\n use crate::lexer::Ident;\n use crate::parser::ast::{Expr, Literal};\n use crate::parser::Parse;\n\n let result = {\n let mut adapter = self.errors.make_adapter(\n move |v| PreprocessorError::ParseError {\n span,\n inner: Box::new(v),\n },\n move |v| PreprocessorError::ParseError {\n span,\n inner: Box::new(v),\n },\n );\n let pp = self.clone_with(condition);\n // TODO add adapter which adds PreprocessorError between\n //let adapter = ErrorReceiverAdapter::new(\n // &mut self.errors,\n //);\n Expr::parse_tokens(&mut adapter, pp)\n };\n match evaluator::eval_expr(&result?, None) {\n Ok(evaluator::Term::Atom(atom)) if atom == symbols::True => Ok(true),\n Ok(evaluator::Term::Atom(atom)) if atom == symbols::False => Ok(false),\n Err(err) => {\n self.errors.error(err.into());\n return Err(());\n }\n _other => {\n self.errors\n .error(PreprocessorError::InvalidConditional { span }.into());\n return Err(());\n }\n }\n }\n}\n\nimpl<'a, R, S> Iterator for Preprocessor<'a, R>\nwhere\n R: TokenReader,\n{\n type Item = Preprocessed;\n\n fn next(&mut self) -> Option {\n match self.next_token() {\n Err(()) => Some(Err(())),\n Ok(None) => None,\n Ok(Some(token)) => Some(Ok(token.into())),\n }\n }\n}\n\n#[derive(Debug)]\nstruct Branch {\n pub then_branch: bool,\n pub entered: bool,\n}\nimpl Branch {\n pub fn new(entered: bool) -> Self {\n Branch {\n then_branch: true,\n entered,\n }\n }\n pub fn switch_to_else_branch(&mut self) -> Result<(), ()> {\n if !self.then_branch {\n return Err(());\n }\n self.then_branch = false;\n self.entered = !self.entered;\n Ok(())\n }\n}\n" }, { "path": "libeir_syntax_erl/src/preprocessor/token_reader.rs", "content": "use std::collections::VecDeque;\nuse std::convert::TryFrom;\nuse std::fmt::Display;\nuse std::fs;\nuse std::path::Path;\nuse std::sync::Arc;\n\nuse snafu::ResultExt;\n\nuse libeir_diagnostics::{CodeMap, SourceSpan};\nuse libeir_util_parse::{FileMapSource, Scanner, Source};\n\nuse crate::lexer::{AtomToken, SymbolToken, TokenConvertError};\nuse crate::lexer::{Lexed, Lexer, LexicalToken, Symbol, Token};\n\nuse super::errors;\nuse super::macros::NoArgsMacroCall;\nuse super::token_stream::TokenStream;\nuse super::{MacroCall, MacroContainer, PreprocessorError, Result};\n\npub trait TokenReader: Sized {\n type Source;\n\n fn new(codemap: Arc, tokens: Self::Source) -> Self;\n\n fn inject_include

(&mut self, path: P, directive: SourceSpan) -> Result<()>\n where\n P: AsRef;\n\n fn read(&mut self) -> Result {\n V::read_from(self)\n }\n\n fn try_read(&mut self) -> Result> {\n V::try_read_from(self)\n }\n\n fn try_read_macro_call(&mut self, macros: &MacroContainer) -> Result> {\n if let Some(call) = self.try_read::()? {\n let span = call.span();\n let start = span.start();\n let mut call = MacroCall {\n _question: SymbolToken(start, Token::Question, start),\n name: call.name,\n args: None,\n };\n\n // The logic for macro resolve/execution is as follows, in order:\n // 1. If there is only a constant macro of the given name and not\n // a function macro, apply the const without looking ahead.\n // 2. If there exists a function macro with the given name, and\n // there is a paren open following the macro identifier, then\n // try to resolve and execute the macro. If there is not a\n // function macro of the correct arity defined, error.\n // 3. If there is a constant macro, apply that.\n // 4. Error.\n\n // If there is a function macro defined with the name...\n if macros.defined_func(&call.name()) {\n let paren_ahead = if let Some(lex_tok) = self.try_read_token()? {\n let res = if let LexicalToken(_, Token::LParen, _) = lex_tok {\n true\n } else {\n false\n };\n self.unread_token(lex_tok);\n res\n } else {\n false\n };\n\n // If there is a following LParen, read arguments\n if paren_ahead {\n call.args = Some(self.read()?);\n }\n }\n\n Ok(Some(call))\n } else {\n Ok(None)\n }\n }\n\n fn read_expected(&mut self, expected: &V::Value) -> Result\n where\n V: ReadFrom + Expect + Into,\n {\n V::read_expected(self, expected)\n }\n\n fn try_read_expected(&mut self, expected: &V::Value) -> Result>\n where\n V: ReadFrom + Expect + Into,\n {\n V::try_read_expected(self, expected)\n }\n\n fn try_read_token(&mut self) -> Result>;\n\n fn read_token(&mut self) -> Result;\n\n fn unread_token(&mut self, token: LexicalToken);\n}\n\n/// Reads tokens from an in-memory buffer (VecDeque)\npub struct TokenBufferReader {\n codemap: Arc,\n tokens: VecDeque,\n unread: VecDeque,\n}\nimpl TokenReader for TokenBufferReader {\n type Source = VecDeque;\n\n fn new(codemap: Arc, tokens: Self::Source) -> Self {\n TokenBufferReader {\n codemap: codemap.clone(),\n tokens,\n unread: VecDeque::new(),\n }\n }\n\n // Adds tokens from the provided path\n fn inject_include

(&mut self, path: P, directive: SourceSpan) -> Result<()>\n where\n P: AsRef,\n {\n let path = path.as_ref();\n let content = std::fs::read_to_string(path).context(errors::IncludeError {\n path: path.to_owned(),\n span: directive,\n })?;\n let id = self.codemap.add(path, content);\n let file = self.codemap.get(id).unwrap();\n let source = FileMapSource::new(file);\n let scanner = Scanner::new(source);\n let lexer = Lexer::new(scanner);\n let mut tokens: VecDeque = lexer.collect();\n tokens.append(&mut self.tokens);\n self.tokens = tokens;\n Ok(())\n }\n\n fn try_read_token(&mut self) -> Result> {\n if let Some(token) = self.unread.pop_front() {\n return Ok(Some(token));\n }\n self.tokens.pop_front().transpose().context(errors::Lexical)\n }\n\n fn read_token(&mut self) -> Result {\n if let Some(token) = self.try_read_token()? {\n Ok(token)\n } else {\n Err(PreprocessorError::UnexpectedEOF)\n }\n }\n\n fn unread_token(&mut self, token: LexicalToken) {\n self.unread.push_front(token);\n }\n}\n\n/// Reads tokens from a TokenStream (backed by a Lexer)\npub struct TokenStreamReader {\n codemap: Arc,\n tokens: TokenStream,\n unread: VecDeque,\n}\nimpl TokenReader for TokenStreamReader\nwhere\n S: Source,\n{\n type Source = Lexer;\n\n fn new(codemap: Arc, tokens: Self::Source) -> Self {\n TokenStreamReader {\n codemap: codemap.clone(),\n tokens: TokenStream::new(tokens),\n unread: VecDeque::new(),\n }\n }\n\n // Adds tokens from the provided path\n fn inject_include

(&mut self, path: P, directive: SourceSpan) -> Result<()>\n where\n P: AsRef,\n {\n let path = path.as_ref();\n let content = fs::read_to_string(path).context(errors::IncludeError {\n path: path.to_owned(),\n span: directive,\n })?;\n let id = self.codemap.add_child(path, content, directive);\n let file = self.codemap.get(id).unwrap();\n let source = Source::new(file);\n let scanner = Scanner::new(source);\n let lexer = Lexer::new(scanner);\n self.tokens.include(lexer);\n Ok(())\n }\n\n fn try_read_token(&mut self) -> Result> {\n if let Some(token) = self.unread.pop_front() {\n return Ok(Some(token));\n }\n self.tokens.next().transpose().context(errors::Lexical)\n }\n\n fn read_token(&mut self) -> Result {\n if let Some(token) = self.try_read_token()? {\n Ok(token)\n } else {\n Err(PreprocessorError::UnexpectedEOF)\n }\n }\n\n fn unread_token(&mut self, token: LexicalToken) {\n self.unread.push_front(token);\n }\n}\n\npub trait ReadFrom: Sized {\n fn read_from(reader: &mut R) -> Result\n where\n R: TokenReader,\n {\n let directive = Self::try_read_from(reader)?;\n Ok(directive.unwrap())\n }\n\n fn try_read_from(reader: &mut R) -> Result>\n where\n R: TokenReader,\n {\n Self::read_from(reader).map(Some).or_else(|e| match e {\n PreprocessorError::UnexpectedToken { token, .. } => {\n reader.unread_token(token.clone());\n return Ok(None);\n }\n PreprocessorError::InvalidTokenType { token, .. } => {\n reader.unread_token(token.clone());\n return Ok(None);\n }\n PreprocessorError::UnexpectedEOF => {\n return Ok(None);\n }\n _ => Err(e),\n })\n }\n\n fn read_expected(reader: &mut R, expected: &Self::Value) -> Result\n where\n R: TokenReader,\n Self: Expect + Into,\n {\n Self::read_from(reader)\n .map_err(|err| match err {\n PreprocessorError::UnexpectedToken { token, .. } => {\n PreprocessorError::UnexpectedToken {\n token,\n expected: vec![expected.to_string()],\n }\n }\n PreprocessorError::InvalidTokenType { token, .. } => {\n PreprocessorError::InvalidTokenType {\n token,\n expected: expected.to_string(),\n }\n }\n _ => err,\n })\n .and_then(|token| {\n if token.expect(expected) {\n Ok(token)\n } else {\n Err(PreprocessorError::UnexpectedToken {\n token: token.into(),\n expected: vec![expected.to_string()],\n })\n }\n })\n }\n\n fn try_read_expected(reader: &mut R, expected: &Self::Value) -> Result>\n where\n R: TokenReader,\n Self: Expect + Into,\n {\n Self::try_read_from(reader).map(|token| {\n token.and_then(|token| {\n if token.expect(expected) {\n Some(token)\n } else {\n reader.unread_token(token.into());\n None\n }\n })\n })\n }\n}\n\n/// Default implementation for all TryFrom supporting types\nimpl ReadFrom for T\nwhere\n T: TryFrom,\n{\n fn read_from(reader: &mut R) -> Result\n where\n R: TokenReader,\n {\n let token = reader.read_token()?;\n Self::try_from(token).map_err(PreprocessorError::from)\n }\n}\n\npub trait Expect {\n type Value: PartialEq + Display + ?Sized;\n\n fn expect(&self, expected: &Self::Value) -> bool;\n}\n\nimpl Expect for AtomToken {\n type Value = Symbol;\n\n fn expect(&self, expected: &Self::Value) -> bool {\n self.symbol() == *expected\n }\n}\n\nimpl Expect for SymbolToken {\n type Value = Token;\n\n fn expect(&self, expected: &Self::Value) -> bool {\n expected.eq(&self.token())\n }\n}\n" }, { "path": "libeir_syntax_erl/src/preprocessor/token_stream.rs", "content": "use std::collections::VecDeque;\n\nuse crate::lexer::{Lexed, Lexer};\nuse libeir_util_parse::Source;\n\npub struct TokenStream {\n eof: bool,\n current: Lexer,\n streams: VecDeque>,\n}\nimpl TokenStream\nwhere\n S: Source,\n{\n pub fn new(current: Lexer) -> Self {\n TokenStream {\n eof: false,\n current,\n streams: VecDeque::new(),\n }\n }\n\n pub fn include(&mut self, next: Lexer) {\n if self.eof {\n self.eof = false;\n }\n let previous = std::mem::replace::>(&mut self.current, next);\n self.streams.push_front(previous);\n }\n}\nimpl Iterator for TokenStream\nwhere\n S: Source,\n{\n type Item = Lexed;\n\n fn next(&mut self) -> Option {\n if self.eof == true {\n return None;\n }\n if let Some(next) = self.current.next() {\n return Some(next);\n }\n match self.streams.pop_front() {\n None => {\n self.eof = true;\n return None;\n }\n Some(next) => {\n self.current = next;\n return self.next();\n }\n }\n }\n}\n" }, { "path": "libeir_syntax_erl/src/preprocessor/types.rs", "content": "use std::fmt;\nuse std::hash::{Hash, Hasher};\nuse std::mem;\n\nuse libeir_diagnostics::SourceSpan;\n\nuse crate::lexer::{AtomToken, IdentToken, SymbolToken};\nuse crate::lexer::{LexicalToken, Symbol, Token};\n\nuse super::token_reader::{ReadFrom, TokenReader};\nuse super::{PreprocessorError, Result};\n\n/// The list of tokens that can be used as a macro name.\n#[derive(Debug, Clone)]\npub enum MacroName {\n Atom(AtomToken),\n Variable(IdentToken),\n}\nimpl MacroName {\n /// Returns the value of this token.\n pub fn value(&self) -> Token {\n match *self {\n MacroName::Atom(ref token) => token.token(),\n MacroName::Variable(ref token) => token.token(),\n }\n }\n\n /// Returns the original textual representation of this token.\n pub fn symbol(&self) -> Symbol {\n match *self {\n MacroName::Atom(ref token) => token.symbol(),\n MacroName::Variable(ref token) => token.symbol(),\n }\n }\n\n pub fn span(&self) -> SourceSpan {\n match *self {\n MacroName::Atom(ref token) => token.span(),\n MacroName::Variable(ref token) => token.span(),\n }\n }\n}\nimpl Eq for MacroName {}\nimpl PartialEq for MacroName {\n fn eq(&self, other: &Self) -> bool {\n self.value() == other.value()\n }\n}\nimpl Hash for MacroName {\n fn hash(&self, hasher: &mut H) {\n self.value().hash(hasher);\n }\n}\nimpl fmt::Display for MacroName {\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n write!(f, \"{}\", self.symbol())\n }\n}\nimpl ReadFrom for MacroName {\n fn read_from(reader: &mut R) -> Result\n where\n R: TokenReader,\n {\n if let Some(token) = reader.try_read()? {\n Ok(MacroName::Atom(token))\n } else {\n let token = reader.read()?;\n Ok(MacroName::Variable(token))\n }\n }\n}\n\n#[derive(Debug, Clone)]\npub struct MacroVariables {\n pub _open_paren: SymbolToken,\n pub list: List,\n pub _close_paren: SymbolToken,\n}\nimpl MacroVariables {\n /// Returns an iterator which iterates over this variables.\n pub fn iter(&self) -> ListIter {\n self.list.iter()\n }\n\n /// Returns the number of this variables.\n pub fn len(&self) -> usize {\n self.list.iter().count()\n }\n\n /// Returns `true` if there are no variables.\n pub fn is_empty(&self) -> bool {\n self.len() == 0\n }\n\n pub fn span(&self) -> SourceSpan {\n SourceSpan::new(self._open_paren.0, self._close_paren.2)\n }\n}\nimpl Eq for MacroVariables {}\nimpl PartialEq for MacroVariables {\n fn eq(&self, other: &Self) -> bool {\n self.list.eq(&other.list)\n }\n}\nimpl fmt::Display for MacroVariables {\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n write!(f, \"({})\", self.list)\n }\n}\nimpl ReadFrom for MacroVariables {\n fn read_from(reader: &mut R) -> Result\n where\n R: TokenReader,\n {\n Ok(MacroVariables {\n _open_paren: reader.read_expected(&Token::LParen)?,\n list: reader.read()?,\n _close_paren: reader.read_expected(&Token::RParen)?,\n })\n }\n}\n\n/// Macro arguments.\n#[derive(Debug, Clone)]\npub struct MacroArgs {\n pub _open_paren: SymbolToken,\n pub list: List,\n pub _close_paren: SymbolToken,\n}\nimpl MacroArgs {\n /// Returns an iterator which iterates over this arguments.\n pub fn iter(&self) -> ListIter {\n self.list.iter()\n }\n\n /// Returns the number of this arguments.\n pub fn len(&self) -> usize {\n self.list.iter().count()\n }\n\n /// Returns `true` if there are no arguments.\n pub fn is_empty(&self) -> bool {\n self.len() == 0\n }\n\n pub fn span(&self) -> SourceSpan {\n SourceSpan::new(self._open_paren.0, self._close_paren.2)\n }\n}\nimpl Eq for MacroArgs {}\nimpl PartialEq for MacroArgs {\n fn eq(&self, other: &Self) -> bool {\n self.list.eq(&other.list)\n }\n}\nimpl fmt::Display for MacroArgs {\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n write!(f, \"({})\", self.list)\n }\n}\nimpl ReadFrom for MacroArgs {\n fn read_from(reader: &mut R) -> Result\n where\n R: TokenReader,\n {\n Ok(MacroArgs {\n _open_paren: reader.read_expected(&Token::LParen)?,\n list: reader.read()?,\n _close_paren: reader.read_expected(&Token::RParen)?,\n })\n }\n}\n\n/// Macro argument.\n#[derive(Debug, Clone, PartialEq, Eq)]\npub struct MacroArg {\n /// Tokens which represent a macro argument.\n ///\n /// Note that this must not be empty.\n pub tokens: Vec,\n}\nimpl MacroArg {\n pub fn span(&self) -> SourceSpan {\n let start = self.tokens.first().unwrap().span().start();\n let end = self.tokens.last().unwrap().span().end();\n SourceSpan::new(start, end)\n }\n}\nimpl fmt::Display for MacroArg {\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n for t in &self.tokens {\n write!(f, \"{}\", t)?;\n }\n Ok(())\n }\n}\nimpl ReadFrom for MacroArg {\n fn try_read_from(reader: &mut R) -> Result>\n where\n R: TokenReader,\n {\n let mut stack = Vec::new();\n let mut arg = Vec::new();\n while let Some(ref token @ LexicalToken(_, _, _)) = reader.try_read_token()? {\n match token.1 {\n Token::RParen if stack.is_empty() => {\n reader.unread_token(token.clone().into());\n return if arg.is_empty() {\n Ok(None)\n } else {\n Ok(Some(MacroArg { tokens: arg }))\n };\n }\n Token::RBrace | Token::RBracket | Token::BinaryEnd if stack.is_empty() => {\n return Err(PreprocessorError::UnexpectedToken {\n token: token.clone(),\n expected: vec![Token::RParen.to_string()],\n });\n }\n Token::Comma if stack.is_empty() => {\n if arg.len() == 0 {\n return Err(PreprocessorError::UnexpectedToken {\n token: token.clone(),\n expected: vec![],\n });\n }\n reader.unread_token(token.clone().into());\n return Ok(Some(MacroArg { tokens: arg }));\n }\n Token::LParen | Token::LBrace | Token::LBracket | Token::BinaryStart => {\n stack.push(token.clone());\n }\n Token::RParen | Token::RBrace | Token::RBracket | Token::BinaryEnd => {\n match stack.pop() {\n None => unreachable!(),\n Some(LexicalToken(_, t2, _)) => {\n let closing = t2.get_closing_token();\n if token.1 != closing {\n return Err(PreprocessorError::UnexpectedToken {\n token: token.clone(),\n expected: vec![closing.to_string()],\n });\n }\n }\n }\n }\n _ => (),\n }\n arg.push(token.clone());\n }\n Err(PreprocessorError::UnexpectedEOF)\n }\n}\n\n/// Tail part of a linked list (cons cell).\n#[derive(Debug, Clone)]\npub enum Tail {\n Nil,\n Cons {\n _comma: SymbolToken,\n head: T,\n tail: Box>,\n },\n}\nimpl Eq for Tail {}\nimpl PartialEq for Tail {\n fn eq(&self, other: &Self) -> bool {\n match (self, other) {\n (Self::Nil, Self::Nil) => true,\n (\n Self::Cons {\n head: lh, tail: lt, ..\n },\n Self::Cons {\n head: rh, tail: rt, ..\n },\n ) => lh == rh && lt == rt,\n _ => false,\n }\n }\n}\nimpl fmt::Display for Tail {\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n match *self {\n Tail::Nil => Ok(()),\n Tail::Cons {\n ref head, ref tail, ..\n } => write!(f, \",{}{}\", head, tail),\n }\n }\n}\nimpl ReadFrom for Tail {\n fn read_from(reader: &mut R) -> Result\n where\n R: TokenReader,\n {\n if let Some(_comma) = reader.try_read_expected(&Token::Comma)? {\n let head = reader.read()?;\n let tail = Box::new(reader.read()?);\n Ok(Tail::Cons { _comma, head, tail })\n } else {\n Ok(Tail::Nil)\n }\n }\n}\n\n/// Linked list (cons cell).\n#[derive(Debug, Clone)]\n#[allow(missing_docs)]\npub enum List {\n Nil,\n Cons { head: T, tail: Tail },\n}\nimpl List {\n /// Returns an iterator which iterates over the elements in this list.\n pub fn iter(&self) -> ListIter {\n ListIter(ListIterInner::List(self))\n }\n}\nimpl Eq for List {}\nimpl PartialEq for List {\n fn eq(&self, other: &Self) -> bool {\n match (self, other) {\n (Self::Nil, Self::Nil) => true,\n (Self::Cons { head: lh, tail: lt }, Self::Cons { head: rh, tail: rt }) => {\n lh == rh && lt == rt\n }\n _ => false,\n }\n }\n}\nimpl fmt::Display for List {\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n match *self {\n List::Nil => Ok(()),\n List::Cons { ref head, ref tail } => write!(f, \"{}{}\", head, tail),\n }\n }\n}\nimpl ReadFrom for List {\n fn read_from(reader: &mut R) -> Result\n where\n R: TokenReader,\n {\n if let Some(head) = reader.try_read()? {\n let tail = reader.read()?;\n Ok(List::Cons { head, tail })\n } else {\n Ok(List::Nil)\n }\n }\n}\n\n/// An iterator which iterates over the elements in a `List`.\n#[derive(Debug)]\npub struct ListIter<'a, T: 'a>(ListIterInner<'a, T>);\nimpl<'a, T: 'a> Iterator for ListIter<'a, T> {\n type Item = &'a T;\n fn next(&mut self) -> Option {\n self.0.next()\n }\n}\n\n#[derive(Debug)]\nenum ListIterInner<'a, T: 'a> {\n List(&'a List),\n Tail(&'a Tail),\n End,\n}\nimpl<'a, T: 'a> Iterator for ListIterInner<'a, T> {\n type Item = &'a T;\n fn next(&mut self) -> Option {\n match mem::replace(self, ListIterInner::End) {\n ListIterInner::List(&List::Cons { ref head, ref tail }) => {\n *self = ListIterInner::Tail(tail);\n Some(head)\n }\n ListIterInner::Tail(&Tail::Cons {\n ref head, ref tail, ..\n }) => {\n *self = ListIterInner::Tail(tail);\n Some(head)\n }\n ListIterInner::List(&List::Nil)\n | ListIterInner::Tail(&Tail::Nil)\n | ListIterInner::End => None,\n }\n }\n}\n" }, { "path": "libeir_syntax_erl/src/util/binary/mod.rs", "content": "mod r#static;\npub use r#static::*;\n" }, { "path": "libeir_syntax_erl/src/util/binary/static.rs", "content": "use std::convert::TryInto;\n\nuse snafu::{ResultExt, Snafu};\n\nuse libeir_ir::{BinaryEntrySpecifier, Endianness};\n\nuse libeir_util_number::{Number, Integer};\nuse libeir_util_binary::{BitVec, Endian};\n\nuse libeir_intern::Ident;\nuse libeir_diagnostics::SourceSpan;\n\nuse crate::evaluator::{Term, EvalError as SrcEvalError, eval_expr, ResolveRecordIndexError};\nuse crate::parser::ast::{BinaryElement, Expr, Literal};\n\nuse crate::util::encoding;\nuse crate::util::string_tokenizer::StringTokenizer;\n\n#[derive(Debug, Snafu)]\npub enum StaticBinaryElementError {\n EvalError { source: SrcEvalError },\n #[snafu(display(\"size expression evaluated to invalid type, must be integer\"))]\n InvalidSizeType { span: SourceSpan },\n #[snafu(display(\"size expression evaluated to outside of valid range\"))]\n InvalidSizeValue { span: SourceSpan },\n #[snafu(display(\"native endianness not allowed in static binary expressions\"))]\n NativeEndianNotAllowed { span: SourceSpan },\n #[snafu(display(\"specifier was invalid for given value\"))]\n InvalidSpecifier { span: SourceSpan },\n #[snafu(display(\"provided value not compatible with binary element specifier\"))]\n IncompatibleValue { span: SourceSpan },\n #[snafu(display(\"only total sizes 32 and 64 are permitted for floats, got {}\", size))]\n InvalidFloatSize { span: SourceSpan, size: usize },\n}\n\nfn map_endian(endianness: Endianness) -> Endian {\n match endianness {\n Endianness::Big => Endian::Big,\n Endianness::Little => Endian::Little,\n Endianness::Native => unreachable!(),\n }\n}\n\nfn append_number(\n num: &Number,\n span: SourceSpan,\n size: Option,\n specifier: BinaryEntrySpecifier,\n out: &mut BitVec,\n) -> Result<(), StaticBinaryElementError> {\n use BinaryEntrySpecifier as BES;\n\n\n match specifier {\n BES::Integer { endianness, unit, .. } => {\n let endian = map_endian(endianness);\n\n let size = size.unwrap_or(8);\n let unit: usize = unit.try_into().unwrap();\n let total_size = size * unit;\n\n if let Number::Integer(integer) = num {\n let bitslice = integer.encode_bitstring(total_size, endian);\n out.push(&bitslice);\n Ok(())\n } else {\n Err(StaticBinaryElementError::IncompatibleValue {\n span,\n })\n }\n },\n BES::Float { endianness, unit } => {\n let endian = map_endian(endianness);\n\n let size = size.unwrap_or(64);\n let unit: usize = unit.try_into().unwrap();\n let total_size = size * unit;\n\n let float = num.to_efloat().unwrap().inner();\n\n match total_size {\n 32 => {\n let float = float as f32;\n todo!()\n },\n 64 => {\n todo!()\n },\n _ => {\n Err(StaticBinaryElementError::InvalidFloatSize {\n span,\n size: total_size,\n })\n },\n }\n\n },\n BES::Utf8 => {\n if let Number::Integer(integer) = num {\n let cp = integer.to_u64().unwrap();\n let encoded = encoding::encode_utf8(cp, span).unwrap();\n out.push(encoded);\n\n Ok(())\n } else {\n Err(StaticBinaryElementError::IncompatibleValue {\n span,\n })\n }\n },\n BES::Utf16 { endianness } => {\n if let Number::Integer(integer) = num {\n let cp = integer.to_u64().unwrap();\n let mut encoded = encoding::encode_utf16(cp, span).unwrap();\n\n if endianness == Endianness::Little {\n encoded = encoded.swap();\n }\n\n out.push(encoded);\n\n Ok(())\n } else {\n Err(StaticBinaryElementError::IncompatibleValue {\n span,\n })\n }\n },\n BES::Utf32 { endianness } => {\n let endian = map_endian(endianness);\n\n if let Number::Integer(integer) = num {\n let cp = integer.to_u64().unwrap();\n let mut encoded = encoding::encode_utf32(cp, span).unwrap();\n\n if endianness == Endianness::Little {\n encoded = encoded.swap();\n }\n\n out.push(encoded);\n\n Ok(())\n } else {\n Err(StaticBinaryElementError::IncompatibleValue {\n span,\n })\n }\n },\n BES::Bytes { .. } => {\n unreachable!()\n },\n BES::Bits { .. } => {\n unreachable!()\n },\n }\n}\n\npub fn append_static_binary_element(\n elem: &BinaryElement,\n out: &mut BitVec,\n resolve_record_index: Option<&dyn Fn(Ident, Ident) -> Result>,\n) -> Result<(), StaticBinaryElementError> {\n let specifier = elem.specifier.unwrap_or_else(BinaryEntrySpecifier::default);\n\n if specifier.is_native_endian() {\n return Err(StaticBinaryElementError::NativeEndianNotAllowed {\n span: elem.bit_expr.span(),\n })\n }\n\n // Evaluate bit size\n let size: Option = if let Some(size_expr) = &elem.bit_size {\n let result = eval_expr(size_expr, resolve_record_index)\n .context(EvalError)?;\n match result {\n Term::Number(Number::Integer(num)) => {\n if let Some(integer) = num.to_usize() {\n Some(integer)\n } else {\n return Err(StaticBinaryElementError::InvalidSizeValue {\n span: size_expr.span(),\n });\n }\n },\n _ => {\n return Err(StaticBinaryElementError::InvalidSizeType {\n span: size_expr.span(),\n });\n },\n }\n } else {\n None\n };\n\n\n // TODO switch to evaluator?\n match &elem.bit_expr {\n Expr::Literal(Literal::String(_id, string)) => {\n let tokenizer = StringTokenizer::new(*string);\n for result in tokenizer {\n // TODO error\n let (cp, span) = result.unwrap();\n\n let cp_int: Integer = cp.into();\n append_number(&cp_int.into(), span, size, specifier, out)?;\n }\n Ok(())\n },\n _ => {\n let evaluated = crate::evaluator::eval_expr(&elem.bit_expr, resolve_record_index)\n .context(EvalError)?;\n\n match evaluated {\n Term::Number(number) => {\n append_number(&number, elem.bit_expr.span(), size, specifier, out)?;\n Ok(())\n },\n _ => {\n Err(StaticBinaryElementError::IncompatibleValue {\n span: elem.bit_expr.span(),\n })\n },\n }\n },\n }\n}\n\n#[cfg(test)]\nmod tests {\n use libeir_ir::binary::{BinaryEntrySpecifier, Endianness};\n use libeir_diagnostics::SourceSpan;\n use libeir_util_binary::BitVec;\n\n use crate::parser::ast;\n use super::*;\n\n #[test]\n fn simple_integer() {\n let expr = ast::Expr::Literal(Literal::Integer(SourceSpan::UNKNOWN, ast::NodeId(0), 21.into()));\n let elem = ast::BinaryElement {\n span: SourceSpan::UNKNOWN,\n id: ast::NodeId(1),\n bit_expr: expr,\n bit_size: None,\n specifier: None,\n };\n\n let mut bits = BitVec::new();\n append_static_binary_element(&elem, &mut bits, None).unwrap();\n assert_eq!(bits.as_ref(), &[21]);\n }\n\n #[test]\n fn simple_integer_with_size() {\n let expr = ast::Expr::Literal(Literal::Integer(SourceSpan::UNKNOWN, ast::NodeId(0), 21.into()));\n let size_expr = ast::Expr::Literal(Literal::Integer(SourceSpan::UNKNOWN, ast::NodeId(2), 12.into()));\n let elem = ast::BinaryElement {\n span: SourceSpan::UNKNOWN,\n id: ast::NodeId(1),\n bit_expr: expr,\n bit_size: Some(size_expr),\n specifier: None,\n };\n\n let mut bits = BitVec::new();\n append_static_binary_element(&elem, &mut bits, None).unwrap();\n assert_eq!(bits.as_ref(), &[21 >> 4, 21 << 4]);\n }\n\n #[test]\n fn simple_integer_little_endian_with_size() {\n let expr = ast::Expr::Literal(Literal::Integer(SourceSpan::UNKNOWN, ast::NodeId(0), 21.into()));\n let size_expr = ast::Expr::Literal(Literal::Integer(SourceSpan::UNKNOWN, ast::NodeId(2), 12.into()));\n let elem = ast::BinaryElement {\n span: SourceSpan::UNKNOWN,\n id: ast::NodeId(1),\n bit_expr: expr,\n bit_size: Some(size_expr),\n specifier: Some(BinaryEntrySpecifier::Integer {\n signed: true,\n unit: 1,\n endianness: Endianness::Little,\n }),\n };\n\n let mut bits = BitVec::new();\n append_static_binary_element(&elem, &mut bits, None).unwrap();\n assert_eq!(bits.as_ref(), &[21, 0]);\n }\n\n}\n" }, { "path": "libeir_syntax_erl/src/util/encoding.rs", "content": "use std::fmt::{Display, Formatter};\nuse std::convert::TryFrom;\n\nuse snafu::Snafu;\n\nuse libeir_diagnostics::{Diagnostic, Label, SourceIndex, SourceSpan, ToDiagnostic};\n\n#[derive(Debug, Snafu)]\npub enum StringError {\n #[snafu(display(\"unicode codepoint #{} is not encodable in {}\", codepoint, encoding))]\n CodepointEncoding {\n span: SourceSpan,\n codepoint: u64,\n encoding: Encoding,\n },\n}\n\nimpl ToDiagnostic for StringError {\n fn to_diagnostic(&self) -> Diagnostic {\n let msg = self.to_string();\n match self {\n StringError::CodepointEncoding {\n span,\n codepoint,\n encoding,\n } => Diagnostic::error()\n .with_message(msg)\n .with_labels(vec![Label::primary(span.source_id(), *span)\n .with_message(\"encoding failed at codepoint\")]),\n }\n }\n}\n\n#[derive(Debug, Copy, Clone)]\npub enum Encoding {\n /// The default encoding for binary string literals.\n /// In practice this is the unicode codepoint modulo 2^8 (truncated to 8 bits).\n Latin1,\n Utf8,\n Utf16,\n Utf32,\n}\n\nimpl Display for Encoding {\n fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {\n match self {\n Encoding::Latin1 => write!(f, \"latin1\"),\n Encoding::Utf8 => write!(f, \"utf8\"),\n Encoding::Utf16 => write!(f, \"utf16\"),\n Encoding::Utf32 => write!(f, \"utf32\"),\n }\n }\n}\n\nimpl Encoding {\n pub fn encode(&self, cp: u64, span: SourceSpan) -> Result {\n match self {\n Encoding::Latin1 => encode_latin1(cp, span),\n Encoding::Utf8 => encode_utf8(cp, span),\n Encoding::Utf16 => encode_utf16(cp, span),\n Encoding::Utf32 => encode_utf32(cp, span),\n }\n }\n}\n\n#[derive(Debug, Copy, Clone)]\npub enum Endianness {\n Big,\n Little,\n}\n\nuse libeir_ir::binary::Endianness as EirEndianness;\nimpl TryFrom for Endianness {\n type Error = ();\n fn try_from(end: EirEndianness) -> Result {\n match end {\n EirEndianness::Big => Ok(Endianness::Big),\n EirEndianness::Little => Ok(Endianness::Little),\n EirEndianness::Native => Err(()),\n }\n }\n}\n\n#[derive(Copy, Clone)]\npub enum Encoded {\n N1(u8),\n N2(u8, u8),\n N3(u8, u8, u8),\n N4(u8, u8, u8, u8),\n}\nimpl Encoded {\n pub fn swap(self) -> Self {\n match self {\n Encoded::N1(a) => Encoded::N1(a),\n Encoded::N2(a, b) => Encoded::N2(b, a),\n Encoded::N3(a, b, c) => Encoded::N3(c, b, a),\n Encoded::N4(a, b, c, d) => Encoded::N4(d, c, b, a),\n }\n }\n\n pub fn write(self, endianness: Endianness, out: &mut Vec) {\n match endianness {\n Endianness::Big => self.write_be(out),\n Endianness::Little => self.write_le(out),\n }\n }\n\n pub fn write_le(self, out: &mut Vec) {\n match self {\n Encoded::N1(a) => out.push(a),\n Encoded::N2(a, b) => {\n out.push(b);\n out.push(a);\n }\n Encoded::N3(a, b, c) => {\n out.push(c);\n out.push(b);\n out.push(a);\n }\n Encoded::N4(a, b, c, d) => {\n out.push(d);\n out.push(c);\n out.push(b);\n out.push(a);\n }\n }\n }\n\n pub fn write_be(self, out: &mut Vec) {\n match self {\n Encoded::N1(a) => out.push(a),\n Encoded::N2(a, b) => {\n out.push(a);\n out.push(b);\n }\n Encoded::N3(a, b, c) => {\n out.push(a);\n out.push(b);\n out.push(c);\n }\n Encoded::N4(a, b, c, d) => {\n out.push(a);\n out.push(b);\n out.push(c);\n out.push(d);\n }\n }\n }\n}\nimpl libeir_util_binary::BitCarrier for Encoded {\n type T = u8;\n fn bit_len(&self) -> usize {\n match self {\n Self::N1(_) => 8,\n Self::N2(_, _) => 16,\n Self::N3(_, _, _) => 24,\n Self::N4(_, _, _, _) => 32,\n }\n }\n}\nimpl libeir_util_binary::BitRead for Encoded {\n fn read_word(&self, n: usize) -> u8 {\n match (self, n) {\n (Self::N1(val), 0) => *val,\n (Self::N2(val, _), 0) => *val,\n (Self::N2(_, val), 1) => *val,\n (Self::N3(val, _, _), 0) => *val,\n (Self::N3(_, val, _), 1) => *val,\n (Self::N3(_, _, val), 2) => *val,\n (Self::N4(val, _, _, _), 0) => *val,\n (Self::N4(_, val, _, _), 1) => *val,\n (Self::N4(_, _, val, _), 2) => *val,\n (Self::N4(_, _, _, val), 3) => *val,\n _ => unreachable!(),\n }\n }\n}\n\npub fn encode_utf8(cp: u64, span: SourceSpan) -> Result {\n match cp {\n 0x00..=0x7f => Ok(Encoded::N1(cp as u8)),\n 0x80..=0x7ff => Ok(Encoded::N2(\n 0b110_00000 | (cp >> 6 & 0b000_11111) as u8,\n 0b10_000000 | (cp >> 0 & 0b00_111111) as u8,\n )),\n 0x800..=0xffff => Ok(Encoded::N3(\n 0b1110_0000 | (cp >> 12 & 0b0000_1111) as u8,\n 0b10_000000 | (cp >> 6 & 0b00_111111) as u8,\n 0b10_000000 | (cp >> 0 & 0b00_111111) as u8,\n )),\n 0x10000..=0x1fffff => Ok(Encoded::N4(\n 0b11110_000 | (cp >> 18 & 0b00000_111) as u8,\n 0b10_000000 | (cp >> 12 & 0b00_111111) as u8,\n 0b10_000000 | (cp >> 6 & 0b00_111111) as u8,\n 0b10_000000 | (cp >> 0 & 0b00_111111) as u8,\n )),\n _ => Err(StringError::CodepointEncoding {\n span,\n codepoint: cp,\n encoding: Encoding::Utf8,\n }),\n }\n}\n\npub fn encode_utf16(cp: u64, span: SourceSpan) -> Result {\n match cp {\n 0x0000..=0xd7ff => Ok(Encoded::N2((cp >> 8) as u8, (cp >> 0) as u8)),\n 0xd800..=0xdfff => Err(StringError::CodepointEncoding {\n span,\n codepoint: cp,\n encoding: Encoding::Utf16,\n }),\n 0xd800..=0xffff => Ok(Encoded::N2((cp >> 8) as u8, (cp >> 0) as u8)),\n 0x10000..=0x10ffff => {\n let val = cp - 0x10000;\n Ok(Encoded::N4(\n 0b110110_00 | (cp >> 18 & 0b000000_11) as u8,\n (cp >> 10) as u8,\n 0b110111_00 | (cp >> 8 & 0b000000_11) as u8,\n (cp >> 0) as u8,\n ))\n }\n _ => Err(StringError::CodepointEncoding {\n span,\n codepoint: cp,\n encoding: Encoding::Utf16,\n }),\n }\n}\n\npub fn encode_utf32(cp: u64, span: SourceSpan) -> Result {\n if cp > std::u32::MAX as u64 {\n Err(StringError::CodepointEncoding {\n span,\n codepoint: cp,\n encoding: Encoding::Utf32,\n })\n } else {\n Ok(Encoded::N4(\n (cp >> 24) as u8,\n (cp >> 16) as u8,\n (cp >> 8) as u8,\n (cp >> 0) as u8,\n ))\n }\n}\n\nfn encode_latin1(cp: u64, _span: SourceSpan) -> Result {\n Ok(Encoded::N1(cp as u8))\n}\n" }, { "path": "libeir_syntax_erl/src/util/escape_stm.rs", "content": "use libeir_diagnostics::{Diagnostic, Label, SourceIndex, SourceSpan, ToDiagnostic};\nuse snafu::Snafu;\n\n#[derive(Snafu, Debug, Clone, PartialEq, Eq)]\npub enum EscapeStmError {\n /// Unknown escape character\n #[snafu(display(\"unknown escape character '{}'\", escape_char))]\n UnknownEscape { range: (D, D), escape_char: char },\n /// Expected a base-n digit or alt\n #[snafu(display(\"expected base{} digit or '{}', found '{}'\", base, alt, found))]\n InvalidBaseNDigitOrAlt {\n range: (D, D),\n found: char,\n base: usize,\n alt: char,\n },\n /// Expected a base-n digit\n #[snafu(display(\"expected base{} digit, found '{}'\", base, found))]\n InvalidBaseNDigit {\n range: (D, D),\n found: char,\n base: usize,\n },\n /// Expected control character symbol\n #[snafu(display(\"expected control character symbol (a-z), found '{}'\", found))]\n InvalidControl { range: (D, D), found: char },\n #[snafu(display(\"unexpected EOF\"))]\n UnexpectedEof { range: (D, D) },\n}\n\nimpl EscapeStmError {\n pub fn range(&self) -> &(D, D) {\n match self {\n Self::UnknownEscape { range, .. } => range,\n Self::InvalidBaseNDigitOrAlt { range, .. } => range,\n Self::InvalidBaseNDigit { range, .. } => range,\n Self::InvalidControl { range, .. } => range,\n Self::UnexpectedEof { range } => range,\n }\n }\n}\n\nimpl EscapeStmError {\n pub fn span(&self) -> SourceSpan {\n let (start, end) = self.range();\n SourceSpan::new(*start, *end)\n }\n}\n\nimpl ToDiagnostic for EscapeStmError {\n fn to_diagnostic(&self) -> Diagnostic {\n let msg = self.to_string();\n let span = self.span();\n\n Diagnostic::error()\n .with_message(\"invalid string escape\")\n .with_labels(vec![\n Label::primary(span.source_id(), span).with_message(msg)\n ])\n }\n}\n\n/// Erlang string escape state machine.\n#[derive(Clone, Debug)]\npub struct EscapeStm {\n buf: String,\n curr_start: Option,\n state: EscapeStmState,\n}\n\n#[derive(Copy, Clone, Debug, PartialEq, Eq)]\npub enum EscapeStmState {\n Norm,\n Escape,\n Oct,\n HexStart,\n HexN,\n Hex2,\n Control,\n}\n\n#[derive(Debug)]\npub enum EscapeStmAction {\n Next,\n Again,\n}\n\n#[derive(Debug)]\npub struct EscapeStmOut {\n pub range: (D, D),\n pub cp: u64,\n}\n\nimpl EscapeStm {\n pub fn new() -> Self {\n EscapeStm {\n buf: String::new(),\n curr_start: None,\n state: EscapeStmState::Norm,\n }\n }\n\n pub fn reset(&mut self) {\n self.buf.clear();\n self.curr_start = None;\n self.state = EscapeStmState::Norm;\n }\n\n pub fn is_norm(&self) -> bool {\n self.state == EscapeStmState::Norm\n }\n\n pub fn transition(\n &mut self,\n c: Option,\n pos: D,\n ) -> Result<(EscapeStmAction, Option>), EscapeStmError> {\n use EscapeStmAction as A;\n use EscapeStmState as S;\n\n let mut range = (self.curr_start.unwrap_or(pos), pos);\n let mut out = None;\n\n let action = match self.state {\n S::Norm => match c {\n Some('\\\\') => {\n self.state = S::Escape;\n self.curr_start = Some(pos);\n A::Next\n }\n Some(c) => {\n self.state = S::Norm;\n range = (pos, pos);\n out = Some(c as u64);\n A::Next\n }\n None => A::Next,\n },\n S::Escape => {\n match c {\n Some('b') => {\n // Backspace\n self.state = S::Norm;\n out = Some('\\x08' as u64);\n }\n Some('d') => {\n // Delete\n self.state = S::Norm;\n out = Some('\\x7f' as u64);\n }\n Some('e') => {\n // Escape\n self.state = S::Norm;\n out = Some('\\x1b' as u64);\n }\n Some('f') => {\n // Form feed\n self.state = S::Norm;\n out = Some('\\x0c' as u64);\n }\n Some('n') => {\n // Line feed\n self.state = S::Norm;\n out = Some('\\n' as u64);\n }\n Some('r') => {\n // Carriage return\n self.state = S::Norm;\n out = Some('\\r' as u64);\n }\n Some('s') => {\n // Space\n self.state = S::Norm;\n out = Some(' ' as u64);\n }\n Some('t') => {\n // Tab\n self.state = S::Norm;\n out = Some('\\t' as u64);\n }\n Some('v') => {\n // Vertical tab\n self.state = S::Norm;\n out = Some('\\x0b' as u64);\n }\n Some(n) if n >= '0' && n <= '7' => {\n self.buf.clear();\n self.buf.push(n);\n self.state = S::Oct;\n }\n Some('x') => {\n self.state = S::HexStart;\n }\n Some('^') => {\n self.state = S::Control;\n }\n Some(c) => {\n self.state = S::Norm;\n out = Some(c as u64);\n }\n None => return Err(EscapeStmError::UnexpectedEof { range }),\n }\n A::Next\n }\n S::Oct => match c {\n Some(c) if c >= '0' && c <= '7' => {\n self.buf.push(c);\n\n if self.buf.len() == 3 {\n let parsed = u64::from_str_radix(&self.buf, 8).unwrap();\n\n self.state = S::Norm;\n out = Some(parsed);\n } else {\n self.state = S::Oct;\n }\n\n A::Next\n }\n _ => {\n let parsed = u64::from_str_radix(&self.buf, 8).unwrap();\n\n self.state = S::Norm;\n out = Some(parsed);\n\n A::Again\n }\n },\n S::HexStart => match c {\n Some('{') => {\n self.state = S::HexN;\n\n A::Next\n }\n Some(n) if n.is_digit(16) => {\n self.buf.clear();\n self.buf.push(n);\n self.state = S::Hex2;\n\n A::Next\n }\n Some(c) => {\n return Err(EscapeStmError::InvalidBaseNDigitOrAlt {\n range,\n found: c,\n base: 16,\n alt: '{',\n });\n }\n None => return Err(EscapeStmError::UnexpectedEof { range }),\n },\n S::Hex2 => match c {\n Some(n) if n.is_digit(16) => {\n self.buf.push(n);\n self.state = S::Norm;\n\n let parsed = u64::from_str_radix(&self.buf, 16).unwrap();\n out = Some(parsed);\n\n A::Next\n }\n Some(c) => {\n return Err(EscapeStmError::InvalidBaseNDigit {\n range,\n found: c,\n base: 16,\n });\n }\n None => return Err(EscapeStmError::UnexpectedEof { range }),\n },\n S::HexN => match c {\n Some('}') => {\n let parsed = u64::from_str_radix(&self.buf, 16).unwrap();\n\n self.state = S::Norm;\n out = Some(parsed);\n\n A::Next\n }\n Some(n) if n.is_digit(16) => {\n self.buf.push(n);\n self.state = S::HexN;\n\n A::Next\n }\n Some(c) => {\n return Err(EscapeStmError::InvalidBaseNDigitOrAlt {\n range,\n found: c,\n base: 16,\n alt: '}',\n });\n }\n None => return Err(EscapeStmError::UnexpectedEof { range }),\n },\n S::Control => {\n match c {\n Some(c) => {\n let num = (c as u64) % 32;\n self.state = S::Norm;\n out = Some(num);\n\n if c < '@' || c > '~' {\n // TODO: Warn?\n // return Err(EscapeStmError::InvalidControl { range, found: c })\n }\n\n A::Next\n }\n None => return Err(EscapeStmError::UnexpectedEof { range }),\n }\n }\n };\n\n Ok((action, out.map(|c| EscapeStmOut { cp: c, range })))\n }\n}\n" }, { "path": "libeir_syntax_erl/src/util/mod.rs", "content": "pub mod encoding;\npub mod escape_stm;\npub mod string_tokenizer;\npub mod string;\npub mod binary;\n" }, { "path": "libeir_syntax_erl/src/util/string.rs", "content": "use libeir_intern::Ident;\n\nuse crate::lower::LowerError;\nuse super::string_tokenizer::{StringTokenizer, StringTokenizeError};\nuse super::encoding::{Encoding, Endianness};\n\npub fn string_to_codepoints(string: Ident) -> Result, StringTokenizeError> {\n StringTokenizer::new(string).map(|v| v.map(|(cp, _span)| cp)).collect()\n}\n\npub fn string_to_binary(\n ident: Ident,\n encoding: Encoding,\n endianness: Endianness,\n) -> Result, LowerError> {\n let mut out = Vec::new();\n\n let tokenizer = StringTokenizer::new(ident);\n for tok in tokenizer {\n let (cp, span) = tok?;\n let encoded = encoding.encode(cp, span)?;\n encoded.write(endianness, &mut out);\n }\n Ok(out)\n}\n\n#[cfg(test)]\nmod tests {\n use libeir_intern::Ident;\n\n use super::{string_to_binary, string_to_codepoints, Encoding, Endianness};\n\n #[test]\n fn string_literal_parse() {\n assert!(\n string_to_codepoints(Ident::from_str(\"abc\")).unwrap()\n == vec!['a' as u64, 'b' as u64, 'c' as u64]\n );\n\n assert!(\n string_to_codepoints(Ident::from_str(\"a\\\\bc\")).unwrap()\n == vec!['a' as u64, 8, 'c' as u64]\n );\n\n assert!(\n string_to_codepoints(Ident::from_str(\"a\\\\b\\\\d\\\\e\\\\f\\\\n\\\\r\\\\s\\\\t\\\\vc\")).unwrap()\n == vec!['a' as u64, 8, 127, 27, 12, 10, 13, ' ' as u64, 9, 11, 'c' as u64]\n );\n\n assert!(\n string_to_codepoints(Ident::from_str(\"a\\\\'\\\\\\\"\\\\\\\\c\")).unwrap()\n == vec!['a' as u64, '\\'' as u64, '\"' as u64, '\\\\' as u64, 'c' as u64]\n );\n\n assert!(\n string_to_codepoints(Ident::from_str(\"a\\\\1\\\\12\\\\123c\")).unwrap()\n == vec!['a' as u64, 0o1, 0o12, 0o123, 'c' as u64]\n );\n assert!(string_to_codepoints(Ident::from_str(\"\\\\123\")).unwrap() == vec![0o123]);\n assert!(string_to_codepoints(Ident::from_str(\"\\\\12\")).unwrap() == vec![0o12]);\n assert!(string_to_codepoints(Ident::from_str(\"\\\\1\")).unwrap() == vec![0o1]);\n\n assert!(\n string_to_codepoints(Ident::from_str(\"a\\\\xffc\")).unwrap()\n == vec!['a' as u64, 0xff, 'c' as u64]\n );\n assert!(string_to_codepoints(Ident::from_str(\"\\\\xff\")).unwrap() == vec![0xff]);\n\n assert!(string_to_codepoints(Ident::from_str(\"\\\\x{ff}\")).unwrap() == vec![0xff]);\n assert!(string_to_codepoints(Ident::from_str(\"\\\\x{ffff}\")).unwrap() == vec![0xffff]);\n\n assert!(string_to_codepoints(Ident::from_str(\"\\\\^a\\\\^z\")).unwrap() == vec![1, 26]);\n }\n\n #[test]\n fn test_string_to_binary() {\n assert!(\n string_to_binary(Ident::from_str(\"abcå\"), Encoding::Utf8, Endianness::Big).unwrap()\n == vec![0x61, 0x62, 0x63, 0xc3, 0xa5]\n )\n }\n}\n" }, { "path": "libeir_syntax_erl/src/util/string_tokenizer.rs", "content": "use snafu::Snafu;\n\nuse libeir_diagnostics::{Diagnostic, SourceIndex, SourceSpan, ToDiagnostic};\nuse libeir_intern::Ident;\n\nuse super::escape_stm as escape;\n\n#[derive(Debug, Snafu)]\npub enum StringTokenizeError {\n InvalidStringEscape {\n span: SourceSpan,\n source: escape::EscapeStmError,\n },\n}\nimpl ToDiagnostic for StringTokenizeError {\n fn to_diagnostic(&self) -> Diagnostic {\n match self {\n StringTokenizeError::InvalidStringEscape { source, .. } =>\n source.to_diagnostic(),\n }\n }\n}\n\npub struct StringTokenizer {\n ident: Ident,\n chars: std::str::Chars<'static>,\n byte_idx: usize,\n stm: escape::EscapeStm,\n again: Option<(Option, SourceIndex)>,\n finished: bool,\n}\n\nimpl StringTokenizer {\n pub fn new(string: Ident) -> Self {\n StringTokenizer {\n ident: string,\n chars: string.name.as_str().get().chars(),\n byte_idx: 0,\n stm: escape::EscapeStm::new(),\n again: None,\n finished: false,\n }\n }\n}\n\nimpl Iterator for StringTokenizer {\n type Item = Result<(u64, SourceSpan), StringTokenizeError>;\n fn next(&mut self) -> Option {\n use escape::EscapeStmAction;\n\n if self.finished {\n return None;\n }\n\n loop {\n if let Some((again_chr, idx)) = self.again.take() {\n let res = self.stm.transition(again_chr, idx);\n\n let out = match res {\n Ok((EscapeStmAction::Next, out)) => {\n match again_chr {\n Some(c) => self.byte_idx += c.len_utf8(),\n // If this is None, it means we have reached the\n // end of the string.\n None => self.finished = true,\n }\n out\n },\n Ok((EscapeStmAction::Again, out)) => {\n self.again = Some((again_chr, idx));\n out\n },\n Err(err) => {\n self.finished = true;\n return Some(Err(StringTokenizeError::InvalidStringEscape {\n span: err.span(),\n source: err,\n }));\n },\n };\n\n if let Some(result) = out {\n // If we have a result, we return that\n let span = SourceSpan::new(result.range.0, result.range.1);\n return Some(Ok((result.cp, span)));\n } else if self.finished {\n // If there is no result, and the iterator has been marked\n // as finished, we return nothing.\n return None;\n } else {\n // Otherwise, the state machine needs more data.\n continue;\n }\n }\n\n let idx = self.ident.span.start() + self.byte_idx;\n let chr = self.chars.next();\n self.again = Some((chr, idx));\n }\n }\n}\n\n#[cfg(test)]\nmod tests {\n use libeir_intern::Ident;\n use libeir_diagnostics::SourceSpan;\n\n use super::*;\n\n #[test]\n fn tokenize_plaintext() {\n let mut tokenizer = StringTokenizer::new(Ident::from_str(\"abc\"));\n assert_eq!(tokenizer.next().unwrap().unwrap(), ('a' as u64, SourceSpan::UNKNOWN));\n assert_eq!(tokenizer.next().unwrap().unwrap(), ('b' as u64, SourceSpan::UNKNOWN));\n assert_eq!(tokenizer.next().unwrap().unwrap(), ('c' as u64, SourceSpan::UNKNOWN));\n assert!(tokenizer.next().is_none());\n }\n\n #[test]\n fn tokenize_unicode_codepoint() {\n let mut tokenizer = StringTokenizer::new(Ident::from_str(\"\\\\x{afaf}\"));\n assert_eq!(tokenizer.next().unwrap().unwrap(), (0xafaf, SourceSpan::UNKNOWN));\n assert!(tokenizer.next().is_none());\n }\n\n}\n" }, { "path": "libeir_tests/Cargo.toml", "content": "[package]\nname = \"libeir_tests\"\nversion = \"0.1.0\"\nauthors = [\"Hans Elias B. Josephsen \"]\nedition = \"2018\"\nlicense = \"MIT OR Apache-2.0\"\n\n[dependencies]\nlibeir_ir = { path = \"../libeir_ir\" }\nlibeir_passes = { path = \"../libeir_passes\" }\nlibeir_syntax_erl = { path = \"../libeir_syntax_erl\" }\nlibeir_diagnostics = { path = \"../libeir_diagnostics\" }\nlibeir_intern = { path = \"../libeir_intern\" }\nlibeir_interpreter = { path = \"../libeir_interpreter\" }\nlibeir_lowerutils = { path = \"../libeir_lowerutils\" }\nlibeir_util_parse = { path = \"../util/libeir_util_parse\" }\nlibeir_util_dot_graph = { path = \"../util/libeir_util_dot_graph\" }\n\n[dev-dependencies]\nenv_logger = \"0.7\"\n" }, { "path": "libeir_tests/shadowing.erl", "content": "-module(shadowing).\n\n-export([run/0]).\n\nrun() ->\n 1 = case_matching({1}, 1),\n {_, _} = (catch case_matching({1}, 2)),\n\n 1 = fun_shadowing({1}, 1),\n 2 = fun_shadowing({1}, 2).\n\ncase_matching(A, B) ->\n case A of\n {B} -> B\n end.\n\nfun_shadowing(A, B) ->\n C = fun({B}) -> B end,\n C(A).\n\n" }, { "path": "libeir_tests/src/control_flow/accumulate_list.rs", "content": "use crate::lower;\n\nuse libeir_intern::Ident;\nuse libeir_ir::FunctionIdent;\nuse libeir_passes::PassManager;\nuse libeir_syntax_erl::ParseConfig;\n\nuse libeir_interpreter::{Term, VMState};\n\nuse std::rc::Rc;\n\n#[test]\nfn test_list_acc() {\n let _ = env_logger::try_init();\n\n let mut eir_mod = lower(\n \"-module(woo).\n\nwoo([], Acc) -> Acc;\nwoo([H | T], Acc) -> woo(T, H + Acc).\n\nwoo(V) -> woo(V, 0).\n\",\n ParseConfig::default(),\n )\n .unwrap();\n\n let mut pass_manager = PassManager::default();\n pass_manager.run(&mut eir_mod);\n\n let mut vm = VMState::new();\n vm.add_builtin_modules();\n vm.add_erlang_module(eir_mod);\n\n let fun = FunctionIdent {\n module: Ident::from_str(\"woo\"),\n name: Ident::from_str(\"woo\"),\n arity: 1,\n };\n\n {\n let arg = Term::slice_to_list(\n &[\n Term::Integer(1.into()).into(),\n Term::Integer(2.into()).into(),\n Term::Integer(4.into()).into(),\n ],\n Term::Nil.into(),\n );\n assert!(\n vm.call(&fun, &[Rc::try_unwrap(arg).unwrap()])\n .unwrap()\n .as_i64()\n == Some(7)\n );\n }\n}\n" }, { "path": "libeir_tests/src/control_flow/fib.rs", "content": "use crate::lower;\n\nuse libeir_intern::Ident;\nuse libeir_ir::FunctionIdent;\nuse libeir_passes::PassManager;\nuse libeir_syntax_erl::ParseConfig;\n\nuse libeir_interpreter::{Term, VMState};\n\n#[test]\nfn test_fib() {\n let _ = env_logger::try_init();\n\n let mut eir_mod = lower(\n \"-module(fib).\n\nfib(X) when X < 2 -> 1;\nfib(X) -> fib(X - 1) + fib(X-2).\n\",\n ParseConfig::default(),\n )\n .unwrap();\n\n let mut pass_manager = PassManager::default();\n pass_manager.run(&mut eir_mod);\n\n let mut vm = VMState::new();\n vm.add_builtin_modules();\n vm.add_erlang_module(eir_mod);\n\n let fun = FunctionIdent {\n module: Ident::from_str(\"fib\"),\n name: Ident::from_str(\"fib\"),\n arity: 1,\n };\n\n let mut call_fib = |n: i64| {\n let num = Term::Integer(n.into());\n vm.call(&fun, &[num.into()])\n };\n\n fn rust_fib(x: i64) -> i64 {\n if x < 2 {\n 1\n } else {\n rust_fib(x - 1) + rust_fib(x - 2)\n }\n }\n\n assert!(call_fib(1).unwrap().as_i64().unwrap() == rust_fib(1));\n assert!(call_fib(2).unwrap().as_i64().unwrap() == rust_fib(2));\n assert!(call_fib(3).unwrap().as_i64().unwrap() == rust_fib(3));\n assert!(call_fib(4).unwrap().as_i64().unwrap() == rust_fib(4));\n assert!(call_fib(5).unwrap().as_i64().unwrap() == rust_fib(5));\n assert!(call_fib(6).unwrap().as_i64().unwrap() == rust_fib(6));\n assert!(call_fib(7).unwrap().as_i64().unwrap() == rust_fib(7));\n assert!(call_fib(8).unwrap().as_i64().unwrap() == rust_fib(8));\n}\n" }, { "path": "libeir_tests/src/control_flow/get_values.rs", "content": "use crate::lower;\n\nuse libeir_passes::PassManager;\nuse libeir_syntax_erl::ParseConfig;\n\n//-module('Elixir.Keyword').\n//\n//get_values(_keywords@1, _key@1)\n// when\n// is_list(_keywords@1)\n// andalso\n// is_atom(_key@1) ->\n// _fun@1 =\n// fun({_key@2,_val@1}) when _key@1 =:= _key@2 ->\n// {true,_val@1};\n// ({_,_}) ->\n// false\n// end,\n// lists:filtermap(_fun@1, _keywords@1).\n\n#[test]\nfn get_values() {\n let _ = env_logger::try_init();\n\n let mut eir_mod = lower(\n \"-module('Elixir.Keyword').\n\nget_values(_key@1) ->\n A = fun(_key@2) ->\n _key@1 =:= _key@2\n end,\n A.\n\",\n ParseConfig::default(),\n )\n .unwrap();\n\n let mut pass_manager = PassManager::default();\n pass_manager.run(&mut eir_mod);\n\n for fun in eir_mod.function_iter() {\n let _ = fun.function().live_values();\n }\n}\n" }, { "path": "libeir_tests/src/control_flow/mod.rs", "content": "mod fib;\n//mod nth_root;\nmod accumulate_list;\nmod get_values;\nmod shadowing;\n" }, { "path": "libeir_tests/src/control_flow/nth_root.rs", "content": "use std::rc::Rc;\n\nuse crate::{lower, write_dot};\n\nuse libeir_intern::{Ident, Symbol};\nuse libeir_ir::FunctionIdent;\nuse libeir_passes::PassManager;\nuse libeir_syntax_erl::ParseConfig;\n\nuse libeir_interpreter::{ErlEq, Term, VMState};\n\n#[test]\nfn test_nth_root() {\n let _ = env_logger::try_init();\n\n let mut eir_mod = lower(\n \"\n-module(woo).\n\nfixed_point(F, Guess, Tolerance) ->\n fixed_point(F, Guess, Tolerance, F(Guess)).\nfixed_point(_, Guess, Tolerance, Next) when erlang:abs(Guess - Next) < Tolerance ->\n Next;\nfixed_point(F, _, Tolerance, Next) ->\n fixed_point(F, Next, Tolerance, F(Next)).\n\nnth_root(N, X) -> nth_root(N, X, 1.0e-5).\nnth_root(N, X, Precision) ->\n F = fun(Prev) -> ((N - 1) * Prev + X / math:pow(Prev, (N-1))) / N end,\n fixed_point(F, X, Precision).\n\",\n ParseConfig::default(),\n )\n .unwrap();\n\n let mut pass_manager = PassManager::default();\n pass_manager.run(&mut eir_mod);\n\n let fun = FunctionIdent {\n module: Ident::from_str(\"woo\"),\n name: Ident::from_str(\"nth_root\"),\n arity: 2,\n };\n\n let mut vm = VMState::new();\n vm.add_builtin_modules();\n vm.add_erlang_module(eir_mod);\n\n assert!(vm.call(&fun, &[2.into(), 2.into()]).unwrap().as_boolean() == Some(true));\n}\n" }, { "path": "libeir_tests/src/control_flow/shadowing.rs", "content": "use crate::lower;\n\nuse libeir_intern::Ident;\nuse libeir_ir::FunctionIdent;\nuse libeir_passes::PassManager;\nuse libeir_syntax_erl::ParseConfig;\n\nuse libeir_interpreter::VMState;\n\n#[test]\nfn pattern_variable_shadowing() {\n let _ = env_logger::try_init();\n\n let mut eir_mod = lower(\n \"-module(shadowing).\n\nrun() ->\n 1 = case_matching({1}, 1),\n {_, _} = (catch case_matching({1}, 2)),\n\n 1 = fun_shadowing({1}, 1),\n 2 = fun_shadowing({2}, 1).\n\ncase_matching(A, B) ->\n case A of\n {B} -> B\n end.\n\nfun_shadowing(A, B) ->\n C = fun({B}) -> B end,\n C(A).\n\n\",\n ParseConfig::default(),\n )\n .unwrap();\n\n let mut pass_manager = PassManager::default();\n pass_manager.run(&mut eir_mod);\n\n let mut vm = VMState::new();\n vm.add_builtin_modules();\n vm.add_erlang_module(eir_mod);\n\n let run_fun = FunctionIdent {\n module: Ident::from_str(\"shadowing\"),\n name: Ident::from_str(\"run\"),\n arity: 0,\n };\n assert!(vm.call(&run_fun, &[]).is_ok());\n}\n\n#[test]\nfn pattern_variable_shadowing_a() {\n let _ = env_logger::try_init();\n\n let mut eir_mod = lower(\n \"-module(shadowinga).\n\nfun_shadowing(A) ->\n C = fun(B) -> B end,\n C(A).\n\n\",\n ParseConfig::default(),\n )\n .unwrap();\n\n let mut pass_manager = PassManager::default();\n pass_manager.run(&mut eir_mod);\n\n for fun_def in eir_mod.function_iter() {\n let fun = fun_def.function();\n fun.live_values();\n }\n}\n" }, { "path": "libeir_tests/src/ct_runner.rs", "content": "use std::collections::HashMap;\n\nuse libeir_intern::{Ident, Symbol};\nuse libeir_ir::FunctionIdent;\n\nuse libeir_interpreter::{Term, VMState};\n\n#[derive(Debug, Clone)]\nstruct SuiteSpec {\n entries: Vec,\n}\n\n#[derive(Debug, Clone)]\nenum SuiteEntrySpec {\n Test(Symbol),\n Group { name: Symbol, tests: Vec },\n}\n\nfn get_suite_spec(vm: &mut VMState, module: Ident) -> SuiteSpec {\n let groups = {\n let fun = FunctionIdent {\n module,\n name: Ident::from_str(\"groups\"),\n arity: 0,\n };\n let ret = vm.call(&fun, &[]).unwrap();\n\n let mut groups = HashMap::new();\n for elem in Term::as_list(&ret).unwrap() {\n let tup = elem.as_tuple().unwrap();\n assert!(tup.len() == 3);\n\n let name = tup[0].as_atom().unwrap();\n\n let tests = Term::as_list(&tup[2])\n .unwrap()\n .iter()\n .map(|v| v.as_atom().unwrap())\n .collect();\n\n let group = SuiteEntrySpec::Group { name, tests };\n groups.insert(name, group);\n }\n\n groups\n };\n\n let all = {\n let fun = FunctionIdent {\n module,\n name: Ident::from_str(\"all\"),\n arity: 0,\n };\n let ret = vm.call(&fun, &[]).unwrap();\n\n let mut entries = Vec::new();\n for elem in Term::as_list(&ret).unwrap() {\n if let Some(name) = elem.as_atom() {\n entries.push(SuiteEntrySpec::Test(name));\n } else if let Some(tup) = elem.as_tuple() {\n match &tup {\n &[group_atom, group]\n if group_atom.as_atom() == Some(Symbol::intern(\"group\")) =>\n {\n let group_name = group.as_atom().unwrap();\n entries.push(groups[&group_name].clone());\n }\n _ => panic!(),\n }\n } else {\n panic!()\n }\n }\n\n entries\n };\n\n SuiteSpec { entries: all }\n}\n\npub fn run_ct_suite(vm: &mut VMState, module: Ident) {\n let spec = get_suite_spec(vm, module);\n\n let config = Term::Nil;\n\n for entry in spec.entries.iter() {\n match entry {\n SuiteEntrySpec::Group { tests, .. } => {\n for test in tests {\n let fun = FunctionIdent {\n module,\n name: Ident::with_empty_span(*test),\n arity: 1,\n };\n let res = vm.call(&fun, &[config.clone()]);\n res.unwrap();\n }\n }\n SuiteEntrySpec::Test(sym) => {\n let fun = FunctionIdent {\n module,\n name: Ident::with_empty_span(*sym),\n arity: 1,\n };\n let res = vm.call(&fun, &[config.clone()]);\n res.unwrap();\n }\n }\n }\n}\n" }, { "path": "libeir_tests/src/errors.rs", "content": "use super::lower;\n\nuse libeir_intern::{Ident, Symbol};\nuse libeir_ir::FunctionIdent;\nuse libeir_passes::PassManager;\nuse libeir_syntax_erl::ParseConfig;\n\nuse libeir_interpreter::{Term, VMState};\n\n#[test]\nfn test_basic_catch() {\n let _ = env_logger::try_init();\n\n let mut eir_mod = lower(\n \"\n-module(woo).\n\nfoo(foo) -> false.\n\nwoo(A) -> try foo(A) catch\n error:function_clause ->\n true\nend.\n\",\n ParseConfig::default(),\n )\n .unwrap();\n\n let mut pass_manager = PassManager::default();\n pass_manager.run(&mut eir_mod);\n\n let fun = FunctionIdent {\n module: Ident::from_str(\"woo\"),\n name: Ident::from_str(\"woo\"),\n arity: 1,\n };\n\n let mut vm = VMState::new();\n vm.add_builtin_modules();\n vm.add_erlang_module(eir_mod);\n\n assert!(vm.call(&fun, &[1.into()]).unwrap().as_boolean() == Some(true));\n assert!(\n vm.call(&fun, &[Term::Atom(Symbol::intern(\"foo\")).into()])\n .unwrap()\n .as_boolean()\n == Some(false)\n );\n}\n\n#[test]\nfn test_basic_catch_miss() {\n let _ = env_logger::try_init();\n\n let mut eir_mod = lower(\n \"\n-module(woo).\n\nfoo(foo) -> false.\n\nwoo(A) -> try foo(A) catch\n error:function_clause_not ->\n true\nend.\n\",\n ParseConfig::default(),\n )\n .unwrap();\n\n let mut pass_manager = PassManager::default();\n pass_manager.run(&mut eir_mod);\n\n let fun = FunctionIdent {\n module: Ident::from_str(\"woo\"),\n name: Ident::from_str(\"woo\"),\n arity: 1,\n };\n\n let mut vm = VMState::new();\n vm.add_builtin_modules();\n vm.add_erlang_module(eir_mod);\n\n assert!(\n vm.call(&fun, &[Term::Atom(Symbol::intern(\"foo\")).into()])\n .unwrap()\n .as_boolean()\n == Some(false)\n );\n assert!(vm.call(&fun, &[1.into()]).is_err());\n}\n" }, { "path": "libeir_tests/src/lib.rs", "content": "//#![deny(warnings)]\n#![cfg(test)]\n\nuse std::path::Path;\nuse std::sync::Arc;\n\nuse libeir_diagnostics::*;\nuse libeir_ir::{FunctionIdent, Module};\nuse libeir_syntax_erl::lower_module;\nuse libeir_syntax_erl::{ErlangError, Parse, ParseConfig, Parser, ParserError};\nuse libeir_util_parse::{error_tee, Errors};\n\nuse libeir_util_dot_graph::GraphPrinter;\n\nmod control_flow;\nmod ct_runner;\nmod errors;\nmod list_comprehensions;\nmod otp;\nmod patterns;\nmod records;\n\nfn lower_file(path: S, config: ParseConfig) -> Result\nwhere\n S: AsRef,\n{\n let mut errors: Errors = Errors::new();\n let codemap = Arc::new(CodeMap::new());\n let eir_res = error_tee(&mut errors, |mut errors| {\n let parser = Parser::new(config, codemap.clone());\n let ast = parser.parse_file(&mut errors.make_into_adapter(), path)?;\n let eir = lower_module(&mut errors.make_into_adapter(), codemap.clone(), &ast)?;\n Ok(eir)\n });\n\n errors.print(&codemap);\n\n eir_res\n}\n\npub fn lower(input: S, config: ParseConfig) -> Result\nwhere\n S: AsRef,\n{\n let mut errors: Errors = Errors::new();\n let codemap = Arc::new(CodeMap::new());\n let eir_res = error_tee(&mut errors, |mut errors| {\n let parser = Parser::new(config, codemap.clone());\n let ast = parser.parse_string(&mut errors.make_into_adapter(), input)?;\n let eir = lower_module(&mut errors.make_into_adapter(), codemap.clone(), &ast)?;\n Ok(eir)\n });\n\n errors.print(&codemap);\n\n eir_res\n}\n\npub fn write_dot(module: &Module, ident: Option) {\n if let Some(ident) = ident {\n let idx = module.ident_index(&ident).unwrap();\n let fun_def = &module[idx];\n let fun = fun_def.function();\n\n let dot = libeir_ir::text::dot_printer::function_to_dot(fun);\n print!(\"{}\", dot);\n } else {\n unimplemented!()\n }\n}\n\n#[test]\nfn rand_error() {\n let _ = env_logger::try_init();\n\n let mut eir_mod = lower(\n r#\"\n-module(rand).\n\nuniform_s(#{a:=_}, _) ->\n 0;\nuniform_s(#{b:=B}, N) ->\n N(),\n B.\n\"#,\n ParseConfig::default(),\n )\n .unwrap();\n\n for fun_def in eir_mod.function_iter() {\n let fun = fun_def.function();\n let mut out = Vec::new();\n fun.validate(&mut out);\n assert!(out.len() == 0);\n }\n\n let mut pass_manager = libeir_passes::PassManager::default();\n pass_manager.run(&mut eir_mod);\n}\n" }, { "path": "libeir_tests/src/list_comprehensions.rs", "content": "use std::rc::Rc;\n\nuse crate::lower;\n\nuse libeir_intern::Ident;\nuse libeir_ir::FunctionIdent;\nuse libeir_passes::PassManager;\nuse libeir_syntax_erl::ParseConfig;\n\nuse libeir_interpreter::{ErlEq, Term, VMState};\n\n#[test]\nfn test_list_comprehension_single_filter() {\n let _ = env_logger::try_init();\n\n let mut eir_mod = lower(\n \"\n-module(woo).\n\nwoo(N) -> [1 || erlang:is_integer(N)].\n\",\n ParseConfig::default(),\n )\n .unwrap();\n\n for fun_def in eir_mod.function_iter() {\n let fun = fun_def.function();\n let mut out = Vec::new();\n fun.validate(&mut out);\n assert!(out.len() == 0);\n }\n\n let mut pass_manager = PassManager::default();\n pass_manager.run(&mut eir_mod);\n\n for fun_def in eir_mod.function_iter() {\n let fun = fun_def.function();\n let mut out = Vec::new();\n fun.validate(&mut out);\n assert!(out.len() == 0);\n }\n\n let fun = FunctionIdent {\n module: Ident::from_str(\"woo\"),\n name: Ident::from_str(\"woo\"),\n arity: 1,\n };\n\n println!(\"{}\", eir_mod.to_text_standard());\n\n let mut vm = VMState::new();\n vm.add_builtin_modules();\n vm.add_erlang_module(eir_mod);\n\n assert!(vm.call(&fun, &[Term::Nil]).unwrap().erl_eq(&Term::Nil));\n\n {\n let out = Term::slice_to_list(&[Term::Integer(1.into()).into()], Term::Nil.into());\n assert!(vm\n .call(&fun, &[Term::Integer(1.into())])\n .unwrap()\n .erl_eq(&*out));\n }\n}\n\n#[test]\nfn test_list_comprehension_single_list_generator() {\n let _ = env_logger::try_init();\n\n let mut eir_mod = lower(\n \"\n-module(woo).\n\nwoo(L) -> [X*2 || X <- L].\n\",\n ParseConfig::default(),\n )\n .unwrap();\n\n for fun_def in eir_mod.function_iter() {\n let fun = fun_def.function();\n let mut out = Vec::new();\n fun.validate(&mut out);\n assert!(out.len() == 0);\n }\n\n let mut pass_manager = PassManager::default();\n pass_manager.run(&mut eir_mod);\n\n for fun_def in eir_mod.function_iter() {\n let fun = fun_def.function();\n let mut out = Vec::new();\n fun.validate(&mut out);\n assert!(out.len() == 0);\n }\n\n let fun = FunctionIdent {\n module: Ident::from_str(\"woo\"),\n name: Ident::from_str(\"woo\"),\n arity: 1,\n };\n\n println!(\"{}\", eir_mod.to_text_standard());\n\n let mut vm = VMState::new();\n vm.add_builtin_modules();\n vm.add_erlang_module(eir_mod);\n\n assert!(vm.call(&fun, &[Term::Nil]).unwrap().erl_eq(&Term::Nil));\n\n {\n let in_list = Term::slice_to_list(&[Term::Integer(1.into()).into()], Term::Nil.into());\n let out_list = Term::slice_to_list(&[Term::Integer(2.into()).into()], Term::Nil.into());\n assert!(vm\n .call(&fun, &[Rc::try_unwrap(in_list).unwrap()])\n .unwrap()\n .erl_eq(&*out_list));\n }\n\n {\n let in_list = Term::slice_to_list(\n &[\n Term::Integer(1.into()).into(),\n Term::Integer(2.into()).into(),\n Term::Integer(3.into()).into(),\n ],\n Term::Nil.into(),\n );\n let out_list = Term::slice_to_list(\n &[\n Term::Integer(2.into()).into(),\n Term::Integer(4.into()).into(),\n Term::Integer(6.into()).into(),\n ],\n Term::Nil.into(),\n );\n assert!(vm\n .call(&fun, &[Rc::try_unwrap(in_list).unwrap()])\n .unwrap()\n .erl_eq(&*out_list));\n }\n}\n\n#[test]\nfn test_list_comprehension_combinations() {\n let _ = env_logger::try_init();\n\n let mut eir_mod = lower(\n \"\n-module(woo).\n\ncomb([]) -> [[]];\ncomb(L) -> [[A, B] || A <- L, B <- L].\n\",\n ParseConfig::default(),\n )\n .unwrap();\n\n for fun_def in eir_mod.function_iter() {\n let fun = fun_def.function();\n let mut out = Vec::new();\n fun.validate(&mut out);\n assert!(out.len() == 0);\n }\n\n let mut pass_manager = PassManager::default();\n pass_manager.run(&mut eir_mod);\n\n for fun_def in eir_mod.function_iter() {\n let fun = fun_def.function();\n let mut out = Vec::new();\n fun.validate(&mut out);\n println!(\"{:?}\", out);\n assert!(out.len() == 0);\n }\n\n let fun = FunctionIdent {\n module: Ident::from_str(\"woo\"),\n name: Ident::from_str(\"comb\"),\n arity: 1,\n };\n\n let mut vm = VMState::new();\n vm.add_builtin_modules();\n vm.add_erlang_module(eir_mod);\n\n {\n let arg = Term::slice_to_list(\n &[Term::new_atom(\"b\").into(), Term::new_atom(\"u\").into()],\n Term::Nil.into(),\n );\n\n let out = Term::slice_to_list(\n &[\n Term::slice_to_list(\n &[Term::new_atom(\"b\").into(), Term::new_atom(\"b\").into()],\n Term::Nil.into(),\n ),\n Term::slice_to_list(\n &[Term::new_atom(\"b\").into(), Term::new_atom(\"u\").into()],\n Term::Nil.into(),\n ),\n Term::slice_to_list(\n &[Term::new_atom(\"u\").into(), Term::new_atom(\"b\").into()],\n Term::Nil.into(),\n ),\n Term::slice_to_list(\n &[Term::new_atom(\"u\").into(), Term::new_atom(\"u\").into()],\n Term::Nil.into(),\n ),\n ],\n Term::Nil.into(),\n );\n\n let res = vm.call(&fun, &[Rc::try_unwrap(arg).unwrap()]).unwrap();\n assert!(res.erl_eq(&out));\n }\n}\n\n#[test]\nfn test_basic_comprehension() {\n let _ = env_logger::try_init();\n\n let mut eir_mod = lower(\n \"\n-module(woo).\n\nperms(L) -> [H || H <- L].\n\",\n ParseConfig::default(),\n )\n .unwrap();\n\n for fun_def in eir_mod.function_iter() {\n let fun = fun_def.function();\n let mut out = Vec::new();\n fun.validate(&mut out);\n assert!(out.len() == 0);\n }\n\n let mut pass_manager = PassManager::default();\n pass_manager.run(&mut eir_mod);\n\n for fun_def in eir_mod.function_iter() {\n let fun = fun_def.function();\n let mut out = Vec::new();\n fun.validate(&mut out);\n println!(\"{:?}\", out);\n assert!(out.len() == 0);\n\n println!(\"{}\", fun.to_text_standard());\n\n libeir_lowerutils::analyze(fun);\n }\n\n println!(\"{}\", eir_mod.to_text_standard());\n}\n\n#[test]\nfn test_list_comprehension_permutations() {\n let _ = env_logger::try_init();\n\n let mut eir_mod = lower(\n \"\n-module(woo).\n\nperms([]) -> [[]];\nperms(L) -> [[H|T] || H <- L, T <- perms(L--[H])].\n\",\n ParseConfig::default(),\n )\n .unwrap();\n\n for fun_def in eir_mod.function_iter() {\n let fun = fun_def.function();\n let mut out = Vec::new();\n fun.validate(&mut out);\n assert!(out.len() == 0);\n }\n\n let mut pass_manager = PassManager::default();\n pass_manager.run(&mut eir_mod);\n\n for fun_def in eir_mod.function_iter() {\n let fun = fun_def.function();\n let mut out = Vec::new();\n fun.validate(&mut out);\n assert!(out.len() == 0);\n\n let analysis = libeir_lowerutils::analyze(fun);\n dbg!(analysis);\n }\n\n println!(\"{}\", eir_mod.to_text_standard());\n\n let fun = FunctionIdent {\n module: Ident::from_str(\"woo\"),\n name: Ident::from_str(\"perms\"),\n arity: 1,\n };\n\n let mut vm = VMState::new();\n vm.add_builtin_modules();\n vm.add_erlang_module(eir_mod);\n\n {\n let b: Rc = Term::new_atom(\"b\").into();\n let u: Rc = Term::new_atom(\"u\").into();\n let g: Rc = Term::new_atom(\"g\").into();\n\n let arg = Term::slice_to_list(&[b.clone(), u.clone(), g.clone()], Term::Nil.into());\n\n let out = Term::slice_to_list(\n &[\n Term::slice_to_list(&[b.clone(), u.clone(), g.clone()], Term::Nil.into()),\n Term::slice_to_list(&[b.clone(), g.clone(), u.clone()], Term::Nil.into()),\n Term::slice_to_list(&[u.clone(), b.clone(), g.clone()], Term::Nil.into()),\n Term::slice_to_list(&[u.clone(), g.clone(), b.clone()], Term::Nil.into()),\n Term::slice_to_list(&[g.clone(), b.clone(), u.clone()], Term::Nil.into()),\n Term::slice_to_list(&[g.clone(), u.clone(), b.clone()], Term::Nil.into()),\n ],\n Term::Nil.into(),\n );\n\n let res = vm.call(&fun, &[Rc::try_unwrap(arg).unwrap()]).unwrap();\n\n println!(\"{:?}\", res);\n println!(\"{:?}\", out);\n\n assert!(res.erl_eq(&out));\n }\n}\n\n#[ignore]\n#[test]\nfn test_binary_comprehension() {\n let _ = env_logger::try_init();\n\n let mut eir_mod = lower(\n \"\n-module(woo).\n\nwoo(N) -> [X || <> <= <<1, 2, 3>>].\n\",\n ParseConfig::default(),\n )\n .unwrap();\n\n for fun_def in eir_mod.function_iter() {\n let fun = fun_def.function();\n let mut out = Vec::new();\n fun.validate(&mut out);\n assert!(out.len() == 0);\n }\n\n let mut pass_manager = PassManager::default();\n pass_manager.run(&mut eir_mod);\n\n for fun_def in eir_mod.function_iter() {\n let fun = fun_def.function();\n let mut out = Vec::new();\n fun.validate(&mut out);\n assert!(out.len() == 0);\n }\n\n let fun = FunctionIdent {\n module: Ident::from_str(\"woo\"),\n name: Ident::from_str(\"woo\"),\n arity: 1,\n };\n\n println!(\"{}\", eir_mod.to_text_standard());\n\n let mut vm = VMState::new();\n vm.add_builtin_modules();\n vm.add_erlang_module(eir_mod);\n\n assert!(vm.call(&fun, &[Term::Nil]).unwrap().erl_eq(&Term::Nil));\n\n {\n let out = Term::slice_to_list(&[Term::Integer(1.into()).into()], Term::Nil.into());\n assert!(vm\n .call(&fun, &[Term::Integer(1.into())])\n .unwrap()\n .erl_eq(&*out));\n }\n}\n" }, { "path": "libeir_tests/src/otp/mod.rs", "content": "use std::path::PathBuf;\n\nuse crate::ct_runner::run_ct_suite;\nuse crate::{lower, lower_file, ParseConfig};\n\nuse libeir_intern::Ident;\nuse libeir_passes::PassManager;\n\nuse libeir_interpreter::VMState;\n\nuse libeir_lowerutils::analyze;\n\n#[ignore]\n#[test]\nfn compiler() {\n let _ = env_logger::try_init();\n\n let mut config = ParseConfig::default();\n\n config\n .include_paths\n .push_front(PathBuf::from(\"../otp/lib/compiler/src/\"));\n config\n .include_paths\n .push_front(PathBuf::from(\"../otp/bootstrap/lib/stdlib/include/\"));\n\n let mut eir_mod = lower_file(\"../otp/lib/compiler/src/compile.erl\", config).unwrap();\n\n for fun_def in eir_mod.function_iter() {\n let fun = fun_def.function();\n fun.graph_validate_global();\n }\n\n let mut pass_manager = PassManager::default();\n pass_manager.run(&mut eir_mod);\n}\n\n#[ignore]\n#[test]\nfn beam_disasm() {\n let _ = env_logger::try_init();\n\n let mut config = ParseConfig::default();\n\n config\n .include_paths\n .push_front(PathBuf::from(\"../otp/lib/compiler/src/\"));\n config\n .include_paths\n .push_front(PathBuf::from(\"../otp/bootstrap/lib/stdlib/include/\"));\n\n let mut eir_mod = lower_file(\"../otp/lib/compiler/src/beam_disasm.erl\", config).unwrap();\n\n for fun_def in eir_mod.function_iter() {\n let fun = fun_def.function();\n fun.graph_validate_global();\n }\n\n let mut pass_manager = PassManager::default();\n pass_manager.run(&mut eir_mod);\n}\n\n#[ignore]\n#[test]\nfn core_parse() {\n let _ = env_logger::try_init();\n\n let mut config = ParseConfig::default();\n\n config\n .include_paths\n .push_front(PathBuf::from(\"../otp/lib/compiler/src/\"));\n config\n .include_paths\n .push_front(PathBuf::from(\"../otp/bootstrap/lib/stdlib/include/\"));\n\n let mut eir_mod = lower_file(\"../otp/lib/compiler/src/core_parse.erl\", config).unwrap();\n\n for fun_def in eir_mod.function_iter() {\n let fun = fun_def.function();\n fun.graph_validate_global();\n }\n\n let mut pass_manager = PassManager::default();\n pass_manager.run(&mut eir_mod);\n}\n\n#[ignore]\n#[test]\nfn maps() {\n let _ = env_logger::try_init();\n\n let config = ParseConfig::default();\n let mut eir_mod = lower_file(\"../otp/lib/stdlib/src/maps.erl\", config).unwrap();\n\n for fun_def in eir_mod.function_iter() {\n let fun = fun_def.function();\n fun.graph_validate_global();\n }\n\n let mut pass_manager = PassManager::default();\n pass_manager.run(&mut eir_mod);\n}\n\n#[ignore]\n#[test]\nfn match_suite() {\n let _ = env_logger::try_init();\n\n let mut config = ParseConfig::default();\n config.code_paths.push_front(PathBuf::from(\"../otp/lib/\"));\n\n let mut eir_mod = lower_file(\"../otp/lib/compiler/test/match_SUITE.erl\", config).unwrap();\n\n for fun_def in eir_mod.function_iter() {\n let fun = fun_def.function();\n println!(\"{}\", fun.ident());\n fun.graph_validate_global();\n fun.live_values();\n }\n\n let mut pass_manager = PassManager::default();\n pass_manager.run(&mut eir_mod);\n\n for fun_def in eir_mod.function_iter() {\n let fun = fun_def.function();\n println!(\"{}\", fun.ident());\n println!(\"{}\", fun.to_text_standard());\n fun.graph_validate_global();\n fun.live_values();\n }\n\n let mut vm = VMState::new();\n vm.add_builtin_modules();\n vm.add_erlang_module(eir_mod);\n\n run_ct_suite(&mut vm, Ident::from_str(\"match_SUITE\"));\n}\n\n#[ignore]\n#[test]\nfn bs_match_suite() {\n let _ = env_logger::try_init();\n\n let mut config = ParseConfig::default();\n config.code_paths.push_front(PathBuf::from(\"../otp/lib/\"));\n\n let mut eir_mod = lower_file(\"../otp_build/bs_match_SUITE_patched.erl\", config).unwrap();\n\n for fun_def in eir_mod.function_iter() {\n let fun = fun_def.function();\n fun.graph_validate_global();\n }\n\n let mut pass_manager = PassManager::default();\n pass_manager.run(&mut eir_mod);\n\n let mut vm = VMState::new();\n vm.add_builtin_modules();\n vm.add_erlang_module(eir_mod);\n\n run_ct_suite(&mut vm, Ident::from_str(\"bs_match_SUITE\"));\n}\n\n#[ignore]\n#[test]\nfn maps_suite() {\n let _ = env_logger::try_init();\n\n let config = ParseConfig::default();\n let mut maps_eir_mod = lower_file(\"../otp/lib/stdlib/src/maps.erl\", config).unwrap();\n\n let config = ParseConfig::default();\n let mut eir_mod = lower_file(\"../otp/lib/compiler/test/map_SUITE.erl\", config).unwrap();\n\n for fun_def in maps_eir_mod.function_iter() {\n let fun = fun_def.function();\n fun.graph_validate_global();\n }\n for fun_def in eir_mod.function_iter() {\n let fun = fun_def.function();\n fun.graph_validate_global();\n }\n\n let mut pass_manager = PassManager::default();\n pass_manager.run(&mut maps_eir_mod);\n pass_manager.run(&mut eir_mod);\n\n let mut vm = VMState::new();\n vm.add_builtin_modules();\n vm.add_erlang_module(eir_mod);\n vm.add_erlang_module(maps_eir_mod);\n\n run_ct_suite(&mut vm, Ident::from_str(\"map_SUITE\"));\n}\n\n#[ignore]\n#[test]\nfn xmerl_scan() {\n let _ = env_logger::try_init();\n\n let mut config = ParseConfig::default();\n config.code_paths.push_front(PathBuf::from(\"../otp/lib/\"));\n config\n .include_paths\n .push_front(PathBuf::from(\"../otp/lib/xmerl/src/\"));\n config\n .include_paths\n .push_front(PathBuf::from(\"../otp/lib/xmerl/include/\"));\n\n let mut eir_mod = lower_file(\"../otp/lib/xmerl/src/xmerl_scan.erl\", config).unwrap();\n\n for fun_def in eir_mod.function_iter() {\n let fun = fun_def.function();\n fun.graph_validate_global();\n }\n\n let mut pass_manager = PassManager::default();\n pass_manager.run(&mut eir_mod);\n}\n\n#[ignore]\n#[test]\nfn xmerl_sax_parser_utf8() {\n let _ = env_logger::try_init();\n\n let mut config = ParseConfig::default();\n config.code_paths.push_front(PathBuf::from(\"../otp/lib/\"));\n config\n .include_paths\n .push_front(PathBuf::from(\"../otp/lib/xmerl/src/\"));\n config\n .include_paths\n .push_front(PathBuf::from(\"../otp/lib/xmerl/include/\"));\n\n let mut eir_mod =\n lower_file(\"../otp/lib/xmerl/src/xmerl_sax_parser_latin1.erl\", config).unwrap();\n\n for fun_def in eir_mod.function_iter() {\n let fun = fun_def.function();\n fun.graph_validate_global();\n }\n\n let mut pass_manager = PassManager::default();\n pass_manager.run(&mut eir_mod);\n}\n\n#[ignore]\n#[test]\nfn foo() {\n let _ = env_logger::try_init();\n\n let config = ParseConfig::default();\n let mut eir_mod = lower_file(\"foo.erl\", config).unwrap();\n\n for fun_def in eir_mod.function_iter() {\n let fun = fun_def.function();\n fun.graph_validate_global();\n }\n\n let mut pass_manager = PassManager::default();\n pass_manager.run(&mut eir_mod);\n\n panic!(\"{:?}\");\n}\n\n#[test]\nfn aa() {\n let _ = env_logger::try_init();\n\n let text = \"\n-module(foo).\n\ndo_map_vars_used(X, Y, Map) ->\n case {X,Y} of\n T ->\n %% core_lib:is_var_used/2 would not consider T used.\n #{T:=42,v:=Val} = Map,\nVal\n end.\n\";\n\n let config = ParseConfig::default();\n let mut eir_mod = lower(text, config).unwrap();\n\n for fun_def in eir_mod.function_iter() {\n let fun = fun_def.function();\n fun.graph_validate_global();\n }\n\n let mut pass_manager = PassManager::default();\n pass_manager.run(&mut eir_mod);\n\n for fun_def in eir_mod.function_iter() {\n let fun = fun_def.function();\n fun.live_values();\n }\n}\n\n#[test]\nfn unary_op_1() {\n let _ = env_logger::try_init();\n\n let text = \"\n-module(foo).\n\nunary_op_1(Vop@1) ->\n %% If all optimizations are working as they should, there should\n %% be no stack frame and all '=:=' tests should be coalesced into\n %% a single select_val instruction.\n\n case Vop@1 =:= '&' of\n true ->\n {non_associative,30};\n false ->\n case\n case Vop@1 =:= '^' of\n true ->\n true;\n false ->\n case Vop@1 =:= 'not' of\n true ->\n true;\n false ->\n case Vop@1 =:= '+' of\n true ->\n true;\n false ->\n case Vop@1 =:= '-' of\n true ->\n true;\n false ->\n case Vop@1 =:= '~~~' of\n true ->\n true;\n false ->\n Vop@1 =:= '!'\n end\n end\n end\n end\n end\n of\n true ->\n {non_associative,300};\n false ->\n case Vop@1 =:= '@' of\n true ->\n {non_associative,320};\n false ->\n error\n end\n end\n end.\n\";\n\n let config = ParseConfig::default();\n let mut eir_mod = lower(text, config).unwrap();\n\n for fun_def in eir_mod.function_iter() {\n let fun = fun_def.function();\n fun.graph_validate_global();\n }\n\n let mut pass_manager = PassManager::default();\n pass_manager.run(&mut eir_mod);\n\n for fun_def in eir_mod.function_iter() {\n let fun = fun_def.function();\n fun.live_values();\n }\n}\n\n#[test]\nfn unary_op_1_a() {\n let _ = env_logger::try_init();\n\n let text = \"\n-module(foobarrr).\n\nunary_op_1(Vop@1) ->\n case\n case Vop@1 =:= '^' of\n true ->\n a;\n false ->\n b\n end\n of\n true ->\n c\n end.\n\";\n\n let config = ParseConfig::default();\n let mut eir_mod = lower(text, config).unwrap();\n\n for fun_def in eir_mod.function_iter() {\n let fun = fun_def.function();\n fun.graph_validate_global();\n }\n\n let mut pass_manager = PassManager::default();\n pass_manager.run(&mut eir_mod);\n\n for fun_def in eir_mod.function_iter() {\n let fun = fun_def.function();\n fun.live_values();\n }\n}\n" }, { "path": "libeir_tests/src/patterns.rs", "content": "use std::rc::Rc;\n\nuse super::lower;\n\nuse libeir_intern::{Ident, Symbol};\nuse libeir_ir::FunctionIdent;\nuse libeir_passes::PassManager;\nuse libeir_syntax_erl::ParseConfig;\n\nuse libeir_interpreter::{ErlEq, Term, VMState};\n\n#[test]\nfn test_pattern_equality() {\n let _ = env_logger::try_init();\n\n let mut eir_mod = lower(\n \"\n-module(woo).\n\nbasic_pat(A, A) -> true;\nbasic_pat(_, _) -> false.\n\",\n ParseConfig::default(),\n )\n .unwrap();\n\n let mut pass_manager = PassManager::default();\n pass_manager.run(&mut eir_mod);\n\n let fun = FunctionIdent {\n module: Ident::from_str(\"woo\"),\n name: Ident::from_str(\"basic_pat\"),\n arity: 2,\n };\n\n let mut vm = VMState::new();\n vm.add_builtin_modules();\n vm.add_erlang_module(eir_mod);\n\n assert!(vm.call(&fun, &[1.into(), 1.into()]).unwrap().as_boolean() == Some(true));\n assert!(vm.call(&fun, &[1.into(), 2.into()]).unwrap().as_boolean() == Some(false));\n}\n\n#[test]\nfn test_tuple_pattern() {\n let _ = env_logger::try_init();\n\n let mut eir_mod = lower(\n \"\n-module(woo).\n\nwoo({1, 2}) -> 1;\nwoo({1, 2, 3}) -> 2;\nwoo(_) -> 3.\n\",\n ParseConfig::default(),\n )\n .unwrap();\n\n let mut pass_manager = PassManager::default();\n pass_manager.run(&mut eir_mod);\n\n let fun = FunctionIdent {\n module: Ident::from_str(\"woo\"),\n name: Ident::from_str(\"woo\"),\n arity: 1,\n };\n\n let mut vm = VMState::new();\n vm.add_builtin_modules();\n vm.add_erlang_module(eir_mod);\n\n assert!(vm.call(&fun, &[1.into()]).unwrap().as_i64() == Some(3));\n\n {\n let arg = Term::Tuple(vec![\n Term::Integer(1.into()).into(),\n Term::Integer(2.into()).into(),\n ]);\n assert!(vm.call(&fun, &[arg.into()]).unwrap().as_i64() == Some(1));\n }\n\n {\n let arg = Term::Tuple(vec![\n Term::Integer(2.into()).into(),\n Term::Integer(2.into()).into(),\n ]);\n assert!(vm.call(&fun, &[arg.into()]).unwrap().as_i64() == Some(3));\n }\n\n {\n let arg = Term::Tuple(vec![\n Term::Integer(1.into()).into(),\n Term::Integer(2.into()).into(),\n Term::Integer(3.into()).into(),\n ]);\n assert!(vm.call(&fun, &[arg.into()]).unwrap().as_i64() == Some(2));\n }\n\n {\n let arg = Term::Tuple(vec![\n Term::Integer(1.into()).into(),\n Term::Integer(2.into()).into(),\n Term::Integer(2.into()).into(),\n ]);\n assert!(vm.call(&fun, &[arg.into()]).unwrap().as_i64() == Some(3));\n }\n}\n\n#[test]\nfn test_list_pattern() {\n let _ = env_logger::try_init();\n\n let mut eir_mod = lower(\n \"\n-module(woo).\n\nwoo([6 | 7]) -> 1;\nwoo([1, 2]) -> 2;\nwoo([]) -> 3;\nwoo(_) -> 4.\n\",\n ParseConfig::default(),\n )\n .unwrap();\n\n let mut pass_manager = PassManager::default();\n pass_manager.run(&mut eir_mod);\n\n let fun = FunctionIdent {\n module: Ident::from_str(\"woo\"),\n name: Ident::from_str(\"woo\"),\n arity: 1,\n };\n\n let mut vm = VMState::new();\n vm.add_builtin_modules();\n vm.add_erlang_module(eir_mod);\n\n assert!(vm.call(&fun, &[1.into()]).unwrap().as_i64() == Some(4));\n\n {\n let arg = Term::slice_to_list(\n &[\n Term::Integer(1.into()).into(),\n Term::Integer(2.into()).into(),\n ],\n Term::Nil.into(),\n );\n assert!(\n vm.call(&fun, &[Rc::try_unwrap(arg).unwrap()])\n .unwrap()\n .as_i64()\n == Some(2)\n );\n }\n}\n\n#[test]\nfn test_fun_atom_pattern() {\n let _ = env_logger::try_init();\n\n let mut eir_mod = lower(\n \"\n-module(woo).\n\nwoo(abc) -> 1;\nwoo(def) -> 2.\n\",\n ParseConfig::default(),\n )\n .unwrap();\n\n let mut pass_manager = PassManager::default();\n pass_manager.run(&mut eir_mod);\n\n let fun = FunctionIdent {\n module: Ident::from_str(\"woo\"),\n name: Ident::from_str(\"woo\"),\n arity: 1,\n };\n\n let mut vm = VMState::new();\n vm.add_builtin_modules();\n vm.add_erlang_module(eir_mod);\n\n assert!(\n vm.call(&fun, &[Term::Atom(Symbol::intern(\"abc\")).into()])\n .unwrap()\n .as_i64()\n == Some(1)\n );\n\n assert!(\n vm.call(&fun, &[Term::Atom(Symbol::intern(\"def\")).into()])\n .unwrap()\n .as_i64()\n == Some(2)\n );\n\n {\n let res = vm.call(&fun, &[Term::Nil.into()]).err().unwrap();\n assert!(res.0.erl_eq(&Term::Atom(Symbol::intern(\"error\")).into()));\n assert!(res\n .1\n .erl_eq(&Term::Atom(Symbol::intern(\"function_clause\")).into()));\n }\n}\n\n#[test]\nfn test_case_atom_pattern() {\n let _ = env_logger::try_init();\n\n let mut eir_mod = lower(\n \"\n-module(woo).\n\nwoo(A) -> case A of\n abc -> 1;\n def -> 2\nend.\n\",\n ParseConfig::default(),\n )\n .unwrap();\n\n let mut pass_manager = PassManager::default();\n pass_manager.run(&mut eir_mod);\n\n let fun = FunctionIdent {\n module: Ident::from_str(\"woo\"),\n name: Ident::from_str(\"woo\"),\n arity: 1,\n };\n\n let mut vm = VMState::new();\n vm.add_builtin_modules();\n vm.add_erlang_module(eir_mod);\n\n assert!(\n vm.call(&fun, &[Term::Atom(Symbol::intern(\"abc\")).into()])\n .unwrap()\n .as_i64()\n == Some(1)\n );\n\n assert!(\n vm.call(&fun, &[Term::Atom(Symbol::intern(\"def\")).into()])\n .unwrap()\n .as_i64()\n == Some(2)\n );\n\n {\n let res = vm\n .call(&fun, &[Term::Atom(Symbol::intern(\"aaa\")).into()])\n .err()\n .unwrap();\n assert!(res.0.erl_eq(&Term::Atom(Symbol::intern(\"error\")).into()));\n assert!(res.1.erl_eq(&Term::Tuple(vec![\n Term::Atom(Symbol::intern(\"case_clause\")).into(),\n Term::Atom(Symbol::intern(\"aaa\")).into(),\n ])));\n }\n}\n" }, { "path": "libeir_tests/src/records.rs", "content": "use super::{lower, write_dot};\n\nuse libeir_intern::{Ident, Symbol};\nuse libeir_ir::FunctionIdent;\nuse libeir_passes::PassManager;\nuse libeir_syntax_erl::ParseConfig;\n\nuse libeir_interpreter::{ErlEq, Term, VMState};\n\n#[test]\nfn record_creation() {\n let _ = env_logger::try_init();\n\n let mut eir_mod = lower(\n \"\n-module(woo).\n\n-record(person, {name, phone, address}).\n-record(alien, {name, planet = zorgon}).\n\ncreate_1(A) -> #person{name=A}.\ncreate_2(A) -> #person{address=A}.\ncreate_3(A) -> #person{address=A, phone=12}.\n\ncreate_4(A) -> #alien{name=A}.\ncreate_5(A, B) -> #alien{name=A, planet=B}.\n\",\n ParseConfig::default(),\n )\n .unwrap();\n\n let mut pass_manager = PassManager::default();\n pass_manager.run(&mut eir_mod);\n\n let fun = FunctionIdent {\n module: Ident::from_str(\"woo\"),\n name: Ident::from_str(\"create_1\"),\n arity: 1,\n };\n\n write_dot(&eir_mod, Some(fun.clone()));\n\n let mut vm = VMState::new();\n vm.add_builtin_modules();\n vm.add_erlang_module(eir_mod);\n\n {\n let fun = FunctionIdent {\n module: Ident::from_str(\"woo\"),\n name: Ident::from_str(\"create_1\"),\n arity: 1,\n };\n\n let out = Term::Tuple(vec![\n Term::Atom(Symbol::intern(\"person\")).into(),\n Term::Integer(1.into()).into(),\n Term::Atom(Symbol::intern(\"undefined\")).into(),\n Term::Atom(Symbol::intern(\"undefined\")).into(),\n ]);\n assert!(vm.call(&fun, &[1.into()]).unwrap().erl_eq(&out));\n }\n\n {\n let fun = FunctionIdent {\n module: Ident::from_str(\"woo\"),\n name: Ident::from_str(\"create_2\"),\n arity: 1,\n };\n\n let out = Term::Tuple(vec![\n Term::Atom(Symbol::intern(\"person\")).into(),\n Term::Atom(Symbol::intern(\"undefined\")).into(),\n Term::Atom(Symbol::intern(\"undefined\")).into(),\n Term::Integer(1.into()).into(),\n ]);\n assert!(vm.call(&fun, &[1.into()]).unwrap().erl_eq(&out));\n }\n\n {\n let fun = FunctionIdent {\n module: Ident::from_str(\"woo\"),\n name: Ident::from_str(\"create_3\"),\n arity: 1,\n };\n\n let out = Term::Tuple(vec![\n Term::Atom(Symbol::intern(\"person\")).into(),\n Term::Atom(Symbol::intern(\"undefined\")).into(),\n Term::Integer(12.into()).into(),\n Term::Integer(2.into()).into(),\n ]);\n assert!(vm.call(&fun, &[2.into()]).unwrap().erl_eq(&out));\n }\n\n {\n let fun = FunctionIdent {\n module: Ident::from_str(\"woo\"),\n name: Ident::from_str(\"create_4\"),\n arity: 1,\n };\n\n let out = Term::Tuple(vec![\n Term::Atom(Symbol::intern(\"alien\")).into(),\n Term::Atom(Symbol::intern(\"zsf\")).into(),\n Term::Atom(Symbol::intern(\"zorgon\")).into(),\n ]);\n assert!(vm\n .call(&fun, &[Term::Atom(Symbol::intern(\"zsf\")).into()])\n .unwrap()\n .erl_eq(&out));\n }\n\n {\n let fun = FunctionIdent {\n module: Ident::from_str(\"woo\"),\n name: Ident::from_str(\"create_5\"),\n arity: 2,\n };\n\n let out = Term::Tuple(vec![\n Term::Atom(Symbol::intern(\"alien\")).into(),\n Term::Atom(Symbol::intern(\"zsf\")).into(),\n Term::Atom(Symbol::intern(\"xon\")).into(),\n ]);\n assert!(vm\n .call(\n &fun,\n &[\n Term::Atom(Symbol::intern(\"zsf\")).into(),\n Term::Atom(Symbol::intern(\"xon\")).into(),\n ]\n )\n .unwrap()\n .erl_eq(&out));\n }\n}\n\n#[test]\nfn record_creation_a() {\n let _ = env_logger::try_init();\n\n let mut eir_mod = lower(\n \"\n-module(woohoo).\n\n-record(person, {name, phone, address}).\ncreate_1(A) -> #person{name=A}.\n\",\n ParseConfig::default(),\n )\n .unwrap();\n\n let mut pass_manager = PassManager::default();\n pass_manager.run(&mut eir_mod);\n\n let fun = FunctionIdent {\n module: Ident::from_str(\"woo\"),\n name: Ident::from_str(\"create_1\"),\n arity: 1,\n };\n\n let mut vm = VMState::new();\n vm.add_builtin_modules();\n vm.add_erlang_module(eir_mod);\n}\n" }, { "path": "otp_build/bs_match_SUITE.erl", "content": "%%\n%% %CopyrightBegin%\n%%\n%% Copyright Ericsson AB 2005-2018. All Rights Reserved.\n%%\n%% Licensed under the Apache License, Version 2.0 (the \"License\");\n%% you may not use this file except in compliance with the License.\n%% You may obtain a copy of the License at\n%%\n%% http://www.apache.org/licenses/LICENSE-2.0\n%%\n%% Unless required by applicable law or agreed to in writing, software\n%% distributed under the License is distributed on an \"AS IS\" BASIS,\n%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n%% See the License for the specific language governing permissions and\n%% limitations under the License.\n%%\n%% %CopyrightEnd%\n%%\n\n-module(bs_match_SUITE).\n-compile(nowarn_shadow_vars).\n\n-export([all/0, suite/0,groups/0,init_per_suite/1, end_per_suite/1, \n\t init_per_group/2,end_per_group/2,\n\t init_per_testcase/2,end_per_testcase/2,\n\t size_shadow/1,int_float/1,otp_5269/1,null_fields/1,wiger/1,\n\t bin_tail/1,save_restore/1,\n\t partitioned_bs_match/1,function_clause/1,\n\t unit/1,shared_sub_bins/1,bin_and_float/1,\n\t dec_subidentifiers/1,skip_optional_tag/1,decode_integer/1,\n\t wfbm/1,degenerated_match/1,bs_sum/1,coverage/1,\n\t multiple_uses/1,zero_label/1,followed_by_catch/1,\n\t matching_meets_construction/1,simon/1,matching_and_andalso/1,\n\t otp_7188/1,otp_7233/1,otp_7240/1,otp_7498/1,\n\t match_string/1,zero_width/1,bad_size/1,haystack/1,\n\t cover_beam_bool/1,matched_out_size/1,follow_fail_branch/1,\n\t no_partition/1,calling_a_binary/1,binary_in_map/1,\n\t match_string_opt/1,select_on_integer/1,\n\t map_and_binary/1,unsafe_branch_caching/1,\n\t bad_literals/1,good_literals/1,constant_propagation/1,\n\t parse_xml/1,get_payload/1,escape/1,num_slots_different/1,\n beam_bsm/1,guard/1,is_ascii/1,non_opt_eq/1,erl_689/1,\n bs_start_match2_defs/1]).\n\n-export([coverage_id/1,coverage_external_ignore/2]).\n\n-include_lib(\"common_test/include/ct.hrl\").\n%-include_lib(\"syntax_tools/include/merl.hrl\").\n\n\nsuite() ->\n [{ct_hooks,[ts_install_cth]},\n {timetrap,{minutes,1}}].\n\nall() -> \n [{group,p}].\n\ngroups() -> \n [{p,[parallel],\n [size_shadow,int_float,otp_5269,null_fields,wiger,\n bin_tail,save_restore,\n partitioned_bs_match,function_clause,unit,\n shared_sub_bins,bin_and_float,dec_subidentifiers,\n skip_optional_tag,decode_integer,wfbm,degenerated_match,bs_sum,\n coverage,multiple_uses,zero_label,followed_by_catch,\n matching_meets_construction,simon,\n matching_and_andalso,otp_7188,otp_7233,otp_7240,\n otp_7498,match_string,zero_width,bad_size,haystack,\n cover_beam_bool,matched_out_size,follow_fail_branch,\n no_partition,calling_a_binary,binary_in_map,\n match_string_opt,select_on_integer,\n map_and_binary,unsafe_branch_caching,\n% bad_literals,good_literals,constant_propagation,parse_xml,\n good_literals,constant_propagation,parse_xml,\n get_payload,escape,num_slots_different,\n beam_bsm,guard,is_ascii,non_opt_eq,erl_689,\n bs_start_match2_defs]}].\n\n\ninit_per_suite(Config) ->\n test_lib:recompile(?MODULE),\n Config.\n\nend_per_suite(_Config) ->\n ok.\n\ninit_per_group(_GroupName, Config) ->\n Config.\n\nend_per_group(_GroupName, Config) ->\n Config.\n\n\ninit_per_testcase(Case, Config) when is_atom(Case), is_list(Config) ->\n Config.\n\nend_per_testcase(Case, Config) when is_atom(Case), is_list(Config) ->\n ok.\n\nsize_shadow(Config) when is_list(Config) ->\n %% Originally OTP-5270.\n 7 = size_shadow_1(),\n 7 = size_shadow_2(8),\n 7 = size_shadow_3(),\n no = size_shadow_4(8),\n Any = {any,term,goes},\n {2577,Any,-175,whatever} =\n\t(size_shadow_5(Any, 12))(<<2577:12>>, -175, whatever),\n {7777,Any,42,whatever} =\n\t(size_shadow_6(Any, 13))(42, <<7777:13>>, whatever),\n {<<45>>,<<>>} = size_shadow_7({int,1}, <<1:16,45>>),\n {'EXIT',{function_clause,_}} =\n\t(catch size_shadow_7({int,42}, <<1:16,45>>)),\n ok.\n\nsize_shadow_1() ->\n L = 8,\n F = fun(<>) -> B end,\n F(<<16:8, 7:16>>).\n\nsize_shadow_2(L) ->\n F = fun(<>) -> B end,\n F(<<16:8, 7:16>>).\n\nsize_shadow_3() ->\n L = 8,\n F = fun(<>) -> B end,\n F(<<16:8, 7:16,16:16>>).\n\nsize_shadow_4(L) ->\n F = fun(<>) -> B;\n\t (_) -> no end,\n F(<<16:8, 7:16,15:16>>).\n\nsize_shadow_5(X, Y) ->\n fun (<< A:Y >>, Y, B) -> fum(A, X, Y, B) end.\n\nsize_shadow_6(X, Y) ->\n fun (Y, << A:Y >>, B) -> fum(A, X, Y, B) end.\n\nfum(A, B, C, D) ->\n {A,B,C,D}.\n\nsize_shadow_7({int,N}, <>) ->\n {B,T}.\n\n\nint_float(Config) when is_list(Config) ->\n %% OTP-5323\n <<103133.0:64/float>> = <<103133:64/float>>,\n <<103133:64/float>> = <<103133:64/float>>,\n\n %% Coverage of error cases in sys_pre_expand:coerce_to_float/2.\n case id(default) of\n\t<<(1 bsl 1024):64/float>> ->\n\t ct:fail(should_not_match);\n\tdefault ->\n\t ok\n end.\n\n%% Stolen from erl_eval_SUITE and modified.\n%% OTP-5269. Bugs in the bit syntax.\notp_5269(Config) when is_list(Config) ->\n check(fun() -> L = 8,\n\t\t F = fun(<>) -> B end,\n\t\t F(<<16:8, 7:16>>)\n end,\n 7),\n check(fun() -> L = 8, <> = <<16:8, 7:16>>, B end,\n\t 7),\n check(fun() -> U = 8, (fun(<>) -> U end)(<<32:8>>) end,\n\t 32),\n check(fun() -> U = 8, [U || <> <- [<<32:8>>]] end,\n\t [32]),\n check(fun() -> [X || <> <- [<<16:8,19:16>>],\n\t\t\t <> <- [<>]] end,\n\t [19]),\n check(fun() -> A = 4, B = 28, bit_size(<<13:(A+(X=B))>>), X end,\n\t 28),\n check(fun() ->\n\t\t <> = <<2,\"AB\",\"CD\">>,\n\t\t {Size,B,Rest}\n\t end,\n\t {2,<<\"AB\">>,<<\"CD\">>}),\n check(fun() -> X = 32,\n\t\t [X || <> <- [<<1:32>>,<<2:32>>,<<3:8>>]] end,\n %% \"binsize variable\" ^\n\t [1,2]),\n check(fun() ->\n\t\t (fun (<>) ->\n\t\t\t case A of\n\t\t\t B -> wrong;\n\t\t\t _ -> ok\n\t\t\t end\n\t\t end)(<<1,2,3,4>>) end,\n\t ok),\n ok.\n\nnull_fields(Config) when is_list(Config) ->\n check(fun() ->\n\t\t W = id(0),\n\t\t F = fun(<<_:W>>) -> tail;\n\t\t\t (<<>>) -> empty\n\t\t end,\n\t\t F(<<>>)\n\t end, tail),\n check(fun() ->\n\t\t F = fun(<<_/binary>>) -> tail;\n\t\t\t (<<>>) -> empty\n\t\t end,\n\t\t F(<<>>)\n\t end, tail),\n ok.\n\nwiger(Config) when is_list(Config) ->\n ok1 = wcheck(<<3>>),\n ok2 = wcheck(<<1,2,3>>),\n ok3 = wcheck(<<4>>),\n {error,<<1,2,3,4>>} = wcheck(<<1,2,3,4>>),\n {error,<<>>} = wcheck(<<>>),\n ok.\n\nwcheck(<>) when A==3->\n ok1;\nwcheck(<<_,_:2/binary>>) ->\n ok2;\nwcheck(<<_>>) ->\n ok3;\nwcheck(Other) ->\n {error,Other}.\n\nbin_tail(Config) when is_list(Config) ->\n S = <<\"abcde\">>,\n $a = bin_tail_c(S, 0),\n $c = bin_tail_c(S, 2),\n $e = bin_tail_c(S, 4),\n {'EXIT',_} = (catch bin_tail_c(S, 5)),\n {'EXIT',_} = (catch bin_tail_c_var(S, 5)),\n\n $a = bin_tail_d(S, 0),\n $b = bin_tail_d(S, 8),\n $d = bin_tail_d(S, 3*8),\n {'EXIT',_} = (catch bin_tail_d_dead(S, 1)),\n {'EXIT',_} = (catch bin_tail_d_dead(S, 9)),\n {'EXIT',_} = (catch bin_tail_d_dead(S, 5*8)),\n {'EXIT',_} = (catch bin_tail_d_var(S, 1)),\n\n ok = bin_tail_e(<<2:2,0:1,1:5>>),\n ok = bin_tail_e(<<2:2,1:1,1:5,42:64>>),\n error = bin_tail_e(<<3:2,1:1,1:5,42:64>>),\n error = bin_tail_e(<<>>),\n ok.\n\nbin_tail_c(Bin, Offset) ->\n Res = bin_tail_c_dead(Bin, Offset),\n <<_:Offset/binary,_,Tail/binary>> = Bin,\n {Res,Tail} = bin_tail_c_var(Bin, Offset),\n Res.\n\nbin_tail_c_dead(Bin, Offset) ->\n <<_:Offset/binary,C,_/binary>> = Bin,\n C.\n\nbin_tail_c_var(Bin, Offset) ->\n <<_:Offset/binary,C,Tail/binary>> = Bin,\n {C,Tail}.\n\n\nbin_tail_d(Bin, BitOffset) ->\n Res = bin_tail_d_dead(Bin, BitOffset),\n <<_:BitOffset,_:8,Tail/binary>> = Bin,\n {Res,Tail} = bin_tail_d_var(Bin, BitOffset),\n Res.\n\nbin_tail_d_dead(Bin, BitOffset) ->\n <<_:BitOffset,C,_/binary>> = Bin,\n C.\n\nbin_tail_d_var(Bin, BitOffset) ->\n <<_:BitOffset,C,Tail/binary>> = Bin,\n {C,Tail}.\n\nbin_tail_e(Bin) ->\n case bin_tail_e_dead(Bin) of\n\tok ->\n\t <<_,Tail/binary>> = Bin,\n\t Tail = bin_tail_e_var(Bin),\n\t ok;\n\terror ->\n\t bin_tail_e_var(Bin)\n end.\n\nbin_tail_e_dead(Bin) ->\n case Bin of\n\t%% The binary is aligned at the end; neither the bs_skip_bits2 nor\n\t%% bs_test_tail2 instructions are needed.\n\t<<2:2,_:1,1:5,_/binary>> -> ok;\n\t_ -> error\n end.\n\nbin_tail_e_var(Bin) ->\n case Bin of\n\t%% The binary is aligned at the end; neither the bs_skip_bits2 nor\n\t%% bs_test_tail2 instructions are needed.\n\t<<2:2,_:1,1:5,Tail/binary>> -> Tail;\n\t_ -> error\n end.\n\t \nsave_restore(Config) when is_list(Config) ->\n 0 = save_restore_1(<<0:2,42:6>>),\n {1,3456} = save_restore_1(<<1:2,3456:14>>),\n {2,7981234} = save_restore_1(<<2:2,7981234:30>>),\n {3,763967493838} = save_restore_1(<<0:2,763967493838:62>>),\n\n A = <<\" x\">>,\n B = <<\".x\">>,\n C = <<\"-x\">>,\n\n {\" \",<<\"x\">>} = lll(A),\n {\" \",<<\"x\">>} = mmm(A),\n {\" \",<<\"x\">>} = nnn(A),\n {\" \",<<\"x\">>} = ooo(A),\n\n {\".\",<<\"x\">>} = lll(B),\n {\".\",<<\"x\">>} = mmm(B),\n {\".\",<<\"x\">>} = nnn(B),\n {\".\",<<\"x\">>} = ooo(B),\n\n {\"-\",<<\"x\">>} = lll(C),\n {\"-\",<<\"x\">>} = mmm(C),\n {\"-\",<<\"x\">>} = nnn(C),\n {\"-\",<<\"x\">>} = ooo(C),\n\n a = multiple_matches(<<777:16>>, <<777:16>>),\n b = multiple_matches(<<777:16>>, <<999:16>>),\n c = multiple_matches(<<777:16>>, <<57:8>>),\n d = multiple_matches(<<17:8>>, <<1111:16>>),\n\n Bin = <<-1:64>>,\n case bad_float_unpack_match(Bin) of\n\t-1 -> ok;\n\t_Other -> ct:fail(bad_return_value_probably_NaN)\n end.\n\nsave_restore_1(Bin) ->\n case Bin of\n\t<<0:2,_:6>> -> 0;\n\t<<1:2,A:14>> -> {1,A};\n\t<<2:2,A:30>> -> {2,A};\n\t<> -> {3,A}\n end.\n\nlll(<>) -> {[Char],Tail}.\n\nmmm(<<$.,$.,$., Tail/binary>>) -> Tail;\nmmm(<<$\\s,$-,$\\s, Tail/binary>>) -> Tail;\nmmm(<>) -> {[Char],Tail}. %% Buggy Tail!\n\nnnn(<<\"...\", Tail/binary>>) -> Tail;\nnnn(<<\" - \", Tail/binary>>) -> Tail;\nnnn(<>) -> {[Char],Tail}. %% Buggy Tail!\n\nooo(<<\" - \", Tail/binary>>) -> Tail;\nooo(<>) -> {[Char],Tail}.\n\nmultiple_matches(<>, <>) -> a;\nmultiple_matches(<<_:16>>, <<_:16>>) -> b;\nmultiple_matches(<<_:16>>, <<_:8>>) -> c;\nmultiple_matches(<<_:8>>, <<_:16>>) -> d.\n\nbad_float_unpack_match(<>) -> F;\nbad_float_unpack_match(<>) -> I.\n\n\npartitioned_bs_match(Config) when is_list(Config) ->\n <<1,2,3>> = partitioned_bs_match(blurf, <<42,1,2,3>>),\n error = partitioned_bs_match(10, <<7,8,15,13>>),\n error = partitioned_bs_match(100, {a,tuple,is,'not',a,binary}),\n ok = partitioned_bs_match(0, <<>>),\n fc(partitioned_bs_match, [-1,blurf],\n\t catch partitioned_bs_match(-1, blurf)),\n fc(partitioned_bs_match, [-1,<<1,2,3>>],\n\t catch partitioned_bs_match(-1, <<1,2,3>>)),\n {17,<<1,2,3>>} = partitioned_bs_match_2(1, <<17,1,2,3>>),\n {7,<<1,2,3>>} = partitioned_bs_match_2(7, <<17,1,2,3>>),\n\n fc(partitioned_bs_match_2, [4,<<0:17>>],\n\t catch partitioned_bs_match_2(4, <<0:17>>)),\n\n anything = partitioned_bs_match_3(anything, <<42>>),\n ok = partitioned_bs_match_3(1, 2),\n\n ok.\n\npartitioned_bs_match(_, <<42:8,T/binary>>) ->\n T;\npartitioned_bs_match(N, _) when N > 0 ->\n error;\npartitioned_bs_match(_, <<>>) ->\n ok.\n\npartitioned_bs_match_2(1, <>) ->\n {B,T};\npartitioned_bs_match_2(Len, <<_:8,T/binary>>) ->\n {Len,T}.\n\npartitioned_bs_match_3(Var, <<_>>) -> Var;\npartitioned_bs_match_3(1, 2) -> ok.\n\nfunction_clause(Config) when is_list(Config) ->\n ok = function_clause_1(<<0,7,0,7,42>>),\n fc(function_clause_1, [<<0,1,2,3>>],\n catch function_clause_1(<<0,1,2,3>>)),\n fc(function_clause_1, [<<0,1,2,3>>],\n catch function_clause_1(<<0,7,0,1,2,3>>)),\n\n ok = function_clause_2(<<0,7,0,7,42>>),\n ok = function_clause_2(<<255>>),\n ok = function_clause_2(<<13:4>>),\n fc(function_clause_2, [<<0,1,2,3>>],\n catch function_clause_2(<<0,1,2,3>>)),\n fc(function_clause_2, [<<0,1,2,3>>],\n catch function_clause_2(<<0,7,0,1,2,3>>)),\n\n ok.\n\nfunction_clause_1(<<0:8,7:8,T/binary>>) ->\n function_clause_1(T);\nfunction_clause_1(<<_:8>>) ->\n ok.\n\nfunction_clause_2(<<0:8,7:8,T/binary>>) ->\n function_clause_2(T);\nfunction_clause_2(<<_:8>>) ->\n ok;\nfunction_clause_2(<<_:4>>) ->\n ok.\n\nunit(Config) when is_list(Config) ->\n 42 = peek1(<<42>>),\n 43 = peek1(<<43,1,2>>),\n 43 = peek1(<<43,1,2,(-1):1>>),\n 43 = peek1(<<43,1,2,(-1):2>>),\n 43 = peek1(<<43,1,2,(-1):7>>),\n\n 99 = peek8(<<99>>),\n 100 = peek8(<<100,101>>),\n fc(peek8, [<<100,101,0:1>>], catch peek8(<<100,101,0:1>>)),\n\n 37484 = peek16(<<37484:16>>),\n 37489 = peek16(<<37489:16,5566:16>>),\n fc(peek16, [<<8>>], catch peek16(<<8>>)),\n fc(peek16, [<<42:15>>], catch peek16(<<42:15>>)),\n fc(peek16, [<<1,2,3,4,5>>], catch peek16(<<1,2,3,4,5>>)),\n\n 127 = peek7(<<127:7>>),\n 100 = peek7(<<100:7,19:7>>),\n fc(peek7, [<<1,2>>], catch peek7(<<1,2>>)),\n ok.\n\npeek1(<>) -> B.\n\npeek7(<>) -> B.\n\npeek8(<>) -> B.\n\npeek16(<>) -> B.\n\nshared_sub_bins(Config) when is_list(Config) ->\n {15,[<<>>,<<5>>,<<4,5>>,<<3,4,5>>,<<2,3,4,5>>]} = sum(<<1,2,3,4,5>>, [], 0),\n ok.\n\nsum(<>, Acc, Sum) ->\n sum(T, [T|Acc], Sum+B);\nsum(<<>>, Last, Sum) -> {Sum,Last}.\n\n\nbin_and_float(Config) when is_list(Config) ->\n 14.0 = bin_and_float(<<1.0/float,2.0/float,3.0/float>>, 0.0),\n ok.\n\nbin_and_float(<>, Sum) when is_float(X),\n\t\t\t\t\t\t\t is_float(Y),\n\t\t\t\t\t\t\t is_float(Z) ->\n bin_and_float(T, Sum+X*X+Y*Y+Z*Z);\nbin_and_float(<<>>, Sum) -> Sum.\n\ndec_subidentifiers(Config) when is_list(Config) ->\n {[],<<1,2,3>>} =\n\tdo_dec_subidentifiers(<<1:1,42:7,1:1,99:7,1,2,3>>, 0, [], 2),\n {[5389],<<1,2,3>>} = do_dec_subidentifiers(<<1:1,42:7,0:1,13:7,1,2,3>>, 0, [], 2),\n {[3,2,1],not_a_binary} = dec_subidentifiers(not_a_binary, any, [1,2,3], 0),\n ok.\n\ndo_dec_subidentifiers(Buffer, Av, Al, Len) -> \n Res = dec_subidentifiers(Buffer, Av, Al, Len),\n Res = dec_subidentifiers2(Buffer, Av, Al, Len),\n Res = dec_subidentifiers4(Buffer, Av, Al, Len),\n Res = dec_subidentifiers3(Buffer, Av, Al, Len).\n\ndec_subidentifiers(Buffer, _Av, Al, 0) -> \n {lists:reverse(Al),Buffer}; \ndec_subidentifiers(<<1:1,H:7,T/binary>>, Av, Al, Len) -> \n dec_subidentifiers(T, (Av bsl 7) bor H, Al, Len-1);\ndec_subidentifiers(<>, Av, Al, Len) -> \n dec_subidentifiers(T, 0, [((Av bsl 7) bor H)|Al], Len-1).\n\ndec_subidentifiers2(<>, _Av, Al, 0) ->\n {lists:reverse(Al),Buffer}; \ndec_subidentifiers2(<<1:1,H:7,T/binary>>, Av, Al, Len) -> \n dec_subidentifiers2(T, (Av bsl 7) bor H, Al, Len-1); \ndec_subidentifiers2(<>, Av, Al, Len) -> \n dec_subidentifiers2(T, 0, [((Av bsl 7) bor H)|Al], Len-1).\n\ndec_subidentifiers3(Buffer, _Av, Al, 0) when is_binary(Buffer) ->\n {lists:reverse(Al),Buffer}; \ndec_subidentifiers3(<<1:1,H:7,T/binary>>, Av, Al, Len) -> \n dec_subidentifiers3(T, (Av bsl 7) bor H, Al, Len-1); \ndec_subidentifiers3(<>, Av, Al, Len) -> \n dec_subidentifiers3(T, 0, [((Av bsl 7) bor H)|Al], Len-1).\n\ndec_subidentifiers4(<<1:1,H:7,T/binary>>, Av, Al, Len) when Len =/= 0 -> \n dec_subidentifiers4(T, (Av bsl 7) bor H, Al, Len-1); \ndec_subidentifiers4(<>, Av, Al, Len) when Len =/= 0 -> \n dec_subidentifiers4(T, 0, [((Av bsl 7) bor H)|Al], Len-1);\ndec_subidentifiers4(Buffer, _Av, Al, 0) -> \n {lists:reverse(Al),Buffer}.\n\n\nskip_optional_tag(Config) when is_list(Config) ->\n {ok,<<>>} = skip_optional_tag(<<42>>, <<42>>),\n {ok,<<>>} = skip_optional_tag(<<42,1>>, <<42,1>>),\n {ok,<<1,2,3>>} = skip_optional_tag(<<42>>, <<42,1,2,3>>),\n missing = skip_optional_tag(<<2:3>>, blurf),\n ok.\n\nskip_optional_tag(<<>>, Binary) ->\n {ok,Binary};\nskip_optional_tag(<>, <>) ->\n skip_optional_tag(RestTag, Rest);\nskip_optional_tag(_, _) -> missing.\n\ndecode_integer(_Config) ->\n {10795,<<43>>,whatever} = decode_integer(1, <<42,43>>, whatever),\n {-28909,<<19>>,whatever} = decode_integer(1, <<143,19>>, whatever),\n ok.\n\ndecode_integer(Len, <>, RemovedBytes) when B1 == 0 ->\n Bin = <<_Skip:Len/unit:8, Buffer2/binary>> = <>,\n Size = byte_size(Bin),\n <> = Bin,\n {Int,Buffer2,RemovedBytes};\ndecode_integer(Len, <>, RemovedBytes) ->\n Bin = <<_Skip:Len/unit:8,Buffer2/binary>> = <>,\n Size = byte_size(Bin),\n <> = <>,\n Int = N - (1 bsl (8 * size(Bin) -1)),\n {Int,Buffer2,RemovedBytes}.\n\n-define(DATELEN, 16).\n\nwfbm(Config) when is_list(Config) ->\n %% check_for_dot_or_space and get_tail is from wfbm4 by Steve Vinoski,\n %% with modifications.\n {nomatch,0} = check_for_dot_or_space(<<\" \">>),\n {nomatch,0} = check_for_dot_or_space(<<\" abc\">>),\n {ok,<<\"abcde\">>} = check_for_dot_or_space(<<\"abcde 34555\">>),\n {nomatch,0} = check_for_dot_or_space(<<\".gurka\">>),\n {nomatch,1} = check_for_dot_or_space(<<\"g.urka\">>),\n\n nomatch = get_tail(<<>>),\n {ok,<<\"2007/10/23/blurf\">>} = get_tail(<<\"200x/2007/10/23/blurf \">>),\n {skip,?DATELEN+5} = get_tail(<<\"200x/2007/10/23/blurf.\">>),\n nomatch = get_tail(<<\"200y.2007.10.23.blurf \">>),\n {'EXIT',_} = (catch get_tail({no,binary,at,all})),\n {'EXIT',_} = (catch get_tail(no_binary)),\n ok.\n\ncheck_for_dot_or_space(Bin) ->\n check_for_dot_or_space(Bin, 0).\n\ncheck_for_dot_or_space(<<$\\s, _/binary>>, 0) ->\n {nomatch,0};\ncheck_for_dot_or_space(Bin, Len) ->\n case Bin of\n <> ->\n {ok,Front};\n <<_:Len/binary, $., _/binary>> ->\n {nomatch,Len};\n\t_ ->\n check_for_dot_or_space(Bin, Len+1)\n end.\n\nget_tail(<<>>) ->\n nomatch;\nget_tail(Bin) ->\n <> = Bin,\n case Front of\n <<_:3/binary,\"x/\",Y:4/binary,$/,M:2/binary,$/,D:2/binary,$/>> ->\n\t case check_for_dot_or_space(Tail) of\n {ok,Match} ->\n {ok,<>};\n {nomatch,Skip} -> {skip,?DATELEN + Skip}\n end;\n _ -> nomatch\n end.\n\ndegenerated_match(Config) when is_list(Config) ->\n error = degenerated_match_1(<<>>),\n 1 = degenerated_match_1(<<1:1>>),\n 2 = degenerated_match_1(<<42,43>>),\n\n error = degenerated_match_2(<<>>),\n no_split = degenerated_match_2(<<1,2>>),\n {<<1,2,3,4>>,<<5>>} = degenerated_match_2(<<1,2,3,4,5>>),\n \n ok.\n\ndegenerated_match_1(<<>>) -> error;\ndegenerated_match_1(Bin) -> byte_size(Bin).\n\ndegenerated_match_2(<<>>) -> error;\ndegenerated_match_2(Bin) ->\n case byte_size(Bin) > 4 of\n\ttrue ->\n\t split_binary(Bin, 4);\n\tfalse ->\n\t no_split\n end.\n\nbs_sum(Config) when is_list(Config) ->\n 0 = bs_sum_1([]),\n 0 = bs_sum_1(<<>>),\n 42 = bs_sum_1([42]),\n 1 = bs_sum_1(<<1>>),\n 10 = bs_sum_1([1,2,3,4]),\n 15 = bs_sum_1(<<1,2,3,4,5>>),\n 21 = bs_sum_1([1,2,3|<<4,5,6>>]),\n 15 = bs_sum_1([1,2,3|{4,5}]),\n 6 = bs_sum_1([1,2,3|zero]),\n 6 = bs_sum_1([1,2,3|0]),\n 7 = bs_sum_1([1,2,3|one]),\n\n fc(catch bs_sum_1({too,big,tuple})),\n fc(catch bs_sum_1([1,2,3|{too,big,tuple}])),\n\n [] = sneaky_alias(<<>>),\n [559,387655] = sneaky_alias(id(<<559:32,387655:32>>)),\n fc(sneaky_alias, [<<1>>], catch sneaky_alias(id(<<1>>))),\n fc(sneaky_alias, [[1,2,3,4]], catch sneaky_alias(lists:seq(1, 4))),\n ok.\n\nbs_sum_1(<>) -> H+bs_sum_1(T);\nbs_sum_1([H|T]) -> H+bs_sum_1(T);\nbs_sum_1({A,B}=_Tuple=_AliasForNoGoodReason) -> A+B;\nbs_sum_1(0) -> 0;\nbs_sum_1(zero=_Zero) -> 0;\nbs_sum_1(one) -> 1;\nbs_sum_1([]) -> 0;\nbs_sum_1(<<>>) -> 0.\n\nsneaky_alias(<<>>=L) -> binary_to_list(L);\nsneaky_alias(<>) -> [From|sneaky_alias(L)].\n\ncoverage(Config) when is_list(Config) ->\n 0 = coverage_fold(fun(B, A) -> A+B end, 0, <<>>),\n 6 = coverage_fold(fun(B, A) -> A+B end, 0, <<1,2,3>>),\n fc(catch coverage_fold(fun(B, A) ->\n\t\t\t\t\t A+B\n\t\t\t\t end, 0, [a,b,c])),\n\n {<<42.0:64/float>>,float} = coverage_build(<<>>, <<42>>, float),\n {<<>>,not_a_tuple} = coverage_build(<<>>, <<>>, not_a_tuple),\n {<<16#76,\"abc\",16#A9,\"abc\">>,{x,42,43}} =\n\tcoverage_build(<<>>, <<16#7,16#A>>, {x,y,z}),\n\n [<<2>>,<<1>>] = coverage_bc(<<1,2>>, []),\n\n {x,<<\"abc\">>,z} = coverage_setelement(<<2,\"abc\">>, {x,y,z}),\n\n [42] = coverage_apply(<<42>>, [coverage_id]),\n 42 = coverage_external(<<42>>),\n\n do_coverage_bin_to_term_list([]),\n do_coverage_bin_to_term_list([lists:seq(0, 10),{a,b,c},<<23:42>>]),\n fc(coverage_bin_to_term_list, [<<0,0,0,7>>],\n\t catch do_coverage_bin_to_term_list_1(<<7:32>>)),\n\n <<>> = coverage_per_key(<<4:32>>),\n <<$a,$b,$c>> = coverage_per_key(<<7:32,\"abc\">>),\n\n binary = coverage_bitstring(<<>>),\n binary = coverage_bitstring(<<7>>),\n bitstring = coverage_bitstring(<<7:4>>),\n other = coverage_bitstring([a]),\n ok.\n\ncoverage_fold(Fun, Acc, <>) ->\n IdFun = fun id/1,\n coverage_fold(Fun, Fun(IdFun(H), IdFun(Acc)), T);\ncoverage_fold(Fun, Acc, <<>>) when is_function(Fun, 2) -> Acc.\n\ncoverage_build(Acc0, <>, float) ->\n Float = id(<>),\n Acc = <>,\n coverage_build(Acc, T, float);\ncoverage_build(Acc0, <>, Tuple0) ->\n Str = id(<>),\n Acc = id(<>),\n Tuple = setelement(2, setelement(3, Tuple0, 43), 42),\n if\n\tbyte_size(Acc) > 0 ->\n\t coverage_build(Acc, T, Tuple)\n end;\ncoverage_build(Acc, <<>>, Tuple) -> {Acc,Tuple}.\n\ncoverage_bc(<>, Acc) ->\n B = << <> || C <- [H] >>,\n coverage_bc(T, [B|Acc]);\ncoverage_bc(<<>>, Acc) -> Acc.\n\ncoverage_setelement(<>, Tuple) when element(1, Tuple) =:= x ->\n setelement(H, Tuple, T1).\n\ncoverage_apply(<>, [F|Fs]) ->\n [?MODULE:F(H)|coverage_apply(T, Fs)];\ncoverage_apply(<<>>, []) -> [].\n\ncoverage_external(<>) ->\n ?MODULE:coverage_external_ignore(T, T),\n H.\n\ncoverage_external_ignore(_, _) ->\n ok.\n\ncoverage_id(I) -> id(I).\n\ndo_coverage_bin_to_term_list(L) ->\n Bin = << <<(begin BinTerm = term_to_binary(Term),\n\t\t <<(byte_size(BinTerm)):32,BinTerm/binary>> end)/binary>> ||\n\t Term <- L >>,\n L = do_coverage_bin_to_term_list_1(Bin),\n L = do_coverage_bin_to_term_list_1(<>),\n L = do_coverage_bin_to_term_list_1(<<7:32,\"garbage\",Bin/binary>>). \n\ndo_coverage_bin_to_term_list_1(Bin) ->\n Res = coverage_bin_to_term_list(Bin),\n Res = coverage_bin_to_term_list(Bin, []),\n Res = coverage_bin_to_term_list_catch(Bin),\n Res = coverage_bin_to_term_list_catch(Bin, []).\n\ncoverage_bin_to_term_list(<>) ->\n try binary_to_term(BinTerm) of\n\tTerm -> [Term|coverage_bin_to_term_list(T)]\n catch\n\terror:badarg -> coverage_bin_to_term_list(T)\n end;\ncoverage_bin_to_term_list(<<>>) -> [].\n\ncoverage_bin_to_term_list(<>, Acc) ->\n try binary_to_term(BinTerm) of\n\tTerm -> coverage_bin_to_term_list(T, [Term|Acc])\n catch\n\terror:badarg -> coverage_bin_to_term_list(T, Acc)\n end;\ncoverage_bin_to_term_list(<<>>, Acc) -> lists:reverse(Acc).\n\ncoverage_bin_to_term_list_catch(<>) ->\n case catch binary_to_term(BinTerm) of\n\t{'EXIT',_} -> coverage_bin_to_term_list_catch(T);\n\tTerm -> [Term|coverage_bin_to_term_list_catch(T)]\n end;\ncoverage_bin_to_term_list_catch(<<>>) -> [].\n\ncoverage_bin_to_term_list_catch(<>, Acc) ->\n case catch binary_to_term(BinTerm) of\n\t{'EXIT',_} -> coverage_bin_to_term_list_catch(T, Acc);\n\tTerm -> coverage_bin_to_term_list_catch(T, [Term|Acc])\n end;\ncoverage_bin_to_term_list_catch(<<>>, Acc) -> lists:reverse(Acc).\n\ncoverage_per_key(<> = B) ->\n true = (byte_size(B) =:= BinSize),\n Bin.\n\ncoverage_bitstring(Bin) when is_binary(Bin) -> binary;\ncoverage_bitstring(<<_/bitstring>>) -> bitstring;\ncoverage_bitstring(_) -> other.\n\nmultiple_uses(Config) when is_list(Config) ->\n {344,62879,345,<<245,159,1,89>>} = multiple_uses_1(<<1,88,245,159,1,89>>),\n true = multiple_uses_2(<<0,0,197,18>>),\n <<42,43>> = multiple_uses_3(<<0,0,42,43>>, fun id/1),\n\n ok = first_after(<<>>, 42),\n <<1>> = first_after(<<1,2,3>>, 0),\n <<2>> = first_after(<<1,2,3>>, 1),\n\n ok.\n\nmultiple_uses_1(<>) ->\n %% NOT OPTIMIZED: sub binary is matched or used in more than one place\n {Y,Z} = multiple_uses_match(Tail),\n {X,Y,Z,Tail}.\n\nmultiple_uses_2(<<_:16,Tail/binary>>) ->\n %% NOT OPTIMIZED: sub binary is matched or used in more than one place\n multiple_uses_cmp(Tail, Tail).\n\nmultiple_uses_3(<<_:16,Tail/binary>>, Fun) ->\n %% NOT OPTIMIZED: sub binary is used or returned\n Fun(Tail).\n\nmultiple_uses_match(<>) ->\n {Y,Z}.\n\nmultiple_uses_cmp(<>, <>) -> true;\nmultiple_uses_cmp(<<_:16>>, <<_:16>>) -> false.\n\nfirst_after(Data, Offset) ->\n case byte_size(Data) > Offset of\n\tfalse ->\n\t {_First, _Rest} = {ok, ok},\n\t ok;\n\ttrue ->\n\t <<_:Offset/binary, Rest/binary>> = Data,\n\t %% 'Rest' saved in y(0) before the call.\n {First, _} = match_first(Data, Rest),\n %% When beam_bsm sees the code, the following line\n %% which uses y(0) has been optimized away.\n\t {First, Rest} = {First, Rest},\n\t First\n end.\n\nmatch_first(_, <>) ->\n {First, Rest}.\n\nzero_label(Config) when is_list(Config) ->\n <<\"nosemouth\">> = read_pols(<<\"FACE\",\"nose\",\"mouth\">>),\n <<\"CE\">> = read_pols(<<\"noFACE\">>),\n ok.\n\nread_pols(Data) ->\n <> = Data,\n %% Intentional warning.\n (PolygonType == <<\"FACE\">>) or (PolygonType == <<\"PTCH\">>),\n Rest.\n\nfollowed_by_catch(Config) when is_list(Config) ->\n ok = handle(<<0,1,2,3,4,5>>).\n\n-record(rec,{field}).\nhandle(<<>>) -> ok;\nhandle(Msg) ->\n <<_DataLen:16, Rest/binary>> = Msg,\n case catch fooX:func() of\n\t[X] ->\n\t X#rec.field;\n\t_ ->\n\t ok\n end,\n handle(Rest).\n\nmatching_meets_construction(Config) when is_list(Config) ->\n Bin = id(<<\"abc\">>),\n Len = id(2),\n Tail0 = id(<<1,2,3,4,5>>),\n <<_:Len/binary,Tail/binary>> = Tail0,\n Res = <>,\n <<3,4,5,\"abc\">> = Res,\n {'EXIT',{badarg,_}} = (catch matching_meets_construction_1(<<\"Abc\">>)),\n {'EXIT',{badarg,_}} = (catch matching_meets_construction_2(<<\"Abc\">>)),\n <<\"Bbc\">> = matching_meets_construction_3(<<\"Abc\">>),\n\n <<1,2>> = encode_octet_string(<<1,2,3>>, 2),\n ok.\n\nmatching_meets_construction_1(<<\"A\",H/binary>>) -> <<\"B\",H>>.\n\nmatching_meets_construction_2(<<\"A\",H/binary>>) -> <<\"B\",H/float>>.\n\nmatching_meets_construction_3(<<\"A\",H/binary>>) -> <<\"B\",H/binary>>.\n\nencode_octet_string(<>, Len) ->\n <>.\n\nsimon(Config) when is_list(Config) ->\n one = simon(blurf, <<>>),\n two = simon(0, <<42>>),\n fc(simon, [17,<<1>>], catch simon(17, <<1>>)),\n fc(simon, [0,<<1,2,3>>], catch simon(0, <<1,2,3>>)),\n\n one = simon2(blurf, <<9>>),\n two = simon2(0, <<9,1>>),\n fc(simon2, [0,<<9,10,11>>], catch simon2(0, <<9,10,11>>)),\n ok.\n\nsimon(_, <<>>) -> one;\nsimon(0, <<_>>) -> two.\n\nsimon2(_, <<9>>) -> one;\nsimon2(0, <<_:16>>) -> two.\n\n\n%% OTP-7113: Crash in v3_codegen.\nmatching_and_andalso(Config) when is_list(Config) ->\n ok = matching_and_andalso_1(<<1,2,3>>, 3),\n {'EXIT',{function_clause,_}} = (catch matching_and_andalso_1(<<1,2,3>>, -8)),\n {'EXIT',{function_clause,_}} = (catch matching_and_andalso_1(<<1,2,3>>, blurf)),\n {'EXIT',{function_clause,_}} = (catch matching_and_andalso_1(<<1,2,3>>, 19)),\n\n {\"abc\",<<\"xyz\">>} = matching_and_andalso_23(\"abc\", <<\"-xyz\">>),\n {\"abc\",<<\"\">>} = matching_and_andalso_23(\"abc\", <<($a-1)>>),\n {\"abc\",<<\"\">>} = matching_and_andalso_23(\"abc\", <<($z+1)>>),\n {\"abc\",<<\"\">>} = matching_and_andalso_23(\"abc\", <<($A-1)>>),\n {\"abc\",<<\"\">>} = matching_and_andalso_23(\"abc\", <<($Z+1)>>),\n error = matching_and_andalso_23([], <<>>),\n error = matching_and_andalso_23([], <<$A>>),\n error = matching_and_andalso_23([], <<$Z>>),\n error = matching_and_andalso_23([], <<$a>>),\n error = matching_and_andalso_23([], <<$z>>),\n ok.\n\nmatching_and_andalso_1(<>, K)\n when is_integer(K) andalso size(Bitmap) >= K andalso 0 < K ->\n ok.\n\nmatching_and_andalso_23(Datetime, Bin) ->\n Res = matching_and_andalso_2(Datetime, Bin),\n Res = matching_and_andalso_3(Datetime, Bin),\n Res.\n\nmatching_and_andalso_2(Datetime, <>)\n when not ((H >= $a) andalso (H =< $z)) andalso\n not ((H >= $A) andalso (H =< $Z)) ->\n {Datetime,T};\nmatching_and_andalso_2(_, _) -> error.\n\n%% Contrived example to ensure we cover the handling of 'call' instructions\n%% in v3_codegen:bsm_rename_ctx/4.\nmatching_and_andalso_3(Datetime, <>)\n when not ((abs(H) >= $a) andalso (abs(H) =< $z)) andalso\n not ((abs(H) >= $A) andalso (abs(H) =< $Z)) ->\n {Datetime,T};\nmatching_and_andalso_3(_, _) -> error.\n\n%% Thanks to Tomas Stejskal.\notp_7188(Config) when is_list(Config) ->\n MP3 = <<84,65,71,68,117,154,105,232,107,121,0,0,0,0,0,0,0,0,0,0,\n\t 0,0,0,0,0,0,0,0,0,0,0,0,0,68,97,110,105,101,108,32,76,\n\t 97,110,100,97,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,66,\n\t 101,115,116,32,79,102,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n\t 0,0,0,0,0,0,50,48,48,48,50,48,48,48,32,45,32,66,101,115,\n\t 116,32,79,102,32,32,32,32,32,32,32,32,32,32,32,32,32,32,\n\t 32,32,12>>,\n {ok,{\"ID3v1\",\n\t [{title,<<68,117,154,105,232,107,121>>},\n\t\t{artist,<<\"Daniel Landa\">>},\n\t\t{album,<<\"Best Of\">>}]}} = parse_v1_or_v11_tag(MP3).\n\nparse_v1_or_v11_tag(<<\"TAG\", Title:30/binary,\n\t\t Artist:30/binary, Album:30/binary,\n\t\t _Year:4/binary, _Comment:28/binary,\n\t\t 0:8, Track:8, _Genre:8>>) ->\n {ok,\n {\"ID3v1.1\",\n [{track, Track}, {title, trim(Title)},\n {artist, trim(Artist)}, {album, trim(Album)}]}};\nparse_v1_or_v11_tag(<<\"TAG\", Title:30/binary,\n\t\t Artist:30/binary, Album:30/binary,\n\t\t _Year:4/binary, _Comment:30/binary,\n\t\t _Genre:8>>) ->\n {ok,\n {\"ID3v1\",\n [{title, trim(Title)},\n {artist, trim(Artist)},\n {album, trim(Album)}]}};\nparse_v1_or_v11_tag(_) ->\n error.\n\ntrim(Bin) ->\n list_to_binary(trim_blanks(binary_to_list(Bin))).\n\ntrim_blanks(L) ->\n lists:reverse(skip_blanks_and_zero(lists:reverse(L))).\n\nskip_blanks_and_zero([$\\s|T]) ->\n skip_blanks_and_zero(T);\nskip_blanks_and_zero([0|T]) ->\n skip_blanks_and_zero(T);\nskip_blanks_and_zero(L) ->\n L.\n\n%% OTP-7233. Record and binary matching optimizations clashed.\n%% Thanks to Vladimir Klebansky.\n\n-record(rec_otp_7233, {key, val}).\n\notp_7233(Config) when is_list(Config) ->\n otp_7233_1(#rec_otp_7233{key = <<\"XXabcde\">>,val=[{\"xxxxxxxx\",42}]}),\n [<<\"XXabcde\">>,{\"xxxxxxxx\",42}] = get(io_format),\n erase(io_format),\n otp_7233_1(#rec_otp_7233{key = <<\"XXabcde\">>,val=[]}),\n undefined = get(io_format),\n ok.\n\notp_7233_1(Rec) ->\n <> = Rec#rec_otp_7233.key,\n case K of\n\t<<\"XX\">> ->\n\t Value = Rec#rec_otp_7233.val,\n\t case lists:keyfind(\"xxxxxxxx\", 1, Value) of\n\t\tfalse ->\n\t\t ok;\n\t\tT ->\n\t\t put(io_format, [Rec#rec_otp_7233.key,T])\n\t end;\n\t_ -> ok\n end.\n\n\notp_7240(Config) when is_list(Config) ->\n a = otp_7240_a(0, <<>>),\n b = otp_7240_a(1, 2),\n\n a = otp_7240_b(anything, <<>>),\n b = otp_7240_b(1, {x,y}),\n\n a = otp_7240_c(anything, <<>>),\n b = otp_7240_c(1, <<2>>),\n\n a = otp_7240_d(anything, <<>>),\n b = otp_7240_d(again, <<2>>),\n\n a = otp_7240_e(anything, <<>>),\n b = otp_7240_e(1, 41),\n\n a = otp_7240_f(anything, <<>>),\n b = otp_7240_f(1, {}),\n \n ok.\n\notp_7240_a(_, <<>>) -> a;\notp_7240_a(1, 2) -> b.\n\notp_7240_b(_, <<>>) -> a;\notp_7240_b(1, {_,_}) -> b.\n\notp_7240_c(_, <<>>) -> a;\notp_7240_c(1, <<2>>) -> b.\n\notp_7240_d(_, <<>>) -> a;\notp_7240_d(_, <<2>>) -> b.\n\notp_7240_e(_, <<>>) -> a;\notp_7240_e(1, B) when B < 42 -> b.\n\notp_7240_f(_, <<>>) -> a;\notp_7240_f(1, B) when is_tuple(B) -> b.\n\notp_7498(Config) when is_list(Config) ->\n <<1,2,3>> = otp_7498_foo(<<1,2,3>>, 0),\n <<2,3>> = otp_7498_foo(<<1,2,3>>, 1),\n <<1,2,3>> = otp_7498_foo(<<1,2,3>>, 2),\n\n <<1,2,3>> = otp_7498_bar(<<1,2,3>>, 0),\n <<2,3>> = otp_7498_bar(<<1,2,3>>, 1),\n <<1,2,3>> = otp_7498_bar(<<1,2,3>>, 2),\n <<>> = otp_7498_bar(<<>>, 2),\n <<1,2,3>> = otp_7498_bar(<<1,2,3>>, 3),\n\n ok.\n\notp_7498_foo(Bin, 0) ->\n otp_7498_foo(Bin, 42);\notp_7498_foo(<<_A, Rest/bitstring>>, 1) ->\n otp_7498_foo(Rest, 43);\notp_7498_foo(Bin, _I) ->\n Bin.\n\notp_7498_bar(Bin, 0) ->\n otp_7498_bar(Bin, 42);\notp_7498_bar(<<_A, Rest/bitstring>>, 1) ->\n otp_7498_bar(Rest, 43);\notp_7498_bar(<<>>, 2) ->\n otp_7498_bar(<<>>, 44);\notp_7498_bar(Bin, _I) ->\n Bin.\n\n\nmatch_string(Config) when is_list(Config) ->\n %% To make sure that native endian really is handled correctly\n %% (i.e. that the compiler does not attempt to use bs_match_string/4\n %% instructions for native segments), running this test is not enough.\n %% Either examine the generated for do_match_string_native/1 or\n %% check the coverage for the v3_kernel module.\n case erlang:system_info(endian) of\n\tlittle ->\n\t do_match_string_native(<<$a,0,$b,0>>);\n\tbig ->\n\t do_match_string_native(<<0,$a,0,$b>>)\n end,\n\n do_match_string_big(<<0,$a,0,$b>>),\n do_match_string_little(<<$a,0,$b,0>>),\n\n do_match_string_big_signed(<<255,255>>),\n do_match_string_little_signed(<<255,255>>),\n\n plain = no_match_string_opt(<<\"abc\">>),\n strange = no_match_string_opt(<<$a:9,$b:9,$c:9>>),\n\n ok.\n\ndo_match_string_native(<<$a:16/native,$b:16/native>>) -> ok.\n\ndo_match_string_big(<<$a:16/big,$b:16/big>>) -> ok.\n\ndo_match_string_little(<<$a:16/little,$b:16/little>>) -> ok.\n\ndo_match_string_big_signed(<<(-1):16/signed>>) -> ok.\n\ndo_match_string_little_signed(<<(-1):16/little-signed>>) -> ok.\n\nno_match_string_opt(<<\"abc\">>) -> plain;\nno_match_string_opt(<<$a:9,$b:9,$c:9>>) -> strange.\n \n\n%% OTP-7591: A zero-width segment in matching would crash the compiler.\n\nzero_width(Config) when is_list(Config) ->\n <> = <<2, 0, $h, $i, 0:0>>,\n 2 = Len,\n Str = <<\"hi\">>,\n\n %% Match sure that values that cannot fit in a segment will not match.\n case id(<<0:8>>) of\n\t<<256:8>> -> ct:fail(should_not_match);\n\t_ -> ok\n end,\n ok.\n\n\n%% OTP_7650: A invalid size for binary segments could crash the compiler.\nbad_size(Config) when is_list(Config) ->\n Tuple = {a,b,c},\n {'EXIT',{{badmatch,<<>>},_}} = (catch <<32:Tuple>> = id(<<>>)),\n Binary = <<1,2,3>>,\n {'EXIT',{{badmatch,<<>>},_}} = (catch <<32:Binary>> = id(<<>>)),\n ok.\n\nhaystack(Config) when is_list(Config) ->\n <<0:10/unit:8>> = haystack_1(<<0:10/unit:8>>),\n [<<0:10/unit:8>>,\n\t <<0:20/unit:8>>] = haystack_2(<<1:8192>>),\n ok.\n\n%% Used to crash the compiler.\nhaystack_1(Haystack) ->\n Subs = [10],\n [begin\n\t <> = Haystack,\n\t B\n end || Y <- Subs],\n Haystack.\n\n%% There would be an incorrect badmatch exception.\nhaystack_2(Haystack) ->\n Subs = [{687,10},{369,20}],\n [begin\n\t <<_:X/binary,B:Y/binary,_/binary>> = Haystack,\n\t B\n end || {X,Y} <- Subs ].\n\nfc({'EXIT',{function_clause,_}}) -> ok;\nfc({'EXIT',{{case_clause,_},_}}) when ?MODULE =:= bs_match_inline_SUITE -> ok.\n\nfc(Name, Args, {'EXIT',{function_clause,[{?MODULE,Name,Args,_}|_]}}) -> ok;\nfc(Name, Args, {'EXIT',{function_clause,[{?MODULE,Name,Arity,_}|_]}})\n when length(Args) =:= Arity ->\n true = test_server:is_native(?MODULE);\nfc(_, Args, {'EXIT',{{case_clause,ActualArgs},_}})\n when ?MODULE =:= bs_match_inline_SUITE ->\n Args = tuple_to_list(ActualArgs).\n\n%% Cover the clause handling bs_context to binary in\n%% beam_block:initialized_regs/2.\ncover_beam_bool(Config) when is_list(Config) ->\n ok = do_cover_beam_bool(<<>>, 3),\n <<19>> = do_cover_beam_bool(<<19>>, 2),\n <<42>> = do_cover_beam_bool(<<42>>, 1),\n <<17>> = do_cover_beam_bool(<<13,17>>, 0),\n ok.\n\ndo_cover_beam_bool(Bin, X) when X > 0 ->\n if\n\tX =:= 1; X =:= 2 ->\n\t Bin;\n\ttrue ->\n\t ok\n end;\ndo_cover_beam_bool(<<_,Bin/binary>>, X) ->\n do_cover_beam_bool(Bin, X+1).\n\nmatched_out_size(Config) when is_list(Config) ->\n {253,16#DEADBEEF} = mos_int(<<8,253,16#DEADBEEF:32>>),\n {6,16#BEEFDEAD} = mos_int(<<3,6:3,16#BEEFDEAD:32>>),\n {53,16#CAFEDEADBEEFCAFE} = mos_int(<<16,53:16,16#CAFEDEADBEEFCAFE:64>>),\n {23,16#CAFEDEADBEEFCAFE} = mos_int(<<5,23:5,16#CAFEDEADBEEFCAFE:64>>),\n\n {<<1,2,3>>,4} = mos_bin(<<3,1,2,3,4,3>>),\n {<<1,2,3,7>>,19,42} = mos_bin(<<4,1,2,3,7,19,4,42>>),\n <<1,2,3,7>> = mos_bin(<<4,1,2,3,7,\"abcdefghij\">>),\n\n ok.\n\nmos_int(<>) ->\n {I,X};\nmos_int(<>) ->\n {I,X}.\n\nmos_bin(<>) ->\n L = byte_size(Bin),\n {Bin,X};\nmos_bin(<>) ->\n L = byte_size(Bin),\n {Bin,X,Y};\nmos_bin(<>) ->\n L = byte_size(Bin),\n Bin.\n\nfollow_fail_branch(_) ->\n 42 = ffb_1(<<0,1>>, <<0>>),\n 8 = ffb_1(<<0,1>>, [a]),\n 42 = ffb_2(<<0,1>>, <<0>>, 17),\n 8 = ffb_2(<<0,1>>, [a], 0),\n ok.\n\nffb_1(<<_,T/bitstring>>, List) ->\n case List of\n\t<<_>> ->\n\t 42;\n\t[_|_] ->\n\t %% The fail branch of the bs_start_match2 instruction\n\t %% pointing to here would be ignored, making the compiler\n\t %% incorrectly assume that the delayed sub-binary\n\t %% optimization was safe.\n\t bit_size(T)\n end.\n\nffb_2(<<_,T/bitstring>>, List, A) ->\n case List of\n\t<<_>> when A =:= 17 -> 42;\n\t[_|_] -> bit_size(T)\n end.\n\nno_partition(_) ->\n one = no_partition_1(<<\"string\">>, a1),\n {two,<<\"string\">>} = no_partition_1(<<\"string\">>, a2),\n {two,<<>>} = no_partition_1(<<>>, a2),\n {two,a} = no_partition_1(a, a2),\n three = no_partition_1(undefined, a3),\n {four,a,[]} = no_partition_1([a], a4),\n {five,a,b} = no_partition_1({a,b}, a5),\n\n one = no_partition_2(<<\"string\">>, a1),\n two = no_partition_2(<<\"string\">>, a2),\n two = no_partition_2(<<>>, a2),\n two = no_partition_2(a, a2),\n three = no_partition_2(undefined, a3),\n four = no_partition_2(42, a4),\n five = no_partition_2([], a5),\n six = no_partition_2(42.0, a6),\n ok.\n\nno_partition_1(<<\"string\">>, a1) ->\n one;\nno_partition_1(V, a2) ->\n {two,V};\nno_partition_1(undefined, a3) ->\n three;\nno_partition_1([H|T], a4) ->\n {four,H,T};\nno_partition_1({A,B}, a5) ->\n {five,A,B}.\n\nno_partition_2(<<\"string\">>, a1) ->\n one;\nno_partition_2(_, a2) ->\n two;\nno_partition_2(undefined, a3) ->\n three;\nno_partition_2(42, a4) ->\n four;\nno_partition_2([], a5) ->\n five;\nno_partition_2(42.0, a6) ->\n six.\n\ncalling_a_binary(Config) when is_list(Config) ->\n [] = call_binary(<<>>, []),\n {'EXIT',{badarg,_}} = (catch call_binary(<<1>>, [])),\n {'EXIT',{badarg,_}} = (catch call_binary(<<1,2,3>>, [])),\n ok.\n\ncall_binary(<<>>, Acc) ->\n Acc;\ncall_binary(<>, Acc) ->\n T(<>).\n\nbinary_in_map(Config) when is_list(Config) ->\n ok = match_binary_in_map(#{key => <<42:8>>}),\n {'EXIT',{{badmatch,#{key := 1}},_}} =\n\t(catch match_binary_in_map(#{key => 1})),\n {'EXIT',{{badmatch,#{key := <<1023:16>>}},_}} =\n\t(catch match_binary_in_map(#{key => <<1023:16>>})),\n {'EXIT',{{badmatch,#{key := <<1:8>>}},_}} =\n\t(catch match_binary_in_map(#{key => <<1:8>>})),\n {'EXIT',{{badmatch,not_a_map},_}} =\n\t(catch match_binary_in_map(not_a_map)),\n ok.\n\nmatch_binary_in_map(Map) ->\n case 8 of\n\tN ->\n\t #{key := <<42:N>>} = Map,\n\t ok\n end.\n\nmatch_string_opt(Config) when is_list(Config) ->\n {x,<<1,2,3>>,{<<1>>,{v,<<1,2,3>>}}} =\n\tdo_match_string_opt({<<1>>,{v,<<1,2,3>>}}),\n ok.\n\ndo_match_string_opt({<<1>>,{v,V}}=T) ->\n {x,V,T}.\n\nselect_on_integer(Config) when is_list(Config) ->\n 42 = do_select_on_integer(<<42>>),\n <<\"abc\">> = do_select_on_integer(<<128,\"abc\">>),\n\n {'EXIT',_} = (catch do_select_on_integer(<<0:1>>)),\n {'EXIT',_} = (catch do_select_on_integer(<<1:1>>)),\n {'EXIT',_} = (catch do_select_on_integer(<<0:1,0:15>>)),\n ok.\n\n%% The ASN.1 compiler frequently generates code like this.\ndo_select_on_integer(<<0:1,I:7>>) ->\n I;\ndo_select_on_integer(<<1:1,_:7,Bin/binary>>) ->\n Bin.\n\n%% If 'bin_opt_info' was given the warning would lack filename\n%% and line number.\n\nmap_and_binary(_Config) ->\n {<<\"10\">>,<<\"37\">>,<<\"am\">>} = do_map_and_binary(<<\"10:37am\">>),\n Map1 = #{time => \"noon\"},\n {ok,Map1} = do_map_and_binary(Map1),\n Map2 = #{hour => 8, min => 42},\n {8,42,Map2} = do_map_and_binary(Map2),\n ok.\n\ndo_map_and_binary(<>) ->\n {Hour, Min, Rest};\ndo_map_and_binary(#{time := _} = T) ->\n {ok, T};\ndo_map_and_binary(#{hour := Hour, min := Min} = T) ->\n {Hour, Min, T}.\n\n%% Unsafe caching of branch outcomes in beam_bsm would cause the\n%% delayed creation of sub-binaries optimization to be applied even\n%% when it was unsafe.\n\nunsafe_branch_caching(_Config) ->\n <<>> = do_unsafe_branch_caching(<<42,1>>),\n <<>> = do_unsafe_branch_caching(<<42,2>>),\n <<>> = do_unsafe_branch_caching(<<42,3>>),\n <<17,18>> = do_unsafe_branch_caching(<<42,3,17,18>>),\n <<>> = do_unsafe_branch_caching(<<1,3,42,2>>),\n\n ok.\n\ndo_unsafe_branch_caching(<>) ->\n <> = Bin,\n case C1 of\n\tX when X =:= 1 orelse X =:= 2 ->\n\t Bin2 = <<>>;\n\t_ ->\n\t Bin2 = B1\n end,\n case Code of\n\t1 -> do_unsafe_branch_caching(Bin2);\n\t_ -> Bin2\n end.\n\nbad_literals(_Config) ->\n% Mod = list_to_atom(?MODULE_STRING ++ \"_\" ++\n%\t\t\t atom_to_list(?FUNCTION_NAME)),\n% S = [signed_lit_match(V, Sz) || V <- lists:seq(-8, 8),\n%\t\t\t\t Sz <- [0,1,2,3]] ++\n%\t[unsigned_lit_match(V, Sz) || V <- lists:seq(-2, 8),\n%\t\t\t\t Sz <- [0,1,2]] ++\n%\t[unicode_match(V) ||\n%\t V <- [-100,-1,0,1,2|lists:seq(16#10FFFC, 16#110004)]],\n% Code = ?Q([\"-module('@Mod@').\\n\"\n%\t \"-export([f/0]).\\n\"\n%\t \"f() ->\\n\"\n%\t \"_@S,\\n\"\n%\t \"ok.\\n\"]),\n% merl:print(Code),\n% Opts = test_lib:opt_opts(?MODULE),\n% {ok,_} = merl:compile_and_load(Code, Opts),\n% Mod:f(),\n\n {'EXIT',<<42>>} = (catch bad_literals_1()),\n\n Sz = id(8),\n {'EXIT',{{badmatch,_},_}} = (catch <<-1:Sz>> = <<-1>>),\n ok.\n\nbad_literals_1() ->\n BadSz = bad,\n case case <<42>> of\n\t <<42:BadSz>> -> ok;\n\t Val -> exit(Val)\n\t end of\n\tok -> ok;\n\terror -> error\n end.\n\n%signed_lit_match(V, Sz) ->\n% case <> of\n%\t<> ->\n%\t ?Q(\"<<_@V@:_@Sz@/signed>> = <<_@V@:_@Sz@>>\");\n%\t_ ->\n%\t ?Q([\"case <<_@V@:_@Sz@>> of\\n\",\n%\t\t\" <<_@V@:_@Sz@/signed>> ->\\n\",\n%\t\t\" ct:fail(should_not_match);\\n\",\n%\t\t\" _ ->\\n\",\n%\t\t\" ok\\n\",\n%\t\t\"end\\n\"])\n% end.\n\n%unsigned_lit_match(V, Sz) ->\n% case <> of\n%\t<> ->\n%\t ?Q(\"<<_@V@:_@Sz@>> = <<_@V@:_@Sz@>>\");\n%\t_ ->\n%\t ?Q([\"case <<_@V@:_@Sz@>> of\\n\",\n%\t\t\" <<_@V@:_@Sz@/unsigned>> ->\\n\",\n%\t\t\" ct:fail(should_not_match);\\n\",\n%\t\t\" _ ->\\n\",\n%\t\t\" ok\\n\",\n%\t\t\"end\\n\"])\n% end.\n\n%unicode_match(V) ->\n% try <> of\n%\t<> ->\n%\t ?Q([\"<<_@V@/utf8>> = <<_@V@/utf8>>,\\n\",\n%\t\t\"<<_@V@/utf16>> = <<_@V@/utf16>>,\\n\",\n%\t\t\"<<_@V@/utf32>> = <<_@V@/utf32>>\\n\"])\n% catch\n%\terror:badarg ->\n%\t ?Q([\"case <<_@V@:32>> of\\n\",\n%\t\t\" <<_@V@/utf32>> ->\\n\",\n%\t\t\" ct:fail(should_not_match);\\n\",\n%\t\t\" _ ->\\n\",\n%\t\t\" ok\\n\",\n%\t\t\"end\\n\"])\n% end.\n\n%% Test a few legal but rare cases.\n\ngood_literals(_Config) ->\n Sz = id(64),\n\n %% Variable size.\n <<42:Sz>> = id(<<42:Sz>>),\n <<42.0:Sz/float>> = id(<<42:Sz/float>>),\n\n %% unit > 1\n <<16#cafebeef:4/unit:8>> = id(<<16#cafebeef:32>>),\n ok.\n\nconstant_propagation(_Config) ->\n <<5>> = constant_propagation_a(a, <<5>>),\n {'EXIT',{{case_clause,b},_}} = (catch constant_propagation_a(b, <<5>>)),\n 258 = constant_propagation_b(<<1,2>>),\n F = constant_propagation_c(),\n 259 = F(<<1,3>>),\n ok.\n\nconstant_propagation_a(X, Y) ->\n case X of\n\ta -> Y2 = 8\n end,\n <<5:Y2>> = Y.\n\nconstant_propagation_b(B) ->\n Sz = 16,\n <> = B,\n X.\n\nconstant_propagation_c() ->\n Size = 16,\n fun(Bin) ->\n\t <> = Bin,\n\t X\n end.\n\nparse_xml(_Config) ->\n <<\"> = do_parse_xml(<<\">),\n <<\" \">> = do_parse_xml(<<\">),\n ok.\n\ndo_parse_xml(<<\"> = Bytes) ->\n %% Delayed sub-binary creation is not safe. A buggy (development)\n %% version of check_liveness_everywhere() in beam_utils would turn\n %% on the optimization.\n Rest1 = case is_next_char_whitespace(Rest) of\n\t\tfalse ->\n\t\t Bytes;\n\t\ttrue ->\n\t\t id(Rest)\n\t end,\n id(Rest1).\n\nis_next_char_whitespace(<>) ->\n C =:= $\\s.\n\n-record(ext_header,\n {this_hdr = 17,\n ext_hdr_opts}).\n\nget_payload(_Config) ->\n <<3445:48>> = do_get_payload(#ext_header{ext_hdr_opts = <<3445:48>>}),\n {'EXIT',_} = (catch do_get_payload(#ext_header{})),\n ok.\n\ndo_get_payload(ExtHdr) ->\n _ = ExtHdr#ext_header.this_hdr,\n ExtHdrOptions = ExtHdr#ext_header.ext_hdr_opts,\n <<_:13,_:35>> = ExtHdr#ext_header.ext_hdr_opts,\n ExtHdrOptions.\n\nescape(_Config) ->\n 0 = escape(<<>>, 0),\n 1 = escape(<<128>>, 0),\n 2 = escape(<<128,255>>, 0),\n 42 = escape(<<42>>, 0),\n 50 = escape(<<42,8>>, 0),\n ok.\n\nescape(<>, Pos) when Byte >= 127 ->\n escape(Rest, Pos + 1);\nescape(<>, Pos) ->\n escape(Rest, Pos + Byte);\nescape(<<_Rest/bits>>, Pos) ->\n Pos.\n\n%% ERL-490\nnum_slots_different(_Config) ->\n Ts = [{<<\"de\">>, <<\"default\">>, <<\"Remove\">>, <<\"a\">>},\n {<<\"de\">>, <<\"default\">>, <<\"Remove from list\">>, <<\"a\">>},\n {<<\"de\">>, <<\"default\">>, <<\"Remove from the list\">>, <<\"a\">>},\n {<<\"de\">>, <<\"default\">>, <<\"Results\">>, <<\"Ergebnisse\">>},\n {<<\"de\">>, <<\"default\">>, <<\"Reservatio\">>, <<\"a\">>},\n {<<\"de\">>, <<\"navigation\">>, <<\"Results\">>, <<\"Ergebnisse\">>},\n {<<\"de\">>, <<\"navigation\">>, <<\"Resources\">>, <<\"Ressourcen\">>}],\n _ = [{ok,Res} = lgettext(A, B, C) || {A,B,C,Res} <- Ts],\n\n {'EXIT',_} = (catch lgettext(<<\"d\">>, <<\"default\">>, <<\"Remove\">>)),\n {'EXIT',_} = (catch lgettext(\"\", <<\"default\">>, <<\"Remove\">>)),\n {'EXIT',_} = (catch lgettext(<<\"de\">>, <<\"def\">>, <<\"Remove\">>)),\n {'EXIT',_} = (catch lgettext(<<\"de\">>, <<\"default\">>, <<\"Res\">>)),\n ok.\n\n\nlgettext(<<\"de\">>, <<\"default\">>, <<\"Remove\">>) ->\n {ok, <<\"a\">>};\nlgettext(<<\"de\">>, <<\"default\">>, <<\"Remove from list\">>) ->\n {ok, <<\"a\">>};\nlgettext(<<\"de\">>, <<\"default\">>, <<\"Remove from the list\">>) ->\n {ok, <<\"a\">>};\nlgettext(<<\"de\">>, <<\"default\">>, <<\"Results\">>) ->\n {ok, <<\"Ergebnisse\">>};\nlgettext(<<\"de\">>, <<\"default\">>, <<\"Reservatio\">>) ->\n {ok, <<\"a\">>};\nlgettext(<<\"de\">>, <<\"navigation\">>, <<\"Results\">>) ->\n {ok, <<\"Ergebnisse\">>};\nlgettext(<<\"de\">>, <<\"navigation\">>, <<\"Resources\">>) ->\n {ok, <<\"Ressourcen\">>}.\n\n%% Test more code in beam_bsm.\nbeam_bsm(_Config) ->\n true = check_bitstring_list(<<1:1,0:1,1:1,1:1>>, [1,0,1,1]),\n false = check_bitstring_list(<<1:1,0:1,1:1,1:1>>, [0]),\n\n true = bsm_validate_scheme(<<>>),\n true = bsm_validate_scheme(<<5,10>>),\n false = bsm_validate_scheme(<<5,10,11,12>>),\n true = bsm_validate_scheme([]),\n true = bsm_validate_scheme([5,10]),\n false = bsm_validate_scheme([5,6,7]),\n\n <<1,2,3>> = bsm_must_save_and_not_save(<<1,2,3>>, []),\n D = fun(N) -> 2*N end,\n [2,4|<<3>>] = bsm_must_save_and_not_save(<<1,2,3>>, [D,D]),\n\n ok.\n\ncheck_bitstring_list(<>, [H|T2]) ->\n check_bitstring_list(T1, T2);\ncheck_bitstring_list(<<>>, []) ->\n true;\ncheck_bitstring_list(_, _) ->\n false.\n\nbsm_validate_scheme([]) -> true;\nbsm_validate_scheme([H|T]) ->\n case bsm_is_scheme(H) of\n true -> bsm_validate_scheme(T);\n false -> false\n end;\nbsm_validate_scheme(<<>>) -> true;\nbsm_validate_scheme(<>) ->\n case bsm_is_scheme(H) of\n true -> bsm_validate_scheme(Rest);\n false -> false\n end.\n\nbsm_is_scheme(Int) ->\n Int rem 5 =:= 0.\n\n%% NOT OPTIMIZED: different control paths use different positions in the binary\nbsm_must_save_and_not_save(Bin, []) ->\n Bin;\nbsm_must_save_and_not_save(<>, [F|Fs]) ->\n [F(H)|bsm_must_save_and_not_save(T, Fs)];\nbsm_must_save_and_not_save(<<>>, []) ->\n [].\n\nguard(_Config) ->\n _Tuple = id({a,b}),\n ok = guard_1(<<1,2,3>>, {1,2,3}),\n ok = guard_2(<<42>>, #{}),\n ok.\n\n%% Cover handling of #k_put{} in v3_codegen:bsm_rename_ctx/4.\nguard_1(<>, Tuple) when Tuple =:= {A,B,C} ->\n ok.\n\n%% Cover handling of #k_call{} in v3_codegen:bsm_rename_ctx/4.\nguard_2(<<_>>, Healing) when Healing#{[] => Healing} =:= #{[] => #{}} ->\n ok.\n\nis_ascii(_Config) ->\n true = do_is_ascii(<<>>),\n true = do_is_ascii(<<\"string\">>),\n false = do_is_ascii(<<1024/utf8>>),\n {'EXIT',{function_clause,_}} = (catch do_is_ascii(<<$A,0:3>>)),\n {'EXIT',{function_clause,_}} = (catch do_is_ascii(<<16#80,0:3>>)),\n ok.\n\ndo_is_ascii(<<>>) ->\n true;\ndo_is_ascii(<>) when C >= 16#80 ->\n %% This clause must fail to match if the size of the argument in\n %% bits is not divisible by 8. Beware of unsafe optimizations.\n false;\ndo_is_ascii(<<_, T/binary>>) ->\n do_is_ascii(T).\n\nnon_opt_eq(_Config) ->\n true = non_opt_eq([], <<>>),\n true = non_opt_eq([$a], <<$a>>),\n false = non_opt_eq([$a], <<$b>>),\n ok.\n\n%% An example from the Efficiency Guide. It used to be not optimized,\n%% but now it can be optimized.\n\nnon_opt_eq([H|T1], <>) ->\n non_opt_eq(T1, T2);\nnon_opt_eq([_|_], <<_,_/binary>>) ->\n false;\nnon_opt_eq([], <<>>) ->\n true.\n\n%% ERL-689\n\nerl_689(_Config) ->\n {{0, 0, 0}, <<>>} = do_erl_689_1(<<0>>, ?MODULE),\n {{2018, 8, 7}, <<>>} = do_erl_689_1(<<4,2018:16/little,8,7>>, ?MODULE),\n {{0, 0, 0}, <<>>} = do_erl_689_2(?MODULE, <<0>>),\n {{2018, 8, 7}, <<>>} = do_erl_689_2(?MODULE, <<4,2018:16/little,8,7>>),\n ok.\n\ndo_erl_689_1(Arg1, Arg2) ->\n Res = do_erl_689_1a(Arg1, Arg2),\n Res = do_erl_689_1b(Arg1, Arg2).\n\ndo_erl_689_2(Arg1, Arg2) ->\n Res = do_erl_689_2a(Arg1, Arg2),\n Res = do_erl_689_2b(Arg1, Arg2).\n\ndo_erl_689_1a(<>, _) ->\n case {Data, Length} of\n {_, 0} ->\n %% bs_context_to_binary would incorrectly set Data to the original\n %% binary (before matching in the function head).\n {{0, 0, 0}, Data};\n {<>, 4} ->\n {{Y, M, D}, Rest}\n end.\n\ndo_erl_689_1b(<>, _) ->\n case {Data, Length} of\n {_, 0} ->\n %% bs_context_to_binary would incorrectly set Data to the original\n %% binary (before matching in the function head).\n id(0),\n {{0, 0, 0}, Data};\n {<>, 4} ->\n id(1),\n {{Y, M, D}, Rest}\n end.\n\ndo_erl_689_2a(_, <>) ->\n case {Length, Data} of\n {0, _} ->\n %% bs_context_to_binary would incorrectly set Data to the original\n %% binary (before matching in the function head).\n {{0, 0, 0}, Data};\n {4, <>} ->\n {{Y, M, D}, Rest}\n end.\n\ndo_erl_689_2b(_, <>) ->\n case {Length, Data} of\n {0, _} ->\n %% bs_context_to_binary would incorrectly set Data to the original\n %% binary (before matching in the function head).\n id(0),\n {{0, 0, 0}, Data};\n {4, <>} ->\n id(1),\n {{Y, M, D}, Rest}\n end.\n\n%% ERL-753\n\nbs_start_match2_defs(_Config) ->\n {<<\"http://127.0.0.1:1234/vsaas/hello\">>} = api_url(<<\"hello\">>, dummy),\n {\"https://127.0.0.1:4321/vsaas/hello\"} = api_url({https, \"hello\"}, dummy).\n\napi_url(URL, Auth) ->\n Header = [],\n case URL of\n <<_/binary>> -> {<<\"http://127.0.0.1:1234/vsaas/\",URL/binary>>};\n {https, [_|_] = URL1} -> {\"https://127.0.0.1:4321/vsaas/\"++URL1}\n end.\n\ncheck(F, R) ->\n R = F().\n\nid(I) -> I.\n" }, { "path": "otp_build/bs_match_SUITE.erl.patch", "content": "49c49\n< -include_lib(\"syntax_tools/include/merl.hrl\").\n---\n> %-include_lib(\"syntax_tools/include/merl.hrl\").\n74c74,75\n< bad_literals,good_literals,constant_propagation,parse_xml,\n---\n> % bad_literals,good_literals,constant_propagation,parse_xml,\n> good_literals,constant_propagation,parse_xml,\n1399,1415c1400,1416\n< Mod = list_to_atom(?MODULE_STRING ++ \"_\" ++\n< \t\t\t atom_to_list(?FUNCTION_NAME)),\n< S = [signed_lit_match(V, Sz) || V <- lists:seq(-8, 8),\n< \t\t\t\t Sz <- [0,1,2,3]] ++\n< \t[unsigned_lit_match(V, Sz) || V <- lists:seq(-2, 8),\n< \t\t\t\t Sz <- [0,1,2]] ++\n< \t[unicode_match(V) ||\n< \t V <- [-100,-1,0,1,2|lists:seq(16#10FFFC, 16#110004)]],\n< Code = ?Q([\"-module('@Mod@').\\n\"\n< \t \"-export([f/0]).\\n\"\n< \t \"f() ->\\n\"\n< \t \"_@S,\\n\"\n< \t \"ok.\\n\"]),\n< merl:print(Code),\n< Opts = test_lib:opt_opts(?MODULE),\n< {ok,_} = merl:compile_and_load(Code, Opts),\n< Mod:f(),\n---\n> % Mod = list_to_atom(?MODULE_STRING ++ \"_\" ++\n> %\t\t\t atom_to_list(?FUNCTION_NAME)),\n> % S = [signed_lit_match(V, Sz) || V <- lists:seq(-8, 8),\n> %\t\t\t\t Sz <- [0,1,2,3]] ++\n> %\t[unsigned_lit_match(V, Sz) || V <- lists:seq(-2, 8),\n> %\t\t\t\t Sz <- [0,1,2]] ++\n> %\t[unicode_match(V) ||\n> %\t V <- [-100,-1,0,1,2|lists:seq(16#10FFFC, 16#110004)]],\n> % Code = ?Q([\"-module('@Mod@').\\n\"\n> %\t \"-export([f/0]).\\n\"\n> %\t \"f() ->\\n\"\n> %\t \"_@S,\\n\"\n> %\t \"ok.\\n\"]),\n> % merl:print(Code),\n> % Opts = test_lib:opt_opts(?MODULE),\n> % {ok,_} = merl:compile_and_load(Code, Opts),\n> % Mod:f(),\n1433,1473c1434,1474\n< signed_lit_match(V, Sz) ->\n< case <> of\n< \t<> ->\n< \t ?Q(\"<<_@V@:_@Sz@/signed>> = <<_@V@:_@Sz@>>\");\n< \t_ ->\n< \t ?Q([\"case <<_@V@:_@Sz@>> of\\n\",\n< \t\t\" <<_@V@:_@Sz@/signed>> ->\\n\",\n< \t\t\" ct:fail(should_not_match);\\n\",\n< \t\t\" _ ->\\n\",\n< \t\t\" ok\\n\",\n< \t\t\"end\\n\"])\n< end.\n< \n< unsigned_lit_match(V, Sz) ->\n< case <> of\n< \t<> ->\n< \t ?Q(\"<<_@V@:_@Sz@>> = <<_@V@:_@Sz@>>\");\n< \t_ ->\n< \t ?Q([\"case <<_@V@:_@Sz@>> of\\n\",\n< \t\t\" <<_@V@:_@Sz@/unsigned>> ->\\n\",\n< \t\t\" ct:fail(should_not_match);\\n\",\n< \t\t\" _ ->\\n\",\n< \t\t\" ok\\n\",\n< \t\t\"end\\n\"])\n< end.\n< \n< unicode_match(V) ->\n< try <> of\n< \t<> ->\n< \t ?Q([\"<<_@V@/utf8>> = <<_@V@/utf8>>,\\n\",\n< \t\t\"<<_@V@/utf16>> = <<_@V@/utf16>>,\\n\",\n< \t\t\"<<_@V@/utf32>> = <<_@V@/utf32>>\\n\"])\n< catch\n< \terror:badarg ->\n< \t ?Q([\"case <<_@V@:32>> of\\n\",\n< \t\t\" <<_@V@/utf32>> ->\\n\",\n< \t\t\" ct:fail(should_not_match);\\n\",\n< \t\t\" _ ->\\n\",\n< \t\t\" ok\\n\",\n< \t\t\"end\\n\"])\n< end.\n---\n> %signed_lit_match(V, Sz) ->\n> % case <> of\n> %\t<> ->\n> %\t ?Q(\"<<_@V@:_@Sz@/signed>> = <<_@V@:_@Sz@>>\");\n> %\t_ ->\n> %\t ?Q([\"case <<_@V@:_@Sz@>> of\\n\",\n> %\t\t\" <<_@V@:_@Sz@/signed>> ->\\n\",\n> %\t\t\" ct:fail(should_not_match);\\n\",\n> %\t\t\" _ ->\\n\",\n> %\t\t\" ok\\n\",\n> %\t\t\"end\\n\"])\n> % end.\n> \n> %unsigned_lit_match(V, Sz) ->\n> % case <> of\n> %\t<> ->\n> %\t ?Q(\"<<_@V@:_@Sz@>> = <<_@V@:_@Sz@>>\");\n> %\t_ ->\n> %\t ?Q([\"case <<_@V@:_@Sz@>> of\\n\",\n> %\t\t\" <<_@V@:_@Sz@/unsigned>> ->\\n\",\n> %\t\t\" ct:fail(should_not_match);\\n\",\n> %\t\t\" _ ->\\n\",\n> %\t\t\" ok\\n\",\n> %\t\t\"end\\n\"])\n> % end.\n> \n> %unicode_match(V) ->\n> % try <> of\n> %\t<> ->\n> %\t ?Q([\"<<_@V@/utf8>> = <<_@V@/utf8>>,\\n\",\n> %\t\t\"<<_@V@/utf16>> = <<_@V@/utf16>>,\\n\",\n> %\t\t\"<<_@V@/utf32>> = <<_@V@/utf32>>\\n\"])\n> % catch\n> %\terror:badarg ->\n> %\t ?Q([\"case <<_@V@:32>> of\\n\",\n> %\t\t\" <<_@V@/utf32>> ->\\n\",\n> %\t\t\" ct:fail(should_not_match);\\n\",\n> %\t\t\" _ ->\\n\",\n> %\t\t\" ok\\n\",\n> %\t\t\"end\\n\"])\n> % end.\n" }, { "path": "otp_build/bs_match_SUITE_patched.erl", "content": "%%\n%% %CopyrightBegin%\n%%\n%% Copyright Ericsson AB 2005-2018. All Rights Reserved.\n%%\n%% Licensed under the Apache License, Version 2.0 (the \"License\");\n%% you may not use this file except in compliance with the License.\n%% You may obtain a copy of the License at\n%%\n%% http://www.apache.org/licenses/LICENSE-2.0\n%%\n%% Unless required by applicable law or agreed to in writing, software\n%% distributed under the License is distributed on an \"AS IS\" BASIS,\n%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n%% See the License for the specific language governing permissions and\n%% limitations under the License.\n%%\n%% %CopyrightEnd%\n%%\n\n-module(bs_match_SUITE).\n-compile(nowarn_shadow_vars).\n\n-export([all/0, suite/0,groups/0,init_per_suite/1, end_per_suite/1, \n\t init_per_group/2,end_per_group/2,\n\t init_per_testcase/2,end_per_testcase/2,\n\t size_shadow/1,int_float/1,otp_5269/1,null_fields/1,wiger/1,\n\t bin_tail/1,save_restore/1,\n\t partitioned_bs_match/1,function_clause/1,\n\t unit/1,shared_sub_bins/1,bin_and_float/1,\n\t dec_subidentifiers/1,skip_optional_tag/1,decode_integer/1,\n\t wfbm/1,degenerated_match/1,bs_sum/1,coverage/1,\n\t multiple_uses/1,zero_label/1,followed_by_catch/1,\n\t matching_meets_construction/1,simon/1,matching_and_andalso/1,\n\t otp_7188/1,otp_7233/1,otp_7240/1,otp_7498/1,\n\t match_string/1,zero_width/1,bad_size/1,haystack/1,\n\t cover_beam_bool/1,matched_out_size/1,follow_fail_branch/1,\n\t no_partition/1,calling_a_binary/1,binary_in_map/1,\n\t match_string_opt/1,select_on_integer/1,\n\t map_and_binary/1,unsafe_branch_caching/1,\n\t bad_literals/1,good_literals/1,constant_propagation/1,\n\t parse_xml/1,get_payload/1,escape/1,num_slots_different/1,\n beam_bsm/1,guard/1,is_ascii/1,non_opt_eq/1,erl_689/1,\n bs_start_match2_defs/1]).\n\n-export([coverage_id/1,coverage_external_ignore/2]).\n\n-include_lib(\"common_test/include/ct.hrl\").\n%-include_lib(\"syntax_tools/include/merl.hrl\").\n\n\nsuite() ->\n [{ct_hooks,[ts_install_cth]},\n {timetrap,{minutes,1}}].\n\nall() -> \n [{group,p}].\n\ngroups() -> \n [{p,[parallel],\n [size_shadow,int_float,otp_5269,null_fields,wiger,\n bin_tail,save_restore,\n partitioned_bs_match,function_clause,unit,\n shared_sub_bins,bin_and_float,dec_subidentifiers,\n skip_optional_tag,decode_integer,wfbm,degenerated_match,bs_sum,\n coverage,multiple_uses,zero_label,followed_by_catch,\n matching_meets_construction,simon,\n matching_and_andalso,otp_7188,otp_7233,otp_7240,\n otp_7498,match_string,zero_width,bad_size,haystack,\n cover_beam_bool,matched_out_size,follow_fail_branch,\n no_partition,calling_a_binary,binary_in_map,\n match_string_opt,select_on_integer,\n map_and_binary,unsafe_branch_caching,\n% bad_literals,good_literals,constant_propagation,parse_xml,\n good_literals,constant_propagation,parse_xml,\n get_payload,escape,num_slots_different,\n beam_bsm,guard,is_ascii,non_opt_eq,erl_689,\n bs_start_match2_defs]}].\n\n\ninit_per_suite(Config) ->\n test_lib:recompile(?MODULE),\n Config.\n\nend_per_suite(_Config) ->\n ok.\n\ninit_per_group(_GroupName, Config) ->\n Config.\n\nend_per_group(_GroupName, Config) ->\n Config.\n\n\ninit_per_testcase(Case, Config) when is_atom(Case), is_list(Config) ->\n Config.\n\nend_per_testcase(Case, Config) when is_atom(Case), is_list(Config) ->\n ok.\n\nsize_shadow(Config) when is_list(Config) ->\n %% Originally OTP-5270.\n 7 = size_shadow_1(),\n 7 = size_shadow_2(8),\n 7 = size_shadow_3(),\n no = size_shadow_4(8),\n Any = {any,term,goes},\n {2577,Any,-175,whatever} =\n\t(size_shadow_5(Any, 12))(<<2577:12>>, -175, whatever),\n {7777,Any,42,whatever} =\n\t(size_shadow_6(Any, 13))(42, <<7777:13>>, whatever),\n {<<45>>,<<>>} = size_shadow_7({int,1}, <<1:16,45>>),\n {'EXIT',{function_clause,_}} =\n\t(catch size_shadow_7({int,42}, <<1:16,45>>)),\n ok.\n\nsize_shadow_1() ->\n L = 8,\n F = fun(<>) -> B end,\n F(<<16:8, 7:16>>).\n\nsize_shadow_2(L) ->\n F = fun(<>) -> B end,\n F(<<16:8, 7:16>>).\n\nsize_shadow_3() ->\n L = 8,\n F = fun(<>) -> B end,\n F(<<16:8, 7:16,16:16>>).\n\nsize_shadow_4(L) ->\n F = fun(<>) -> B;\n\t (_) -> no end,\n F(<<16:8, 7:16,15:16>>).\n\nsize_shadow_5(X, Y) ->\n fun (<< A:Y >>, Y, B) -> fum(A, X, Y, B) end.\n\nsize_shadow_6(X, Y) ->\n fun (Y, << A:Y >>, B) -> fum(A, X, Y, B) end.\n\nfum(A, B, C, D) ->\n {A,B,C,D}.\n\nsize_shadow_7({int,N}, <>) ->\n {B,T}.\n\n\nint_float(Config) when is_list(Config) ->\n %% OTP-5323\n <<103133.0:64/float>> = <<103133:64/float>>,\n <<103133:64/float>> = <<103133:64/float>>,\n\n %% Coverage of error cases in sys_pre_expand:coerce_to_float/2.\n case id(default) of\n\t<<(1 bsl 1024):64/float>> ->\n\t ct:fail(should_not_match);\n\tdefault ->\n\t ok\n end.\n\n%% Stolen from erl_eval_SUITE and modified.\n%% OTP-5269. Bugs in the bit syntax.\notp_5269(Config) when is_list(Config) ->\n check(fun() -> L = 8,\n\t\t F = fun(<>) -> B end,\n\t\t F(<<16:8, 7:16>>)\n end,\n 7),\n check(fun() -> L = 8, <> = <<16:8, 7:16>>, B end,\n\t 7),\n check(fun() -> U = 8, (fun(<>) -> U end)(<<32:8>>) end,\n\t 32),\n check(fun() -> U = 8, [U || <> <- [<<32:8>>]] end,\n\t [32]),\n check(fun() -> [X || <> <- [<<16:8,19:16>>],\n\t\t\t <> <- [<>]] end,\n\t [19]),\n check(fun() -> A = 4, B = 28, bit_size(<<13:(A+(X=B))>>), X end,\n\t 28),\n check(fun() ->\n\t\t <> = <<2,\"AB\",\"CD\">>,\n\t\t {Size,B,Rest}\n\t end,\n\t {2,<<\"AB\">>,<<\"CD\">>}),\n check(fun() -> X = 32,\n\t\t [X || <> <- [<<1:32>>,<<2:32>>,<<3:8>>]] end,\n %% \"binsize variable\" ^\n\t [1,2]),\n check(fun() ->\n\t\t (fun (<>) ->\n\t\t\t case A of\n\t\t\t B -> wrong;\n\t\t\t _ -> ok\n\t\t\t end\n\t\t end)(<<1,2,3,4>>) end,\n\t ok),\n ok.\n\nnull_fields(Config) when is_list(Config) ->\n check(fun() ->\n\t\t W = id(0),\n\t\t F = fun(<<_:W>>) -> tail;\n\t\t\t (<<>>) -> empty\n\t\t end,\n\t\t F(<<>>)\n\t end, tail),\n check(fun() ->\n\t\t F = fun(<<_/binary>>) -> tail;\n\t\t\t (<<>>) -> empty\n\t\t end,\n\t\t F(<<>>)\n\t end, tail),\n ok.\n\nwiger(Config) when is_list(Config) ->\n ok1 = wcheck(<<3>>),\n ok2 = wcheck(<<1,2,3>>),\n ok3 = wcheck(<<4>>),\n {error,<<1,2,3,4>>} = wcheck(<<1,2,3,4>>),\n {error,<<>>} = wcheck(<<>>),\n ok.\n\nwcheck(<>) when A==3->\n ok1;\nwcheck(<<_,_:2/binary>>) ->\n ok2;\nwcheck(<<_>>) ->\n ok3;\nwcheck(Other) ->\n {error,Other}.\n\nbin_tail(Config) when is_list(Config) ->\n S = <<\"abcde\">>,\n $a = bin_tail_c(S, 0),\n $c = bin_tail_c(S, 2),\n $e = bin_tail_c(S, 4),\n {'EXIT',_} = (catch bin_tail_c(S, 5)),\n {'EXIT',_} = (catch bin_tail_c_var(S, 5)),\n\n $a = bin_tail_d(S, 0),\n $b = bin_tail_d(S, 8),\n $d = bin_tail_d(S, 3*8),\n {'EXIT',_} = (catch bin_tail_d_dead(S, 1)),\n {'EXIT',_} = (catch bin_tail_d_dead(S, 9)),\n {'EXIT',_} = (catch bin_tail_d_dead(S, 5*8)),\n {'EXIT',_} = (catch bin_tail_d_var(S, 1)),\n\n ok = bin_tail_e(<<2:2,0:1,1:5>>),\n ok = bin_tail_e(<<2:2,1:1,1:5,42:64>>),\n error = bin_tail_e(<<3:2,1:1,1:5,42:64>>),\n error = bin_tail_e(<<>>),\n ok.\n\nbin_tail_c(Bin, Offset) ->\n Res = bin_tail_c_dead(Bin, Offset),\n <<_:Offset/binary,_,Tail/binary>> = Bin,\n {Res,Tail} = bin_tail_c_var(Bin, Offset),\n Res.\n\nbin_tail_c_dead(Bin, Offset) ->\n <<_:Offset/binary,C,_/binary>> = Bin,\n C.\n\nbin_tail_c_var(Bin, Offset) ->\n <<_:Offset/binary,C,Tail/binary>> = Bin,\n {C,Tail}.\n\n\nbin_tail_d(Bin, BitOffset) ->\n Res = bin_tail_d_dead(Bin, BitOffset),\n <<_:BitOffset,_:8,Tail/binary>> = Bin,\n {Res,Tail} = bin_tail_d_var(Bin, BitOffset),\n Res.\n\nbin_tail_d_dead(Bin, BitOffset) ->\n <<_:BitOffset,C,_/binary>> = Bin,\n C.\n\nbin_tail_d_var(Bin, BitOffset) ->\n <<_:BitOffset,C,Tail/binary>> = Bin,\n {C,Tail}.\n\nbin_tail_e(Bin) ->\n case bin_tail_e_dead(Bin) of\n\tok ->\n\t <<_,Tail/binary>> = Bin,\n\t Tail = bin_tail_e_var(Bin),\n\t ok;\n\terror ->\n\t bin_tail_e_var(Bin)\n end.\n\nbin_tail_e_dead(Bin) ->\n case Bin of\n\t%% The binary is aligned at the end; neither the bs_skip_bits2 nor\n\t%% bs_test_tail2 instructions are needed.\n\t<<2:2,_:1,1:5,_/binary>> -> ok;\n\t_ -> error\n end.\n\nbin_tail_e_var(Bin) ->\n case Bin of\n\t%% The binary is aligned at the end; neither the bs_skip_bits2 nor\n\t%% bs_test_tail2 instructions are needed.\n\t<<2:2,_:1,1:5,Tail/binary>> -> Tail;\n\t_ -> error\n end.\n\t \nsave_restore(Config) when is_list(Config) ->\n 0 = save_restore_1(<<0:2,42:6>>),\n {1,3456} = save_restore_1(<<1:2,3456:14>>),\n {2,7981234} = save_restore_1(<<2:2,7981234:30>>),\n {3,763967493838} = save_restore_1(<<0:2,763967493838:62>>),\n\n A = <<\" x\">>,\n B = <<\".x\">>,\n C = <<\"-x\">>,\n\n {\" \",<<\"x\">>} = lll(A),\n {\" \",<<\"x\">>} = mmm(A),\n {\" \",<<\"x\">>} = nnn(A),\n {\" \",<<\"x\">>} = ooo(A),\n\n {\".\",<<\"x\">>} = lll(B),\n {\".\",<<\"x\">>} = mmm(B),\n {\".\",<<\"x\">>} = nnn(B),\n {\".\",<<\"x\">>} = ooo(B),\n\n {\"-\",<<\"x\">>} = lll(C),\n {\"-\",<<\"x\">>} = mmm(C),\n {\"-\",<<\"x\">>} = nnn(C),\n {\"-\",<<\"x\">>} = ooo(C),\n\n a = multiple_matches(<<777:16>>, <<777:16>>),\n b = multiple_matches(<<777:16>>, <<999:16>>),\n c = multiple_matches(<<777:16>>, <<57:8>>),\n d = multiple_matches(<<17:8>>, <<1111:16>>),\n\n Bin = <<-1:64>>,\n case bad_float_unpack_match(Bin) of\n\t-1 -> ok;\n\t_Other -> ct:fail(bad_return_value_probably_NaN)\n end.\n\nsave_restore_1(Bin) ->\n case Bin of\n\t<<0:2,_:6>> -> 0;\n\t<<1:2,A:14>> -> {1,A};\n\t<<2:2,A:30>> -> {2,A};\n\t<> -> {3,A}\n end.\n\nlll(<>) -> {[Char],Tail}.\n\nmmm(<<$.,$.,$., Tail/binary>>) -> Tail;\nmmm(<<$\\s,$-,$\\s, Tail/binary>>) -> Tail;\nmmm(<>) -> {[Char],Tail}. %% Buggy Tail!\n\nnnn(<<\"...\", Tail/binary>>) -> Tail;\nnnn(<<\" - \", Tail/binary>>) -> Tail;\nnnn(<>) -> {[Char],Tail}. %% Buggy Tail!\n\nooo(<<\" - \", Tail/binary>>) -> Tail;\nooo(<>) -> {[Char],Tail}.\n\nmultiple_matches(<>, <>) -> a;\nmultiple_matches(<<_:16>>, <<_:16>>) -> b;\nmultiple_matches(<<_:16>>, <<_:8>>) -> c;\nmultiple_matches(<<_:8>>, <<_:16>>) -> d.\n\nbad_float_unpack_match(<>) -> F;\nbad_float_unpack_match(<>) -> I.\n\n\npartitioned_bs_match(Config) when is_list(Config) ->\n <<1,2,3>> = partitioned_bs_match(blurf, <<42,1,2,3>>),\n error = partitioned_bs_match(10, <<7,8,15,13>>),\n error = partitioned_bs_match(100, {a,tuple,is,'not',a,binary}),\n ok = partitioned_bs_match(0, <<>>),\n fc(partitioned_bs_match, [-1,blurf],\n\t catch partitioned_bs_match(-1, blurf)),\n fc(partitioned_bs_match, [-1,<<1,2,3>>],\n\t catch partitioned_bs_match(-1, <<1,2,3>>)),\n {17,<<1,2,3>>} = partitioned_bs_match_2(1, <<17,1,2,3>>),\n {7,<<1,2,3>>} = partitioned_bs_match_2(7, <<17,1,2,3>>),\n\n fc(partitioned_bs_match_2, [4,<<0:17>>],\n\t catch partitioned_bs_match_2(4, <<0:17>>)),\n\n anything = partitioned_bs_match_3(anything, <<42>>),\n ok = partitioned_bs_match_3(1, 2),\n\n ok.\n\npartitioned_bs_match(_, <<42:8,T/binary>>) ->\n T;\npartitioned_bs_match(N, _) when N > 0 ->\n error;\npartitioned_bs_match(_, <<>>) ->\n ok.\n\npartitioned_bs_match_2(1, <>) ->\n {B,T};\npartitioned_bs_match_2(Len, <<_:8,T/binary>>) ->\n {Len,T}.\n\npartitioned_bs_match_3(Var, <<_>>) -> Var;\npartitioned_bs_match_3(1, 2) -> ok.\n\nfunction_clause(Config) when is_list(Config) ->\n ok = function_clause_1(<<0,7,0,7,42>>),\n fc(function_clause_1, [<<0,1,2,3>>],\n catch function_clause_1(<<0,1,2,3>>)),\n fc(function_clause_1, [<<0,1,2,3>>],\n catch function_clause_1(<<0,7,0,1,2,3>>)),\n\n ok = function_clause_2(<<0,7,0,7,42>>),\n ok = function_clause_2(<<255>>),\n ok = function_clause_2(<<13:4>>),\n fc(function_clause_2, [<<0,1,2,3>>],\n catch function_clause_2(<<0,1,2,3>>)),\n fc(function_clause_2, [<<0,1,2,3>>],\n catch function_clause_2(<<0,7,0,1,2,3>>)),\n\n ok.\n\nfunction_clause_1(<<0:8,7:8,T/binary>>) ->\n function_clause_1(T);\nfunction_clause_1(<<_:8>>) ->\n ok.\n\nfunction_clause_2(<<0:8,7:8,T/binary>>) ->\n function_clause_2(T);\nfunction_clause_2(<<_:8>>) ->\n ok;\nfunction_clause_2(<<_:4>>) ->\n ok.\n\nunit(Config) when is_list(Config) ->\n 42 = peek1(<<42>>),\n 43 = peek1(<<43,1,2>>),\n 43 = peek1(<<43,1,2,(-1):1>>),\n 43 = peek1(<<43,1,2,(-1):2>>),\n 43 = peek1(<<43,1,2,(-1):7>>),\n\n 99 = peek8(<<99>>),\n 100 = peek8(<<100,101>>),\n fc(peek8, [<<100,101,0:1>>], catch peek8(<<100,101,0:1>>)),\n\n 37484 = peek16(<<37484:16>>),\n 37489 = peek16(<<37489:16,5566:16>>),\n fc(peek16, [<<8>>], catch peek16(<<8>>)),\n fc(peek16, [<<42:15>>], catch peek16(<<42:15>>)),\n fc(peek16, [<<1,2,3,4,5>>], catch peek16(<<1,2,3,4,5>>)),\n\n 127 = peek7(<<127:7>>),\n 100 = peek7(<<100:7,19:7>>),\n fc(peek7, [<<1,2>>], catch peek7(<<1,2>>)),\n ok.\n\npeek1(<>) -> B.\n\npeek7(<>) -> B.\n\npeek8(<>) -> B.\n\npeek16(<>) -> B.\n\nshared_sub_bins(Config) when is_list(Config) ->\n {15,[<<>>,<<5>>,<<4,5>>,<<3,4,5>>,<<2,3,4,5>>]} = sum(<<1,2,3,4,5>>, [], 0),\n ok.\n\nsum(<>, Acc, Sum) ->\n sum(T, [T|Acc], Sum+B);\nsum(<<>>, Last, Sum) -> {Sum,Last}.\n\n\nbin_and_float(Config) when is_list(Config) ->\n 14.0 = bin_and_float(<<1.0/float,2.0/float,3.0/float>>, 0.0),\n ok.\n\nbin_and_float(<>, Sum) when is_float(X),\n\t\t\t\t\t\t\t is_float(Y),\n\t\t\t\t\t\t\t is_float(Z) ->\n bin_and_float(T, Sum+X*X+Y*Y+Z*Z);\nbin_and_float(<<>>, Sum) -> Sum.\n\ndec_subidentifiers(Config) when is_list(Config) ->\n {[],<<1,2,3>>} =\n\tdo_dec_subidentifiers(<<1:1,42:7,1:1,99:7,1,2,3>>, 0, [], 2),\n {[5389],<<1,2,3>>} = do_dec_subidentifiers(<<1:1,42:7,0:1,13:7,1,2,3>>, 0, [], 2),\n {[3,2,1],not_a_binary} = dec_subidentifiers(not_a_binary, any, [1,2,3], 0),\n ok.\n\ndo_dec_subidentifiers(Buffer, Av, Al, Len) -> \n Res = dec_subidentifiers(Buffer, Av, Al, Len),\n Res = dec_subidentifiers2(Buffer, Av, Al, Len),\n Res = dec_subidentifiers4(Buffer, Av, Al, Len),\n Res = dec_subidentifiers3(Buffer, Av, Al, Len).\n\ndec_subidentifiers(Buffer, _Av, Al, 0) -> \n {lists:reverse(Al),Buffer}; \ndec_subidentifiers(<<1:1,H:7,T/binary>>, Av, Al, Len) -> \n dec_subidentifiers(T, (Av bsl 7) bor H, Al, Len-1);\ndec_subidentifiers(<>, Av, Al, Len) -> \n dec_subidentifiers(T, 0, [((Av bsl 7) bor H)|Al], Len-1).\n\ndec_subidentifiers2(<>, _Av, Al, 0) ->\n {lists:reverse(Al),Buffer}; \ndec_subidentifiers2(<<1:1,H:7,T/binary>>, Av, Al, Len) -> \n dec_subidentifiers2(T, (Av bsl 7) bor H, Al, Len-1); \ndec_subidentifiers2(<>, Av, Al, Len) -> \n dec_subidentifiers2(T, 0, [((Av bsl 7) bor H)|Al], Len-1).\n\ndec_subidentifiers3(Buffer, _Av, Al, 0) when is_binary(Buffer) ->\n {lists:reverse(Al),Buffer}; \ndec_subidentifiers3(<<1:1,H:7,T/binary>>, Av, Al, Len) -> \n dec_subidentifiers3(T, (Av bsl 7) bor H, Al, Len-1); \ndec_subidentifiers3(<>, Av, Al, Len) -> \n dec_subidentifiers3(T, 0, [((Av bsl 7) bor H)|Al], Len-1).\n\ndec_subidentifiers4(<<1:1,H:7,T/binary>>, Av, Al, Len) when Len =/= 0 -> \n dec_subidentifiers4(T, (Av bsl 7) bor H, Al, Len-1); \ndec_subidentifiers4(<>, Av, Al, Len) when Len =/= 0 -> \n dec_subidentifiers4(T, 0, [((Av bsl 7) bor H)|Al], Len-1);\ndec_subidentifiers4(Buffer, _Av, Al, 0) -> \n {lists:reverse(Al),Buffer}.\n\n\nskip_optional_tag(Config) when is_list(Config) ->\n {ok,<<>>} = skip_optional_tag(<<42>>, <<42>>),\n {ok,<<>>} = skip_optional_tag(<<42,1>>, <<42,1>>),\n {ok,<<1,2,3>>} = skip_optional_tag(<<42>>, <<42,1,2,3>>),\n missing = skip_optional_tag(<<2:3>>, blurf),\n ok.\n\nskip_optional_tag(<<>>, Binary) ->\n {ok,Binary};\nskip_optional_tag(<>, <>) ->\n skip_optional_tag(RestTag, Rest);\nskip_optional_tag(_, _) -> missing.\n\ndecode_integer(_Config) ->\n {10795,<<43>>,whatever} = decode_integer(1, <<42,43>>, whatever),\n {-28909,<<19>>,whatever} = decode_integer(1, <<143,19>>, whatever),\n ok.\n\ndecode_integer(Len, <>, RemovedBytes) when B1 == 0 ->\n Bin = <<_Skip:Len/unit:8, Buffer2/binary>> = <>,\n Size = byte_size(Bin),\n <> = Bin,\n {Int,Buffer2,RemovedBytes};\ndecode_integer(Len, <>, RemovedBytes) ->\n Bin = <<_Skip:Len/unit:8,Buffer2/binary>> = <>,\n Size = byte_size(Bin),\n <> = <>,\n Int = N - (1 bsl (8 * size(Bin) -1)),\n {Int,Buffer2,RemovedBytes}.\n\n-define(DATELEN, 16).\n\nwfbm(Config) when is_list(Config) ->\n %% check_for_dot_or_space and get_tail is from wfbm4 by Steve Vinoski,\n %% with modifications.\n {nomatch,0} = check_for_dot_or_space(<<\" \">>),\n {nomatch,0} = check_for_dot_or_space(<<\" abc\">>),\n {ok,<<\"abcde\">>} = check_for_dot_or_space(<<\"abcde 34555\">>),\n {nomatch,0} = check_for_dot_or_space(<<\".gurka\">>),\n {nomatch,1} = check_for_dot_or_space(<<\"g.urka\">>),\n\n nomatch = get_tail(<<>>),\n {ok,<<\"2007/10/23/blurf\">>} = get_tail(<<\"200x/2007/10/23/blurf \">>),\n {skip,?DATELEN+5} = get_tail(<<\"200x/2007/10/23/blurf.\">>),\n nomatch = get_tail(<<\"200y.2007.10.23.blurf \">>),\n {'EXIT',_} = (catch get_tail({no,binary,at,all})),\n {'EXIT',_} = (catch get_tail(no_binary)),\n ok.\n\ncheck_for_dot_or_space(Bin) ->\n check_for_dot_or_space(Bin, 0).\n\ncheck_for_dot_or_space(<<$\\s, _/binary>>, 0) ->\n {nomatch,0};\ncheck_for_dot_or_space(Bin, Len) ->\n case Bin of\n <> ->\n {ok,Front};\n <<_:Len/binary, $., _/binary>> ->\n {nomatch,Len};\n\t_ ->\n check_for_dot_or_space(Bin, Len+1)\n end.\n\nget_tail(<<>>) ->\n nomatch;\nget_tail(Bin) ->\n <> = Bin,\n case Front of\n <<_:3/binary,\"x/\",Y:4/binary,$/,M:2/binary,$/,D:2/binary,$/>> ->\n\t case check_for_dot_or_space(Tail) of\n {ok,Match} ->\n {ok,<>};\n {nomatch,Skip} -> {skip,?DATELEN + Skip}\n end;\n _ -> nomatch\n end.\n\ndegenerated_match(Config) when is_list(Config) ->\n error = degenerated_match_1(<<>>),\n 1 = degenerated_match_1(<<1:1>>),\n 2 = degenerated_match_1(<<42,43>>),\n\n error = degenerated_match_2(<<>>),\n no_split = degenerated_match_2(<<1,2>>),\n {<<1,2,3,4>>,<<5>>} = degenerated_match_2(<<1,2,3,4,5>>),\n \n ok.\n\ndegenerated_match_1(<<>>) -> error;\ndegenerated_match_1(Bin) -> byte_size(Bin).\n\ndegenerated_match_2(<<>>) -> error;\ndegenerated_match_2(Bin) ->\n case byte_size(Bin) > 4 of\n\ttrue ->\n\t split_binary(Bin, 4);\n\tfalse ->\n\t no_split\n end.\n\nbs_sum(Config) when is_list(Config) ->\n 0 = bs_sum_1([]),\n 0 = bs_sum_1(<<>>),\n 42 = bs_sum_1([42]),\n 1 = bs_sum_1(<<1>>),\n 10 = bs_sum_1([1,2,3,4]),\n 15 = bs_sum_1(<<1,2,3,4,5>>),\n 21 = bs_sum_1([1,2,3|<<4,5,6>>]),\n 15 = bs_sum_1([1,2,3|{4,5}]),\n 6 = bs_sum_1([1,2,3|zero]),\n 6 = bs_sum_1([1,2,3|0]),\n 7 = bs_sum_1([1,2,3|one]),\n\n fc(catch bs_sum_1({too,big,tuple})),\n fc(catch bs_sum_1([1,2,3|{too,big,tuple}])),\n\n [] = sneaky_alias(<<>>),\n [559,387655] = sneaky_alias(id(<<559:32,387655:32>>)),\n fc(sneaky_alias, [<<1>>], catch sneaky_alias(id(<<1>>))),\n fc(sneaky_alias, [[1,2,3,4]], catch sneaky_alias(lists:seq(1, 4))),\n ok.\n\nbs_sum_1(<>) -> H+bs_sum_1(T);\nbs_sum_1([H|T]) -> H+bs_sum_1(T);\nbs_sum_1({A,B}=_Tuple=_AliasForNoGoodReason) -> A+B;\nbs_sum_1(0) -> 0;\nbs_sum_1(zero=_Zero) -> 0;\nbs_sum_1(one) -> 1;\nbs_sum_1([]) -> 0;\nbs_sum_1(<<>>) -> 0.\n\nsneaky_alias(<<>>=L) -> binary_to_list(L);\nsneaky_alias(<>) -> [From|sneaky_alias(L)].\n\ncoverage(Config) when is_list(Config) ->\n 0 = coverage_fold(fun(B, A) -> A+B end, 0, <<>>),\n 6 = coverage_fold(fun(B, A) -> A+B end, 0, <<1,2,3>>),\n fc(catch coverage_fold(fun(B, A) ->\n\t\t\t\t\t A+B\n\t\t\t\t end, 0, [a,b,c])),\n\n {<<42.0:64/float>>,float} = coverage_build(<<>>, <<42>>, float),\n {<<>>,not_a_tuple} = coverage_build(<<>>, <<>>, not_a_tuple),\n {<<16#76,\"abc\",16#A9,\"abc\">>,{x,42,43}} =\n\tcoverage_build(<<>>, <<16#7,16#A>>, {x,y,z}),\n\n [<<2>>,<<1>>] = coverage_bc(<<1,2>>, []),\n\n {x,<<\"abc\">>,z} = coverage_setelement(<<2,\"abc\">>, {x,y,z}),\n\n [42] = coverage_apply(<<42>>, [coverage_id]),\n 42 = coverage_external(<<42>>),\n\n do_coverage_bin_to_term_list([]),\n do_coverage_bin_to_term_list([lists:seq(0, 10),{a,b,c},<<23:42>>]),\n fc(coverage_bin_to_term_list, [<<0,0,0,7>>],\n\t catch do_coverage_bin_to_term_list_1(<<7:32>>)),\n\n <<>> = coverage_per_key(<<4:32>>),\n <<$a,$b,$c>> = coverage_per_key(<<7:32,\"abc\">>),\n\n binary = coverage_bitstring(<<>>),\n binary = coverage_bitstring(<<7>>),\n bitstring = coverage_bitstring(<<7:4>>),\n other = coverage_bitstring([a]),\n ok.\n\ncoverage_fold(Fun, Acc, <>) ->\n IdFun = fun id/1,\n coverage_fold(Fun, Fun(IdFun(H), IdFun(Acc)), T);\ncoverage_fold(Fun, Acc, <<>>) when is_function(Fun, 2) -> Acc.\n\ncoverage_build(Acc0, <>, float) ->\n Float = id(<>),\n Acc = <>,\n coverage_build(Acc, T, float);\ncoverage_build(Acc0, <>, Tuple0) ->\n Str = id(<>),\n Acc = id(<>),\n Tuple = setelement(2, setelement(3, Tuple0, 43), 42),\n if\n\tbyte_size(Acc) > 0 ->\n\t coverage_build(Acc, T, Tuple)\n end;\ncoverage_build(Acc, <<>>, Tuple) -> {Acc,Tuple}.\n\ncoverage_bc(<>, Acc) ->\n B = << <> || C <- [H] >>,\n coverage_bc(T, [B|Acc]);\ncoverage_bc(<<>>, Acc) -> Acc.\n\ncoverage_setelement(<>, Tuple) when element(1, Tuple) =:= x ->\n setelement(H, Tuple, T1).\n\ncoverage_apply(<>, [F|Fs]) ->\n [?MODULE:F(H)|coverage_apply(T, Fs)];\ncoverage_apply(<<>>, []) -> [].\n\ncoverage_external(<>) ->\n ?MODULE:coverage_external_ignore(T, T),\n H.\n\ncoverage_external_ignore(_, _) ->\n ok.\n\ncoverage_id(I) -> id(I).\n\ndo_coverage_bin_to_term_list(L) ->\n Bin = << <<(begin BinTerm = term_to_binary(Term),\n\t\t <<(byte_size(BinTerm)):32,BinTerm/binary>> end)/binary>> ||\n\t Term <- L >>,\n L = do_coverage_bin_to_term_list_1(Bin),\n L = do_coverage_bin_to_term_list_1(<>),\n L = do_coverage_bin_to_term_list_1(<<7:32,\"garbage\",Bin/binary>>). \n\ndo_coverage_bin_to_term_list_1(Bin) ->\n Res = coverage_bin_to_term_list(Bin),\n Res = coverage_bin_to_term_list(Bin, []),\n Res = coverage_bin_to_term_list_catch(Bin),\n Res = coverage_bin_to_term_list_catch(Bin, []).\n\ncoverage_bin_to_term_list(<>) ->\n try binary_to_term(BinTerm) of\n\tTerm -> [Term|coverage_bin_to_term_list(T)]\n catch\n\terror:badarg -> coverage_bin_to_term_list(T)\n end;\ncoverage_bin_to_term_list(<<>>) -> [].\n\ncoverage_bin_to_term_list(<>, Acc) ->\n try binary_to_term(BinTerm) of\n\tTerm -> coverage_bin_to_term_list(T, [Term|Acc])\n catch\n\terror:badarg -> coverage_bin_to_term_list(T, Acc)\n end;\ncoverage_bin_to_term_list(<<>>, Acc) -> lists:reverse(Acc).\n\ncoverage_bin_to_term_list_catch(<>) ->\n case catch binary_to_term(BinTerm) of\n\t{'EXIT',_} -> coverage_bin_to_term_list_catch(T);\n\tTerm -> [Term|coverage_bin_to_term_list_catch(T)]\n end;\ncoverage_bin_to_term_list_catch(<<>>) -> [].\n\ncoverage_bin_to_term_list_catch(<>, Acc) ->\n case catch binary_to_term(BinTerm) of\n\t{'EXIT',_} -> coverage_bin_to_term_list_catch(T, Acc);\n\tTerm -> coverage_bin_to_term_list_catch(T, [Term|Acc])\n end;\ncoverage_bin_to_term_list_catch(<<>>, Acc) -> lists:reverse(Acc).\n\ncoverage_per_key(<> = B) ->\n true = (byte_size(B) =:= BinSize),\n Bin.\n\ncoverage_bitstring(Bin) when is_binary(Bin) -> binary;\ncoverage_bitstring(<<_/bitstring>>) -> bitstring;\ncoverage_bitstring(_) -> other.\n\nmultiple_uses(Config) when is_list(Config) ->\n {344,62879,345,<<245,159,1,89>>} = multiple_uses_1(<<1,88,245,159,1,89>>),\n true = multiple_uses_2(<<0,0,197,18>>),\n <<42,43>> = multiple_uses_3(<<0,0,42,43>>, fun id/1),\n\n ok = first_after(<<>>, 42),\n <<1>> = first_after(<<1,2,3>>, 0),\n <<2>> = first_after(<<1,2,3>>, 1),\n\n ok.\n\nmultiple_uses_1(<>) ->\n %% NOT OPTIMIZED: sub binary is matched or used in more than one place\n {Y,Z} = multiple_uses_match(Tail),\n {X,Y,Z,Tail}.\n\nmultiple_uses_2(<<_:16,Tail/binary>>) ->\n %% NOT OPTIMIZED: sub binary is matched or used in more than one place\n multiple_uses_cmp(Tail, Tail).\n\nmultiple_uses_3(<<_:16,Tail/binary>>, Fun) ->\n %% NOT OPTIMIZED: sub binary is used or returned\n Fun(Tail).\n\nmultiple_uses_match(<>) ->\n {Y,Z}.\n\nmultiple_uses_cmp(<>, <>) -> true;\nmultiple_uses_cmp(<<_:16>>, <<_:16>>) -> false.\n\nfirst_after(Data, Offset) ->\n case byte_size(Data) > Offset of\n\tfalse ->\n\t {_First, _Rest} = {ok, ok},\n\t ok;\n\ttrue ->\n\t <<_:Offset/binary, Rest/binary>> = Data,\n\t %% 'Rest' saved in y(0) before the call.\n {First, _} = match_first(Data, Rest),\n %% When beam_bsm sees the code, the following line\n %% which uses y(0) has been optimized away.\n\t {First, Rest} = {First, Rest},\n\t First\n end.\n\nmatch_first(_, <>) ->\n {First, Rest}.\n\nzero_label(Config) when is_list(Config) ->\n <<\"nosemouth\">> = read_pols(<<\"FACE\",\"nose\",\"mouth\">>),\n <<\"CE\">> = read_pols(<<\"noFACE\">>),\n ok.\n\nread_pols(Data) ->\n <> = Data,\n %% Intentional warning.\n (PolygonType == <<\"FACE\">>) or (PolygonType == <<\"PTCH\">>),\n Rest.\n\nfollowed_by_catch(Config) when is_list(Config) ->\n ok = handle(<<0,1,2,3,4,5>>).\n\n-record(rec,{field}).\nhandle(<<>>) -> ok;\nhandle(Msg) ->\n <<_DataLen:16, Rest/binary>> = Msg,\n case catch fooX:func() of\n\t[X] ->\n\t X#rec.field;\n\t_ ->\n\t ok\n end,\n handle(Rest).\n\nmatching_meets_construction(Config) when is_list(Config) ->\n Bin = id(<<\"abc\">>),\n Len = id(2),\n Tail0 = id(<<1,2,3,4,5>>),\n <<_:Len/binary,Tail/binary>> = Tail0,\n Res = <>,\n <<3,4,5,\"abc\">> = Res,\n {'EXIT',{badarg,_}} = (catch matching_meets_construction_1(<<\"Abc\">>)),\n {'EXIT',{badarg,_}} = (catch matching_meets_construction_2(<<\"Abc\">>)),\n <<\"Bbc\">> = matching_meets_construction_3(<<\"Abc\">>),\n\n <<1,2>> = encode_octet_string(<<1,2,3>>, 2),\n ok.\n\nmatching_meets_construction_1(<<\"A\",H/binary>>) -> <<\"B\",H>>.\n\nmatching_meets_construction_2(<<\"A\",H/binary>>) -> <<\"B\",H/float>>.\n\nmatching_meets_construction_3(<<\"A\",H/binary>>) -> <<\"B\",H/binary>>.\n\nencode_octet_string(<>, Len) ->\n <>.\n\nsimon(Config) when is_list(Config) ->\n one = simon(blurf, <<>>),\n two = simon(0, <<42>>),\n fc(simon, [17,<<1>>], catch simon(17, <<1>>)),\n fc(simon, [0,<<1,2,3>>], catch simon(0, <<1,2,3>>)),\n\n one = simon2(blurf, <<9>>),\n two = simon2(0, <<9,1>>),\n fc(simon2, [0,<<9,10,11>>], catch simon2(0, <<9,10,11>>)),\n ok.\n\nsimon(_, <<>>) -> one;\nsimon(0, <<_>>) -> two.\n\nsimon2(_, <<9>>) -> one;\nsimon2(0, <<_:16>>) -> two.\n\n\n%% OTP-7113: Crash in v3_codegen.\nmatching_and_andalso(Config) when is_list(Config) ->\n ok = matching_and_andalso_1(<<1,2,3>>, 3),\n {'EXIT',{function_clause,_}} = (catch matching_and_andalso_1(<<1,2,3>>, -8)),\n {'EXIT',{function_clause,_}} = (catch matching_and_andalso_1(<<1,2,3>>, blurf)),\n {'EXIT',{function_clause,_}} = (catch matching_and_andalso_1(<<1,2,3>>, 19)),\n\n {\"abc\",<<\"xyz\">>} = matching_and_andalso_23(\"abc\", <<\"-xyz\">>),\n {\"abc\",<<\"\">>} = matching_and_andalso_23(\"abc\", <<($a-1)>>),\n {\"abc\",<<\"\">>} = matching_and_andalso_23(\"abc\", <<($z+1)>>),\n {\"abc\",<<\"\">>} = matching_and_andalso_23(\"abc\", <<($A-1)>>),\n {\"abc\",<<\"\">>} = matching_and_andalso_23(\"abc\", <<($Z+1)>>),\n error = matching_and_andalso_23([], <<>>),\n error = matching_and_andalso_23([], <<$A>>),\n error = matching_and_andalso_23([], <<$Z>>),\n error = matching_and_andalso_23([], <<$a>>),\n error = matching_and_andalso_23([], <<$z>>),\n ok.\n\nmatching_and_andalso_1(<>, K)\n when is_integer(K) andalso size(Bitmap) >= K andalso 0 < K ->\n ok.\n\nmatching_and_andalso_23(Datetime, Bin) ->\n Res = matching_and_andalso_2(Datetime, Bin),\n Res = matching_and_andalso_3(Datetime, Bin),\n Res.\n\nmatching_and_andalso_2(Datetime, <>)\n when not ((H >= $a) andalso (H =< $z)) andalso\n not ((H >= $A) andalso (H =< $Z)) ->\n {Datetime,T};\nmatching_and_andalso_2(_, _) -> error.\n\n%% Contrived example to ensure we cover the handling of 'call' instructions\n%% in v3_codegen:bsm_rename_ctx/4.\nmatching_and_andalso_3(Datetime, <>)\n when not ((abs(H) >= $a) andalso (abs(H) =< $z)) andalso\n not ((abs(H) >= $A) andalso (abs(H) =< $Z)) ->\n {Datetime,T};\nmatching_and_andalso_3(_, _) -> error.\n\n%% Thanks to Tomas Stejskal.\notp_7188(Config) when is_list(Config) ->\n MP3 = <<84,65,71,68,117,154,105,232,107,121,0,0,0,0,0,0,0,0,0,0,\n\t 0,0,0,0,0,0,0,0,0,0,0,0,0,68,97,110,105,101,108,32,76,\n\t 97,110,100,97,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,66,\n\t 101,115,116,32,79,102,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n\t 0,0,0,0,0,0,50,48,48,48,50,48,48,48,32,45,32,66,101,115,\n\t 116,32,79,102,32,32,32,32,32,32,32,32,32,32,32,32,32,32,\n\t 32,32,12>>,\n {ok,{\"ID3v1\",\n\t [{title,<<68,117,154,105,232,107,121>>},\n\t\t{artist,<<\"Daniel Landa\">>},\n\t\t{album,<<\"Best Of\">>}]}} = parse_v1_or_v11_tag(MP3).\n\nparse_v1_or_v11_tag(<<\"TAG\", Title:30/binary,\n\t\t Artist:30/binary, Album:30/binary,\n\t\t _Year:4/binary, _Comment:28/binary,\n\t\t 0:8, Track:8, _Genre:8>>) ->\n {ok,\n {\"ID3v1.1\",\n [{track, Track}, {title, trim(Title)},\n {artist, trim(Artist)}, {album, trim(Album)}]}};\nparse_v1_or_v11_tag(<<\"TAG\", Title:30/binary,\n\t\t Artist:30/binary, Album:30/binary,\n\t\t _Year:4/binary, _Comment:30/binary,\n\t\t _Genre:8>>) ->\n {ok,\n {\"ID3v1\",\n [{title, trim(Title)},\n {artist, trim(Artist)},\n {album, trim(Album)}]}};\nparse_v1_or_v11_tag(_) ->\n error.\n\ntrim(Bin) ->\n list_to_binary(trim_blanks(binary_to_list(Bin))).\n\ntrim_blanks(L) ->\n lists:reverse(skip_blanks_and_zero(lists:reverse(L))).\n\nskip_blanks_and_zero([$\\s|T]) ->\n skip_blanks_and_zero(T);\nskip_blanks_and_zero([0|T]) ->\n skip_blanks_and_zero(T);\nskip_blanks_and_zero(L) ->\n L.\n\n%% OTP-7233. Record and binary matching optimizations clashed.\n%% Thanks to Vladimir Klebansky.\n\n-record(rec_otp_7233, {key, val}).\n\notp_7233(Config) when is_list(Config) ->\n otp_7233_1(#rec_otp_7233{key = <<\"XXabcde\">>,val=[{\"xxxxxxxx\",42}]}),\n [<<\"XXabcde\">>,{\"xxxxxxxx\",42}] = get(io_format),\n erase(io_format),\n otp_7233_1(#rec_otp_7233{key = <<\"XXabcde\">>,val=[]}),\n undefined = get(io_format),\n ok.\n\notp_7233_1(Rec) ->\n <> = Rec#rec_otp_7233.key,\n case K of\n\t<<\"XX\">> ->\n\t Value = Rec#rec_otp_7233.val,\n\t case lists:keyfind(\"xxxxxxxx\", 1, Value) of\n\t\tfalse ->\n\t\t ok;\n\t\tT ->\n\t\t put(io_format, [Rec#rec_otp_7233.key,T])\n\t end;\n\t_ -> ok\n end.\n\n\notp_7240(Config) when is_list(Config) ->\n a = otp_7240_a(0, <<>>),\n b = otp_7240_a(1, 2),\n\n a = otp_7240_b(anything, <<>>),\n b = otp_7240_b(1, {x,y}),\n\n a = otp_7240_c(anything, <<>>),\n b = otp_7240_c(1, <<2>>),\n\n a = otp_7240_d(anything, <<>>),\n b = otp_7240_d(again, <<2>>),\n\n a = otp_7240_e(anything, <<>>),\n b = otp_7240_e(1, 41),\n\n a = otp_7240_f(anything, <<>>),\n b = otp_7240_f(1, {}),\n \n ok.\n\notp_7240_a(_, <<>>) -> a;\notp_7240_a(1, 2) -> b.\n\notp_7240_b(_, <<>>) -> a;\notp_7240_b(1, {_,_}) -> b.\n\notp_7240_c(_, <<>>) -> a;\notp_7240_c(1, <<2>>) -> b.\n\notp_7240_d(_, <<>>) -> a;\notp_7240_d(_, <<2>>) -> b.\n\notp_7240_e(_, <<>>) -> a;\notp_7240_e(1, B) when B < 42 -> b.\n\notp_7240_f(_, <<>>) -> a;\notp_7240_f(1, B) when is_tuple(B) -> b.\n\notp_7498(Config) when is_list(Config) ->\n <<1,2,3>> = otp_7498_foo(<<1,2,3>>, 0),\n <<2,3>> = otp_7498_foo(<<1,2,3>>, 1),\n <<1,2,3>> = otp_7498_foo(<<1,2,3>>, 2),\n\n <<1,2,3>> = otp_7498_bar(<<1,2,3>>, 0),\n <<2,3>> = otp_7498_bar(<<1,2,3>>, 1),\n <<1,2,3>> = otp_7498_bar(<<1,2,3>>, 2),\n <<>> = otp_7498_bar(<<>>, 2),\n <<1,2,3>> = otp_7498_bar(<<1,2,3>>, 3),\n\n ok.\n\notp_7498_foo(Bin, 0) ->\n otp_7498_foo(Bin, 42);\notp_7498_foo(<<_A, Rest/bitstring>>, 1) ->\n otp_7498_foo(Rest, 43);\notp_7498_foo(Bin, _I) ->\n Bin.\n\notp_7498_bar(Bin, 0) ->\n otp_7498_bar(Bin, 42);\notp_7498_bar(<<_A, Rest/bitstring>>, 1) ->\n otp_7498_bar(Rest, 43);\notp_7498_bar(<<>>, 2) ->\n otp_7498_bar(<<>>, 44);\notp_7498_bar(Bin, _I) ->\n Bin.\n\n\nmatch_string(Config) when is_list(Config) ->\n %% To make sure that native endian really is handled correctly\n %% (i.e. that the compiler does not attempt to use bs_match_string/4\n %% instructions for native segments), running this test is not enough.\n %% Either examine the generated for do_match_string_native/1 or\n %% check the coverage for the v3_kernel module.\n case erlang:system_info(endian) of\n\tlittle ->\n\t do_match_string_native(<<$a,0,$b,0>>);\n\tbig ->\n\t do_match_string_native(<<0,$a,0,$b>>)\n end,\n\n do_match_string_big(<<0,$a,0,$b>>),\n do_match_string_little(<<$a,0,$b,0>>),\n\n do_match_string_big_signed(<<255,255>>),\n do_match_string_little_signed(<<255,255>>),\n\n plain = no_match_string_opt(<<\"abc\">>),\n strange = no_match_string_opt(<<$a:9,$b:9,$c:9>>),\n\n ok.\n\ndo_match_string_native(<<$a:16/native,$b:16/native>>) -> ok.\n\ndo_match_string_big(<<$a:16/big,$b:16/big>>) -> ok.\n\ndo_match_string_little(<<$a:16/little,$b:16/little>>) -> ok.\n\ndo_match_string_big_signed(<<(-1):16/signed>>) -> ok.\n\ndo_match_string_little_signed(<<(-1):16/little-signed>>) -> ok.\n\nno_match_string_opt(<<\"abc\">>) -> plain;\nno_match_string_opt(<<$a:9,$b:9,$c:9>>) -> strange.\n \n\n%% OTP-7591: A zero-width segment in matching would crash the compiler.\n\nzero_width(Config) when is_list(Config) ->\n <> = <<2, 0, $h, $i, 0:0>>,\n 2 = Len,\n Str = <<\"hi\">>,\n\n %% Match sure that values that cannot fit in a segment will not match.\n case id(<<0:8>>) of\n\t<<256:8>> -> ct:fail(should_not_match);\n\t_ -> ok\n end,\n ok.\n\n\n%% OTP_7650: A invalid size for binary segments could crash the compiler.\nbad_size(Config) when is_list(Config) ->\n Tuple = {a,b,c},\n {'EXIT',{{badmatch,<<>>},_}} = (catch <<32:Tuple>> = id(<<>>)),\n Binary = <<1,2,3>>,\n {'EXIT',{{badmatch,<<>>},_}} = (catch <<32:Binary>> = id(<<>>)),\n ok.\n\nhaystack(Config) when is_list(Config) ->\n <<0:10/unit:8>> = haystack_1(<<0:10/unit:8>>),\n [<<0:10/unit:8>>,\n\t <<0:20/unit:8>>] = haystack_2(<<1:8192>>),\n ok.\n\n%% Used to crash the compiler.\nhaystack_1(Haystack) ->\n Subs = [10],\n [begin\n\t <> = Haystack,\n\t B\n end || Y <- Subs],\n Haystack.\n\n%% There would be an incorrect badmatch exception.\nhaystack_2(Haystack) ->\n Subs = [{687,10},{369,20}],\n [begin\n\t <<_:X/binary,B:Y/binary,_/binary>> = Haystack,\n\t B\n end || {X,Y} <- Subs ].\n\nfc({'EXIT',{function_clause,_}}) -> ok;\nfc({'EXIT',{{case_clause,_},_}}) when ?MODULE =:= bs_match_inline_SUITE -> ok.\n\nfc(Name, Args, {'EXIT',{function_clause,[{?MODULE,Name,Args,_}|_]}}) -> ok;\nfc(Name, Args, {'EXIT',{function_clause,[{?MODULE,Name,Arity,_}|_]}})\n when length(Args) =:= Arity ->\n true = test_server:is_native(?MODULE);\nfc(_, Args, {'EXIT',{{case_clause,ActualArgs},_}})\n when ?MODULE =:= bs_match_inline_SUITE ->\n Args = tuple_to_list(ActualArgs).\n\n%% Cover the clause handling bs_context to binary in\n%% beam_block:initialized_regs/2.\ncover_beam_bool(Config) when is_list(Config) ->\n ok = do_cover_beam_bool(<<>>, 3),\n <<19>> = do_cover_beam_bool(<<19>>, 2),\n <<42>> = do_cover_beam_bool(<<42>>, 1),\n <<17>> = do_cover_beam_bool(<<13,17>>, 0),\n ok.\n\ndo_cover_beam_bool(Bin, X) when X > 0 ->\n if\n\tX =:= 1; X =:= 2 ->\n\t Bin;\n\ttrue ->\n\t ok\n end;\ndo_cover_beam_bool(<<_,Bin/binary>>, X) ->\n do_cover_beam_bool(Bin, X+1).\n\nmatched_out_size(Config) when is_list(Config) ->\n {253,16#DEADBEEF} = mos_int(<<8,253,16#DEADBEEF:32>>),\n {6,16#BEEFDEAD} = mos_int(<<3,6:3,16#BEEFDEAD:32>>),\n {53,16#CAFEDEADBEEFCAFE} = mos_int(<<16,53:16,16#CAFEDEADBEEFCAFE:64>>),\n {23,16#CAFEDEADBEEFCAFE} = mos_int(<<5,23:5,16#CAFEDEADBEEFCAFE:64>>),\n\n {<<1,2,3>>,4} = mos_bin(<<3,1,2,3,4,3>>),\n {<<1,2,3,7>>,19,42} = mos_bin(<<4,1,2,3,7,19,4,42>>),\n <<1,2,3,7>> = mos_bin(<<4,1,2,3,7,\"abcdefghij\">>),\n\n ok.\n\nmos_int(<>) ->\n {I,X};\nmos_int(<>) ->\n {I,X}.\n\nmos_bin(<>) ->\n L = byte_size(Bin),\n {Bin,X};\nmos_bin(<>) ->\n L = byte_size(Bin),\n {Bin,X,Y};\nmos_bin(<>) ->\n L = byte_size(Bin),\n Bin.\n\nfollow_fail_branch(_) ->\n 42 = ffb_1(<<0,1>>, <<0>>),\n 8 = ffb_1(<<0,1>>, [a]),\n 42 = ffb_2(<<0,1>>, <<0>>, 17),\n 8 = ffb_2(<<0,1>>, [a], 0),\n ok.\n\nffb_1(<<_,T/bitstring>>, List) ->\n case List of\n\t<<_>> ->\n\t 42;\n\t[_|_] ->\n\t %% The fail branch of the bs_start_match2 instruction\n\t %% pointing to here would be ignored, making the compiler\n\t %% incorrectly assume that the delayed sub-binary\n\t %% optimization was safe.\n\t bit_size(T)\n end.\n\nffb_2(<<_,T/bitstring>>, List, A) ->\n case List of\n\t<<_>> when A =:= 17 -> 42;\n\t[_|_] -> bit_size(T)\n end.\n\nno_partition(_) ->\n one = no_partition_1(<<\"string\">>, a1),\n {two,<<\"string\">>} = no_partition_1(<<\"string\">>, a2),\n {two,<<>>} = no_partition_1(<<>>, a2),\n {two,a} = no_partition_1(a, a2),\n three = no_partition_1(undefined, a3),\n {four,a,[]} = no_partition_1([a], a4),\n {five,a,b} = no_partition_1({a,b}, a5),\n\n one = no_partition_2(<<\"string\">>, a1),\n two = no_partition_2(<<\"string\">>, a2),\n two = no_partition_2(<<>>, a2),\n two = no_partition_2(a, a2),\n three = no_partition_2(undefined, a3),\n four = no_partition_2(42, a4),\n five = no_partition_2([], a5),\n six = no_partition_2(42.0, a6),\n ok.\n\nno_partition_1(<<\"string\">>, a1) ->\n one;\nno_partition_1(V, a2) ->\n {two,V};\nno_partition_1(undefined, a3) ->\n three;\nno_partition_1([H|T], a4) ->\n {four,H,T};\nno_partition_1({A,B}, a5) ->\n {five,A,B}.\n\nno_partition_2(<<\"string\">>, a1) ->\n one;\nno_partition_2(_, a2) ->\n two;\nno_partition_2(undefined, a3) ->\n three;\nno_partition_2(42, a4) ->\n four;\nno_partition_2([], a5) ->\n five;\nno_partition_2(42.0, a6) ->\n six.\n\ncalling_a_binary(Config) when is_list(Config) ->\n [] = call_binary(<<>>, []),\n {'EXIT',{badarg,_}} = (catch call_binary(<<1>>, [])),\n {'EXIT',{badarg,_}} = (catch call_binary(<<1,2,3>>, [])),\n ok.\n\ncall_binary(<<>>, Acc) ->\n Acc;\ncall_binary(<>, Acc) ->\n T(<>).\n\nbinary_in_map(Config) when is_list(Config) ->\n ok = match_binary_in_map(#{key => <<42:8>>}),\n {'EXIT',{{badmatch,#{key := 1}},_}} =\n\t(catch match_binary_in_map(#{key => 1})),\n {'EXIT',{{badmatch,#{key := <<1023:16>>}},_}} =\n\t(catch match_binary_in_map(#{key => <<1023:16>>})),\n {'EXIT',{{badmatch,#{key := <<1:8>>}},_}} =\n\t(catch match_binary_in_map(#{key => <<1:8>>})),\n {'EXIT',{{badmatch,not_a_map},_}} =\n\t(catch match_binary_in_map(not_a_map)),\n ok.\n\nmatch_binary_in_map(Map) ->\n case 8 of\n\tN ->\n\t #{key := <<42:N>>} = Map,\n\t ok\n end.\n\nmatch_string_opt(Config) when is_list(Config) ->\n {x,<<1,2,3>>,{<<1>>,{v,<<1,2,3>>}}} =\n\tdo_match_string_opt({<<1>>,{v,<<1,2,3>>}}),\n ok.\n\ndo_match_string_opt({<<1>>,{v,V}}=T) ->\n {x,V,T}.\n\nselect_on_integer(Config) when is_list(Config) ->\n 42 = do_select_on_integer(<<42>>),\n <<\"abc\">> = do_select_on_integer(<<128,\"abc\">>),\n\n {'EXIT',_} = (catch do_select_on_integer(<<0:1>>)),\n {'EXIT',_} = (catch do_select_on_integer(<<1:1>>)),\n {'EXIT',_} = (catch do_select_on_integer(<<0:1,0:15>>)),\n ok.\n\n%% The ASN.1 compiler frequently generates code like this.\ndo_select_on_integer(<<0:1,I:7>>) ->\n I;\ndo_select_on_integer(<<1:1,_:7,Bin/binary>>) ->\n Bin.\n\n%% If 'bin_opt_info' was given the warning would lack filename\n%% and line number.\n\nmap_and_binary(_Config) ->\n {<<\"10\">>,<<\"37\">>,<<\"am\">>} = do_map_and_binary(<<\"10:37am\">>),\n Map1 = #{time => \"noon\"},\n {ok,Map1} = do_map_and_binary(Map1),\n Map2 = #{hour => 8, min => 42},\n {8,42,Map2} = do_map_and_binary(Map2),\n ok.\n\ndo_map_and_binary(<>) ->\n {Hour, Min, Rest};\ndo_map_and_binary(#{time := _} = T) ->\n {ok, T};\ndo_map_and_binary(#{hour := Hour, min := Min} = T) ->\n {Hour, Min, T}.\n\n%% Unsafe caching of branch outcomes in beam_bsm would cause the\n%% delayed creation of sub-binaries optimization to be applied even\n%% when it was unsafe.\n\nunsafe_branch_caching(_Config) ->\n <<>> = do_unsafe_branch_caching(<<42,1>>),\n <<>> = do_unsafe_branch_caching(<<42,2>>),\n <<>> = do_unsafe_branch_caching(<<42,3>>),\n <<17,18>> = do_unsafe_branch_caching(<<42,3,17,18>>),\n <<>> = do_unsafe_branch_caching(<<1,3,42,2>>),\n\n ok.\n\ndo_unsafe_branch_caching(<>) ->\n <> = Bin,\n case C1 of\n\tX when X =:= 1 orelse X =:= 2 ->\n\t Bin2 = <<>>;\n\t_ ->\n\t Bin2 = B1\n end,\n case Code of\n\t1 -> do_unsafe_branch_caching(Bin2);\n\t_ -> Bin2\n end.\n\nbad_literals(_Config) ->\n% Mod = list_to_atom(?MODULE_STRING ++ \"_\" ++\n%\t\t\t atom_to_list(?FUNCTION_NAME)),\n% S = [signed_lit_match(V, Sz) || V <- lists:seq(-8, 8),\n%\t\t\t\t Sz <- [0,1,2,3]] ++\n%\t[unsigned_lit_match(V, Sz) || V <- lists:seq(-2, 8),\n%\t\t\t\t Sz <- [0,1,2]] ++\n%\t[unicode_match(V) ||\n%\t V <- [-100,-1,0,1,2|lists:seq(16#10FFFC, 16#110004)]],\n% Code = ?Q([\"-module('@Mod@').\\n\"\n%\t \"-export([f/0]).\\n\"\n%\t \"f() ->\\n\"\n%\t \"_@S,\\n\"\n%\t \"ok.\\n\"]),\n% merl:print(Code),\n% Opts = test_lib:opt_opts(?MODULE),\n% {ok,_} = merl:compile_and_load(Code, Opts),\n% Mod:f(),\n\n {'EXIT',<<42>>} = (catch bad_literals_1()),\n\n Sz = id(8),\n {'EXIT',{{badmatch,_},_}} = (catch <<-1:Sz>> = <<-1>>),\n ok.\n\nbad_literals_1() ->\n BadSz = bad,\n case case <<42>> of\n\t <<42:BadSz>> -> ok;\n\t Val -> exit(Val)\n\t end of\n\tok -> ok;\n\terror -> error\n end.\n\n%signed_lit_match(V, Sz) ->\n% case <> of\n%\t<> ->\n%\t ?Q(\"<<_@V@:_@Sz@/signed>> = <<_@V@:_@Sz@>>\");\n%\t_ ->\n%\t ?Q([\"case <<_@V@:_@Sz@>> of\\n\",\n%\t\t\" <<_@V@:_@Sz@/signed>> ->\\n\",\n%\t\t\" ct:fail(should_not_match);\\n\",\n%\t\t\" _ ->\\n\",\n%\t\t\" ok\\n\",\n%\t\t\"end\\n\"])\n% end.\n\n%unsigned_lit_match(V, Sz) ->\n% case <> of\n%\t<> ->\n%\t ?Q(\"<<_@V@:_@Sz@>> = <<_@V@:_@Sz@>>\");\n%\t_ ->\n%\t ?Q([\"case <<_@V@:_@Sz@>> of\\n\",\n%\t\t\" <<_@V@:_@Sz@/unsigned>> ->\\n\",\n%\t\t\" ct:fail(should_not_match);\\n\",\n%\t\t\" _ ->\\n\",\n%\t\t\" ok\\n\",\n%\t\t\"end\\n\"])\n% end.\n\n%unicode_match(V) ->\n% try <> of\n%\t<> ->\n%\t ?Q([\"<<_@V@/utf8>> = <<_@V@/utf8>>,\\n\",\n%\t\t\"<<_@V@/utf16>> = <<_@V@/utf16>>,\\n\",\n%\t\t\"<<_@V@/utf32>> = <<_@V@/utf32>>\\n\"])\n% catch\n%\terror:badarg ->\n%\t ?Q([\"case <<_@V@:32>> of\\n\",\n%\t\t\" <<_@V@/utf32>> ->\\n\",\n%\t\t\" ct:fail(should_not_match);\\n\",\n%\t\t\" _ ->\\n\",\n%\t\t\" ok\\n\",\n%\t\t\"end\\n\"])\n% end.\n\n%% Test a few legal but rare cases.\n\ngood_literals(_Config) ->\n Sz = id(64),\n\n %% Variable size.\n <<42:Sz>> = id(<<42:Sz>>),\n <<42.0:Sz/float>> = id(<<42:Sz/float>>),\n\n %% unit > 1\n <<16#cafebeef:4/unit:8>> = id(<<16#cafebeef:32>>),\n ok.\n\nconstant_propagation(_Config) ->\n <<5>> = constant_propagation_a(a, <<5>>),\n {'EXIT',{{case_clause,b},_}} = (catch constant_propagation_a(b, <<5>>)),\n 258 = constant_propagation_b(<<1,2>>),\n F = constant_propagation_c(),\n 259 = F(<<1,3>>),\n ok.\n\nconstant_propagation_a(X, Y) ->\n case X of\n\ta -> Y2 = 8\n end,\n <<5:Y2>> = Y.\n\nconstant_propagation_b(B) ->\n Sz = 16,\n <> = B,\n X.\n\nconstant_propagation_c() ->\n Size = 16,\n fun(Bin) ->\n\t <> = Bin,\n\t X\n end.\n\nparse_xml(_Config) ->\n <<\"> = do_parse_xml(<<\">),\n <<\" \">> = do_parse_xml(<<\">),\n ok.\n\ndo_parse_xml(<<\"> = Bytes) ->\n %% Delayed sub-binary creation is not safe. A buggy (development)\n %% version of check_liveness_everywhere() in beam_utils would turn\n %% on the optimization.\n Rest1 = case is_next_char_whitespace(Rest) of\n\t\tfalse ->\n\t\t Bytes;\n\t\ttrue ->\n\t\t id(Rest)\n\t end,\n id(Rest1).\n\nis_next_char_whitespace(<>) ->\n C =:= $\\s.\n\n-record(ext_header,\n {this_hdr = 17,\n ext_hdr_opts}).\n\nget_payload(_Config) ->\n <<3445:48>> = do_get_payload(#ext_header{ext_hdr_opts = <<3445:48>>}),\n {'EXIT',_} = (catch do_get_payload(#ext_header{})),\n ok.\n\ndo_get_payload(ExtHdr) ->\n _ = ExtHdr#ext_header.this_hdr,\n ExtHdrOptions = ExtHdr#ext_header.ext_hdr_opts,\n <<_:13,_:35>> = ExtHdr#ext_header.ext_hdr_opts,\n ExtHdrOptions.\n\nescape(_Config) ->\n 0 = escape(<<>>, 0),\n 1 = escape(<<128>>, 0),\n 2 = escape(<<128,255>>, 0),\n 42 = escape(<<42>>, 0),\n 50 = escape(<<42,8>>, 0),\n ok.\n\nescape(<>, Pos) when Byte >= 127 ->\n escape(Rest, Pos + 1);\nescape(<>, Pos) ->\n escape(Rest, Pos + Byte);\nescape(<<_Rest/bits>>, Pos) ->\n Pos.\n\n%% ERL-490\nnum_slots_different(_Config) ->\n Ts = [{<<\"de\">>, <<\"default\">>, <<\"Remove\">>, <<\"a\">>},\n {<<\"de\">>, <<\"default\">>, <<\"Remove from list\">>, <<\"a\">>},\n {<<\"de\">>, <<\"default\">>, <<\"Remove from the list\">>, <<\"a\">>},\n {<<\"de\">>, <<\"default\">>, <<\"Results\">>, <<\"Ergebnisse\">>},\n {<<\"de\">>, <<\"default\">>, <<\"Reservatio\">>, <<\"a\">>},\n {<<\"de\">>, <<\"navigation\">>, <<\"Results\">>, <<\"Ergebnisse\">>},\n {<<\"de\">>, <<\"navigation\">>, <<\"Resources\">>, <<\"Ressourcen\">>}],\n _ = [{ok,Res} = lgettext(A, B, C) || {A,B,C,Res} <- Ts],\n\n {'EXIT',_} = (catch lgettext(<<\"d\">>, <<\"default\">>, <<\"Remove\">>)),\n {'EXIT',_} = (catch lgettext(\"\", <<\"default\">>, <<\"Remove\">>)),\n {'EXIT',_} = (catch lgettext(<<\"de\">>, <<\"def\">>, <<\"Remove\">>)),\n {'EXIT',_} = (catch lgettext(<<\"de\">>, <<\"default\">>, <<\"Res\">>)),\n ok.\n\n\nlgettext(<<\"de\">>, <<\"default\">>, <<\"Remove\">>) ->\n {ok, <<\"a\">>};\nlgettext(<<\"de\">>, <<\"default\">>, <<\"Remove from list\">>) ->\n {ok, <<\"a\">>};\nlgettext(<<\"de\">>, <<\"default\">>, <<\"Remove from the list\">>) ->\n {ok, <<\"a\">>};\nlgettext(<<\"de\">>, <<\"default\">>, <<\"Results\">>) ->\n {ok, <<\"Ergebnisse\">>};\nlgettext(<<\"de\">>, <<\"default\">>, <<\"Reservatio\">>) ->\n {ok, <<\"a\">>};\nlgettext(<<\"de\">>, <<\"navigation\">>, <<\"Results\">>) ->\n {ok, <<\"Ergebnisse\">>};\nlgettext(<<\"de\">>, <<\"navigation\">>, <<\"Resources\">>) ->\n {ok, <<\"Ressourcen\">>}.\n\n%% Test more code in beam_bsm.\nbeam_bsm(_Config) ->\n true = check_bitstring_list(<<1:1,0:1,1:1,1:1>>, [1,0,1,1]),\n false = check_bitstring_list(<<1:1,0:1,1:1,1:1>>, [0]),\n\n true = bsm_validate_scheme(<<>>),\n true = bsm_validate_scheme(<<5,10>>),\n false = bsm_validate_scheme(<<5,10,11,12>>),\n true = bsm_validate_scheme([]),\n true = bsm_validate_scheme([5,10]),\n false = bsm_validate_scheme([5,6,7]),\n\n <<1,2,3>> = bsm_must_save_and_not_save(<<1,2,3>>, []),\n D = fun(N) -> 2*N end,\n [2,4|<<3>>] = bsm_must_save_and_not_save(<<1,2,3>>, [D,D]),\n\n ok.\n\ncheck_bitstring_list(<>, [H|T2]) ->\n check_bitstring_list(T1, T2);\ncheck_bitstring_list(<<>>, []) ->\n true;\ncheck_bitstring_list(_, _) ->\n false.\n\nbsm_validate_scheme([]) -> true;\nbsm_validate_scheme([H|T]) ->\n case bsm_is_scheme(H) of\n true -> bsm_validate_scheme(T);\n false -> false\n end;\nbsm_validate_scheme(<<>>) -> true;\nbsm_validate_scheme(<>) ->\n case bsm_is_scheme(H) of\n true -> bsm_validate_scheme(Rest);\n false -> false\n end.\n\nbsm_is_scheme(Int) ->\n Int rem 5 =:= 0.\n\n%% NOT OPTIMIZED: different control paths use different positions in the binary\nbsm_must_save_and_not_save(Bin, []) ->\n Bin;\nbsm_must_save_and_not_save(<>, [F|Fs]) ->\n [F(H)|bsm_must_save_and_not_save(T, Fs)];\nbsm_must_save_and_not_save(<<>>, []) ->\n [].\n\nguard(_Config) ->\n _Tuple = id({a,b}),\n ok = guard_1(<<1,2,3>>, {1,2,3}),\n ok = guard_2(<<42>>, #{}),\n ok.\n\n%% Cover handling of #k_put{} in v3_codegen:bsm_rename_ctx/4.\nguard_1(<>, Tuple) when Tuple =:= {A,B,C} ->\n ok.\n\n%% Cover handling of #k_call{} in v3_codegen:bsm_rename_ctx/4.\nguard_2(<<_>>, Healing) when Healing#{[] => Healing} =:= #{[] => #{}} ->\n ok.\n\nis_ascii(_Config) ->\n true = do_is_ascii(<<>>),\n true = do_is_ascii(<<\"string\">>),\n false = do_is_ascii(<<1024/utf8>>),\n {'EXIT',{function_clause,_}} = (catch do_is_ascii(<<$A,0:3>>)),\n {'EXIT',{function_clause,_}} = (catch do_is_ascii(<<16#80,0:3>>)),\n ok.\n\ndo_is_ascii(<<>>) ->\n true;\ndo_is_ascii(<>) when C >= 16#80 ->\n %% This clause must fail to match if the size of the argument in\n %% bits is not divisible by 8. Beware of unsafe optimizations.\n false;\ndo_is_ascii(<<_, T/binary>>) ->\n do_is_ascii(T).\n\nnon_opt_eq(_Config) ->\n true = non_opt_eq([], <<>>),\n true = non_opt_eq([$a], <<$a>>),\n false = non_opt_eq([$a], <<$b>>),\n ok.\n\n%% An example from the Efficiency Guide. It used to be not optimized,\n%% but now it can be optimized.\n\nnon_opt_eq([H|T1], <>) ->\n non_opt_eq(T1, T2);\nnon_opt_eq([_|_], <<_,_/binary>>) ->\n false;\nnon_opt_eq([], <<>>) ->\n true.\n\n%% ERL-689\n\nerl_689(_Config) ->\n {{0, 0, 0}, <<>>} = do_erl_689_1(<<0>>, ?MODULE),\n {{2018, 8, 7}, <<>>} = do_erl_689_1(<<4,2018:16/little,8,7>>, ?MODULE),\n {{0, 0, 0}, <<>>} = do_erl_689_2(?MODULE, <<0>>),\n {{2018, 8, 7}, <<>>} = do_erl_689_2(?MODULE, <<4,2018:16/little,8,7>>),\n ok.\n\ndo_erl_689_1(Arg1, Arg2) ->\n Res = do_erl_689_1a(Arg1, Arg2),\n Res = do_erl_689_1b(Arg1, Arg2).\n\ndo_erl_689_2(Arg1, Arg2) ->\n Res = do_erl_689_2a(Arg1, Arg2),\n Res = do_erl_689_2b(Arg1, Arg2).\n\ndo_erl_689_1a(<>, _) ->\n case {Data, Length} of\n {_, 0} ->\n %% bs_context_to_binary would incorrectly set Data to the original\n %% binary (before matching in the function head).\n {{0, 0, 0}, Data};\n {<>, 4} ->\n {{Y, M, D}, Rest}\n end.\n\ndo_erl_689_1b(<>, _) ->\n case {Data, Length} of\n {_, 0} ->\n %% bs_context_to_binary would incorrectly set Data to the original\n %% binary (before matching in the function head).\n id(0),\n {{0, 0, 0}, Data};\n {<>, 4} ->\n id(1),\n {{Y, M, D}, Rest}\n end.\n\ndo_erl_689_2a(_, <>) ->\n case {Length, Data} of\n {0, _} ->\n %% bs_context_to_binary would incorrectly set Data to the original\n %% binary (before matching in the function head).\n {{0, 0, 0}, Data};\n {4, <>} ->\n {{Y, M, D}, Rest}\n end.\n\ndo_erl_689_2b(_, <>) ->\n case {Length, Data} of\n {0, _} ->\n %% bs_context_to_binary would incorrectly set Data to the original\n %% binary (before matching in the function head).\n id(0),\n {{0, 0, 0}, Data};\n {4, <>} ->\n id(1),\n {{Y, M, D}, Rest}\n end.\n\n%% ERL-753\n\nbs_start_match2_defs(_Config) ->\n {<<\"http://127.0.0.1:1234/vsaas/hello\">>} = api_url(<<\"hello\">>, dummy),\n {\"https://127.0.0.1:4321/vsaas/hello\"} = api_url({https, \"hello\"}, dummy).\n\napi_url(URL, Auth) ->\n Header = [],\n case URL of\n <<_/binary>> -> {<<\"http://127.0.0.1:1234/vsaas/\",URL/binary>>};\n {https, [_|_] = URL1} -> {\"https://127.0.0.1:4321/vsaas/\"++URL1}\n end.\n\ncheck(F, R) ->\n R = F().\n\nid(I) -> I.\n" }, { "path": "otp_build/otp_build_core.patch", "content": "diff --git a/make/otp.mk.in b/make/otp.mk.in\nindex df29d26833..b74fb14a71 100644\n--- a/make/otp.mk.in\n+++ b/make/otp.mk.in\n@@ -126,9 +126,11 @@ endif\n \n $(EBIN)/%.beam: $(EGEN)/%.erl\n \t$(V_ERLC) $(ERL_COMPILE_FLAGS) -o$(EBIN) $<\n+\t$(V_ERLC) $(ERL_COMPILE_FLAGS) +to_core -o$(EBIN) $<\n \n $(EBIN)/%.beam: $(ESRC)/%.erl\n \t$(V_ERLC) $(ERL_COMPILE_FLAGS) -o$(EBIN) $<\n+\t$(V_ERLC) $(ERL_COMPILE_FLAGS) +to_core -o$(EBIN) $<\n \n ifeq ($(NATIVE_LIBS_ENABLED),yes)\n # Special rule for the HIPE bootstrap w/ native libs\n" }, { "path": "otp_build/patch_build_otp.sh", "content": "#!/bin/bash\nset -e\n\npushd ../otp\n\ngit reset --hard\ngit apply ../otp_build/otp_build_core.patch\n\n./otp_build autoconf\n./configure\n\n# TODO: This will fail on the `tools` app. Will fix when needed\nmake preloaded libs\n\n#APPS=\"kernel stdlib compiler common_test\"\n#for app_name in $APPS; do\n# make -C lib/$app_name opt\n#done\n\npopd\n" }, { "path": "otp_build/patch_tests.sh", "content": "#!/bin/bash\nset -e\n\ncp ../otp/lib/compiler/test/bs_match_SUITE.erl .\npatch -l --normal --verbose bs_match_SUITE.erl bs_match_SUITE.erl.patch\n\n" }, { "path": "test_data/Elixir.Enum.erl", "content": "-file(\"/home/build/elixir/lib/elixir/lib/enum.ex\", 196).\n\n-module('Elixir.Enum').\n\n-compile([no_auto_import,\n inline_list_funcs,\n {inline,\n [{reduce_enumerable,3},\n {reduce_by,3},\n {reduce,3},\n {entry_to_string,1},\n {aggregate,3}]}]).\n\n-spec reverse(t(), t()) -> list().\n\n-spec slice(t(), index(), non_neg_integer()) -> list().\n\n-spec 'empty?'(t()) -> boolean().\n\n-spec drop(t(), integer()) -> list().\n\n-spec unzip(t()) -> {[element()], [element()]}.\n\n-spec zip([t()]) -> t();\n (t()) -> t().\n\n-spec split(t(), integer()) -> {list(), list()}.\n\n-spec flat_map(t(), fun((element()) -> t())) -> list().\n\n-spec chunk_every(t(), pos_integer(), pos_integer(), t() | discard) ->\n [list()].\n\n-spec min_max_by(t(),\n fun((element()) -> any()),\n fun(() -> empty_result)) ->\n {element(), element()} | empty_result\n when empty_result :: any().\n\n-spec reduce(t(), fun((element(), any()) -> any())) -> any().\n\n-spec flat_map_reduce(t(), acc, fun) -> {[any()], any()}\n when\n fun ::\n fun((element(), acc) ->\n {t(), acc} | {halt, acc}),\n acc :: any().\n\n-spec at(t(), index(), default()) -> element() | default().\n\n-spec drop_while(t(), fun((element()) -> elixir:as_boolean(term()))) ->\n list().\n\n-spec find_value(t(), any(), fun((element()) -> any())) -> any() | nil.\n\n-spec into('Elixir.Enumerable':t(), 'Elixir.Collectable':t()) ->\n 'Elixir.Collectable':t().\n\n-spec reverse_slice(t(), non_neg_integer(), non_neg_integer()) -> list().\n\n-spec into('Elixir.Enumerable':t(),\n 'Elixir.Collectable':t(),\n fun((term()) -> term())) ->\n 'Elixir.Collectable':t().\n\n-spec take_while(t(), fun((element()) -> elixir:as_boolean(term()))) ->\n list().\n\n-spec min(t(), fun(() -> empty_result)) -> element() | empty_result\n when empty_result :: any().\n\n-spec sum(t()) -> number().\n\n-spec map_reduce(t(), any(), fun((element(), any()) -> {any(), any()})) ->\n {any(), any()}.\n\n-spec dedup(t()) -> list().\n\n-spec scan(t(), any(), fun((element(), any()) -> any())) -> list().\n\n-spec each(t(), fun((element()) -> any())) -> ok.\n\n-spec random(t()) -> element().\n\n-spec 'any?'(t(), fun((element()) -> elixir:as_boolean(term()))) ->\n boolean().\n\n-spec count(t()) -> non_neg_integer().\n\n-spec fetch(t(), index()) -> {ok, element()} | error.\n\n-spec intersperse(t(), element()) -> list().\n\n-spec map_every(t(), non_neg_integer(), fun((element()) -> any())) ->\n list().\n\n-spec sort(t(), fun((element(), element()) -> boolean())) -> list().\n\n-spec chunk_while(t(),\n acc(),\n fun((element(), acc()) ->\n {cont, chunk, acc()} |\n {cont, acc()} |\n {halt, acc()}),\n fun((acc()) -> {cont, chunk, acc()} | {cont, acc()})) ->\n 'Elixir.Enumerable':t()\n when chunk :: any().\n\n-spec map_join(t(),\n 'Elixir.String':t(),\n fun((element()) -> 'Elixir.String.Chars':t())) ->\n 'Elixir.String':t().\n\n-spec take(t(), integer()) -> list().\n\n-spec drop_every(t(), non_neg_integer()) -> list().\n\n-spec uniq(t()) -> list().\n\n-spec 'member?'(t(), element()) -> boolean().\n\n-spec count(t(), fun((element()) -> elixir:as_boolean(term()))) ->\n non_neg_integer().\n\n-spec min_by(t(), fun((element()) -> any()), fun(() -> empty_result)) ->\n element() | empty_result\n when empty_result :: any().\n\n-spec uniq_by(t(), fun((element()) -> term())) -> list().\n\n-spec min_max(t(), fun(() -> empty_result)) ->\n {element(), element()} | empty_result\n when empty_result :: any().\n\n-spec sort_by(t(),\n fun((element()) -> mapped_element),\n fun((mapped_element, mapped_element) -> boolean())) ->\n list()\n when mapped_element :: element().\n\n-spec reduce_while(t(),\n any(),\n fun((element(), any()) ->\n {cont, any()} | {halt, any()})) ->\n any().\n\n-spec map(t(), fun((element()) -> any())) -> list().\n\n-spec 'all?'(t(), fun((element()) -> elixir:as_boolean(term()))) ->\n boolean().\n\n-spec chunk_by(t(), fun((element()) -> any())) -> [list()].\n\n-spec max_by(t(), fun((element()) -> any()), fun(() -> empty_result)) ->\n element() | empty_result\n when empty_result :: any().\n\n-spec split_while(t(), fun((element()) -> elixir:as_boolean(term()))) ->\n {list(), list()}.\n\n-spec take_every(t(), non_neg_integer()) -> list().\n\n-spec sort(t()) -> list().\n\n-spec join(t(), 'Elixir.String':t()) -> 'Elixir.String':t().\n\n-spec split_with(t(), fun((element()) -> any())) -> {list(), list()}.\n\n-spec scan(t(), fun((element(), any()) -> any())) -> list().\n\n-spec reverse(t()) -> list().\n\n-spec take_random(t(), non_neg_integer()) -> list().\n\n-spec group_by(t(),\n fun((element()) -> any()),\n fun((element()) -> any())) ->\n map().\n\n-spec find_index(t(), fun((element()) -> any())) ->\n non_neg_integer() | nil.\n\n-spec concat(t()) -> t().\n\n-spec zip(t(), t()) -> [{any(), any()}].\n\n-spec slice(t(), 'Elixir.Range':t()) -> list().\n\n-spec with_index(t(), integer()) -> [{element(), index()}].\n\n-spec concat(t(), t()) -> t().\n\n-spec max(t(), fun(() -> empty_result)) -> element() | empty_result\n when empty_result :: any().\n\n-spec 'fetch!'(t(), index()) -> element().\n\n-spec filter(t(), fun((element()) -> elixir:as_boolean(term()))) ->\n list().\n\n-spec reject(t(), fun((element()) -> elixir:as_boolean(term()))) ->\n list().\n\n-spec reduce(t(), any(), fun((element(), any()) -> any())) -> any().\n\n-spec find(t(), default(), fun((element()) -> any())) ->\n element() | default().\n\n-spec shuffle(t()) -> list().\n\n-spec to_list(t()) -> [element()].\n\n-spec dedup_by(t(), fun((element()) -> term())) -> list().\n\n-spec chunk_every(t(), pos_integer()) -> [list()].\n\n-export_type([default/0]).\n\n-type default() :: any().\n\n-export_type([index/0]).\n\n-type index() :: integer().\n\n-export_type([element/0]).\n\n-type element() :: any().\n\n-export_type([acc/0]).\n\n-type acc() :: any().\n\n-export_type([t/0]).\n\n-type t() :: 'Elixir.Enumerable':t().\n\n-export(['__info__'/1,\n 'all?'/1,\n 'all?'/2,\n 'any?'/1,\n 'any?'/2,\n at/2,\n at/3,\n chunk/2,\n chunk/3,\n chunk/4,\n chunk_by/2,\n chunk_every/2,\n chunk_every/3,\n chunk_every/4,\n chunk_while/4,\n concat/1,\n concat/2,\n count/1,\n count/2,\n dedup/1,\n dedup_by/2,\n drop/2,\n drop_every/2,\n drop_while/2,\n each/2,\n 'empty?'/1,\n fetch/2,\n 'fetch!'/2,\n filter/2,\n filter_map/3,\n find/2,\n find/3,\n find_index/2,\n find_value/2,\n find_value/3,\n flat_map/2,\n flat_map_reduce/3,\n group_by/2,\n group_by/3,\n intersperse/2,\n into/2,\n into/3,\n join/1,\n join/2,\n map/2,\n map_every/3,\n map_join/2,\n map_join/3,\n map_reduce/3,\n max/1,\n max/2,\n max_by/2,\n max_by/3,\n 'member?'/2,\n min/1,\n min/2,\n min_by/2,\n min_by/3,\n min_max/1,\n min_max/2,\n min_max_by/2,\n min_max_by/3,\n partition/2,\n random/1,\n reduce/2,\n reduce/3,\n reduce_while/3,\n reject/2,\n reverse/1,\n reverse/2,\n reverse_slice/3,\n scan/2,\n scan/3,\n shuffle/1,\n slice/2,\n slice/3,\n sort/1,\n sort/2,\n sort_by/2,\n sort_by/3,\n split/2,\n split_while/2,\n split_with/2,\n sum/1,\n take/2,\n take_every/2,\n take_random/2,\n take_while/2,\n to_list/1,\n uniq/1,\n uniq/2,\n uniq_by/2,\n unzip/1,\n with_index/1,\n with_index/2,\n zip/1,\n zip/2]).\n\n-spec '__info__'(attributes |\n compile |\n functions |\n macros |\n md5 |\n module |\n deprecated) ->\n any().\n\n'__info__'(module) ->\n 'Elixir.Enum';\n'__info__'(functions) ->\n [{'all?',1},\n {'all?',2},\n {'any?',1},\n {'any?',2},\n {at,2},\n {at,3},\n {chunk,2},\n {chunk,3},\n {chunk,4},\n {chunk_by,2},\n {chunk_every,2},\n {chunk_every,3},\n {chunk_every,4},\n {chunk_while,4},\n {concat,1},\n {concat,2},\n {count,1},\n {count,2},\n {dedup,1},\n {dedup_by,2},\n {drop,2},\n {drop_every,2},\n {drop_while,2},\n {each,2},\n {'empty?',1},\n {fetch,2},\n {'fetch!',2},\n {filter,2},\n {filter_map,3},\n {find,2},\n {find,3},\n {find_index,2},\n {find_value,2},\n {find_value,3},\n {flat_map,2},\n {flat_map_reduce,3},\n {group_by,2},\n {group_by,3},\n {intersperse,2},\n {into,2},\n {into,3},\n {join,1},\n {join,2},\n {map,2},\n {map_every,3},\n {map_join,2},\n {map_join,3},\n {map_reduce,3},\n {max,1},\n {max,2},\n {max_by,2},\n {max_by,3},\n {'member?',2},\n {min,1},\n {min,2},\n {min_by,2},\n {min_by,3},\n {min_max,1},\n {min_max,2},\n {min_max_by,2},\n {min_max_by,3},\n {partition,2},\n {random,1},\n {reduce,2},\n {reduce,3},\n {reduce_while,3},\n {reject,2},\n {reverse,1},\n {reverse,2},\n {reverse_slice,3},\n {scan,2},\n {scan,3},\n {shuffle,1},\n {slice,2},\n {slice,3},\n {sort,1},\n {sort,2},\n {sort_by,2},\n {sort_by,3},\n {split,2},\n {split_while,2},\n {split_with,2},\n {sum,1},\n {take,2},\n {take_every,2},\n {take_random,2},\n {take_while,2},\n {to_list,1},\n {uniq,1},\n {uniq,2},\n {uniq_by,2},\n {unzip,1},\n {with_index,1},\n {with_index,2},\n {zip,1},\n {zip,2}];\n'__info__'(macros) ->\n [];\n'__info__'(Key = attributes) ->\n erlang:get_module_info('Elixir.Enum', Key);\n'__info__'(Key = compile) ->\n erlang:get_module_info('Elixir.Enum', Key);\n'__info__'(Key = md5) ->\n erlang:get_module_info('Elixir.Enum', Key);\n'__info__'(deprecated) ->\n [{{chunk,2},<<\"Use Enum.chunk_every/2 instead\">>},\n {{chunk,3},<<\"Use Enum.chunk_every/3 instead\">>},\n {{chunk,4},<<\"Use Enum.chunk_every/4 instead\">>},\n {{filter_map,3},\n <<\"Use Enum.filter/2 + Enum.map/2 or for comprehensions instead\">>},\n {{partition,2},<<\"Use Enum.split_with/2 instead\">>},\n {{uniq,2},<<\"Use Enum.uniq_by/2 instead\">>}].\n\naggregate([_head@1|_tail@1], _fun@1, __empty@1) ->\n lists:foldl(_fun@1, _head@1, _tail@1);\naggregate([], __fun@1, _empty@1) ->\n _empty@1();\naggregate(#{'__struct__' := 'Elixir.Range',\n first := _first@1,\n last := _last@1},\n _fun@1,\n __empty@1) ->\n _fun@1(_first@1, _last@1);\naggregate(_enumerable@1, _fun@1, _empty@1) ->\n _ref@1 = make_ref(),\n case\n reduce(_enumerable@1,\n _ref@1,\n fun(_element@1, _ref@2) when _ref@1 =:= _ref@2 ->\n _element@1;\n (_element@2, _acc@1) ->\n _fun@1(_element@2, _acc@1)\n end)\n of\n _ref@1 ->\n _empty@1();\n _result@1 ->\n _result@1\n end.\n\n'all?'(__@1) ->\n 'all?'(__@1,\n fun(_x@1) ->\n _x@1\n end).\n\n'all?'(_enumerable@1, _fun@1) when is_list(_enumerable@1) ->\n all_list(_enumerable@1, _fun@1);\n'all?'(_enumerable@1, _fun@1) ->\n element(2,\n 'Elixir.Enumerable':reduce(_enumerable@1,\n {cont,true},\n fun(_entry@1, _) ->\n case _fun@1(_entry@1) of\n __@1\n when\n __@1 =:= nil\n orelse\n __@1 =:= false ->\n {halt,false};\n _ ->\n {cont,true}\n end\n end)).\n\nall_list([_h@1|_t@1], _fun@1) ->\n case _fun@1(_h@1) of\n __@1\n when\n __@1 =:= nil\n orelse\n __@1 =:= false ->\n false;\n _ ->\n all_list(_t@1, _fun@1)\n end;\nall_list([], _) ->\n true.\n\n'any?'(__@1) ->\n 'any?'(__@1,\n fun(_x@1) ->\n _x@1\n end).\n\n'any?'(_enumerable@1, _fun@1) when is_list(_enumerable@1) ->\n any_list(_enumerable@1, _fun@1);\n'any?'(_enumerable@1, _fun@1) ->\n element(2,\n 'Elixir.Enumerable':reduce(_enumerable@1,\n {cont,false},\n fun(_entry@1, _) ->\n case _fun@1(_entry@1) of\n __@1\n when\n __@1 =:= nil\n orelse\n __@1 =:= false ->\n {cont,false};\n _ ->\n {halt,true}\n end\n end)).\n\nany_list([_h@1|_t@1], _fun@1) ->\n case _fun@1(_h@1) of\n __@1\n when\n __@1 =:= nil\n orelse\n __@1 =:= false ->\n any_list(_t@1, _fun@1);\n _ ->\n true\n end;\nany_list([], _) ->\n false.\n\nat(__@1, __@2) ->\n at(__@1, __@2, nil).\n\nat(_enumerable@1, _index@1, _default@1) ->\n case slice_any(_enumerable@1, _index@1, 1) of\n [_value@1] ->\n _value@1;\n [] ->\n _default@1\n end.\n\nbackwards_compatible_slice(_args@1) ->\n try\n 'Elixir.Enumerable':slice(_args@1)\n catch\n error:undef:___STACKTRACE__@1 ->\n case ___STACKTRACE__@1 of\n [{_module@1,slice,[_args@1],_}|_] ->\n {error,_module@1};\n _stack@1 ->\n erlang:raise(error, undef, _stack@1)\n end\n end.\n\nchunk(_enumerable@1, _count@1) ->\n chunk(_enumerable@1, _count@1, _count@1, nil).\n\nchunk(_enum@1, _n@1, _step@1) ->\n chunk_every(_enum@1, _n@1, _step@1, nil).\n\nchunk(_enumerable@1, _count@1, _step@1, _leftover@1) ->\n chunk_every(_enumerable@1,\n _count@1,\n _step@1,\n case _leftover@1 of\n __@1\n when\n __@1 =:= nil\n orelse\n __@1 =:= false ->\n discard;\n __@2 ->\n __@2\n end).\n\nchunk_by(_enumerable@1, _fun@1) ->\n 'Elixir.Stream.Reducers':chunk_by(fun chunk_while/4,\n _enumerable@1,\n _fun@1).\n\nchunk_every(_enumerable@1, _count@1) ->\n chunk_every(_enumerable@1, _count@1, _count@1, []).\n\nchunk_every(__@1, __@2, __@3) ->\n chunk_every(__@1, __@2, __@3, []).\n\nchunk_every(_enumerable@1, _count@1, _step@1, _leftover@1)\n when\n ((is_integer(_count@1)\n andalso\n _count@1 > 0)\n andalso\n is_integer(_step@1))\n andalso\n _step@1 > 0 ->\n 'Elixir.Stream.Reducers':chunk_every(fun chunk_while/4,\n _enumerable@1,\n _count@1,\n _step@1,\n _leftover@1).\n\nchunk_while(_enumerable@1, _acc@1, _chunk_fun@1, _after_fun@1) ->\n {_,{_res@1,_acc@6}} =\n 'Elixir.Enumerable':reduce(_enumerable@1,\n {cont,{[],_acc@1}},\n fun(_entry@1, {_buffer@1,_acc@2}) ->\n case\n _chunk_fun@1(_entry@1,\n _acc@2)\n of\n {cont,_emit@1,_acc@3} ->\n {cont,\n {[_emit@1|_buffer@1],\n _acc@3}};\n {cont,_acc@4} ->\n {cont,\n {_buffer@1,_acc@4}};\n {halt,_acc@5} ->\n {halt,\n {_buffer@1,_acc@5}}\n end\n end),\n case _after_fun@1(_acc@6) of\n {cont,__acc@1} ->\n lists:reverse(_res@1);\n {cont,_elem@1,__acc@2} ->\n lists:reverse([_elem@1|_res@1])\n end.\n\nconcat(_enumerables@1) ->\n _fun@1 =\n fun(__@1, __@2) ->\n [__@1|__@2]\n end,\n lists:reverse(reduce(_enumerables@1,\n [],\n fun(__@3, __@4) ->\n reduce(__@3, __@4, _fun@1)\n end)).\n\nconcat(_left@1, _right@1)\n when\n is_list(_left@1)\n andalso\n is_list(_right@1) ->\n _left@1 ++ _right@1;\nconcat(_left@1, _right@1) ->\n concat([_left@1,_right@1]).\n\ncount(_enumerable@1) when is_list(_enumerable@1) ->\n length(_enumerable@1);\ncount(_enumerable@1) ->\n case 'Elixir.Enumerable':count(_enumerable@1) of\n {ok,_value@1} when is_integer(_value@1) ->\n _value@1;\n {error,_module@1} ->\n element(2,\n _module@1:reduce(_enumerable@1,\n {cont,0},\n fun(_, _acc@1) ->\n {cont,_acc@1 + 1}\n end))\n end.\n\ncount(_enumerable@1, _fun@1) ->\n reduce(_enumerable@1,\n 0,\n fun(_entry@1, _acc@1) ->\n case _fun@1(_entry@1) of\n __@1\n when\n __@1 =:= nil\n orelse\n __@1 =:= false ->\n _acc@1;\n _ ->\n _acc@1 + 1\n end\n end).\n\ndedup(_enumerable@1) ->\n dedup_by(_enumerable@1,\n fun(_x@1) ->\n _x@1\n end).\n\ndedup_by(_enumerable@1, _fun@1) ->\n {_list@1,_} =\n reduce(_enumerable@1,\n {[],[]},\n fun(__@1, {__@3,__@4} = __@2) ->\n __@5 = _fun@1(__@1),\n case __@4 of\n {value,__@5} ->\n __@2;\n _ ->\n {[__@1|__@3],{value,__@5}}\n end\n end),\n lists:reverse(_list@1).\n\ndrop(_enumerable@1, _amount@1)\n when\n (is_list(_enumerable@1)\n andalso\n is_integer(_amount@1))\n andalso\n _amount@1 >= 0 ->\n drop_list(_enumerable@1, _amount@1);\ndrop(_enumerable@1, _amount@1)\n when\n is_integer(_amount@1)\n andalso\n _amount@1 >= 0 ->\n {_result@1,_} =\n reduce(_enumerable@1,\n {[],_amount@1},\n fun(__@1, {__@2,__@3}) when __@3 > 0 ->\n {__@2,__@3 - 1};\n (__@4, {__@5,__@6}) ->\n {[__@4|__@5],__@6}\n end),\n case is_list(_result@1) of\n false ->\n [];\n true ->\n lists:reverse(_result@1)\n end;\ndrop(_enumerable@1, _amount@1)\n when\n is_integer(_amount@1)\n andalso\n _amount@1 < 0 ->\n {_count@1,_fun@1} = slice_count_and_fun(_enumerable@1),\n _amount@2 = min(_amount@1 + _count@1, _count@1),\n case _amount@2 > 0 of\n false ->\n [];\n true ->\n _fun@1(0, _amount@2)\n end.\n\ndrop_every(__enumerable@1, 1) ->\n [];\ndrop_every(_enumerable@1, 0) ->\n to_list(_enumerable@1);\ndrop_every([], _nth@1) when is_integer(_nth@1) ->\n [];\ndrop_every(_enumerable@1, _nth@1)\n when\n is_integer(_nth@1)\n andalso\n _nth@1 > 1 ->\n {_res@1,_} =\n reduce(_enumerable@1,\n {[],first},\n fun(__@1, {__@2,__@3})\n when\n __@3 =:= first\n orelse\n __@3 =:= _nth@1 ->\n {__@2,1};\n (__@4, {__@5,__@6}) ->\n {[__@4|__@5],__@6 + 1}\n end),\n lists:reverse(_res@1).\n\ndrop_list(_list@1, 0) ->\n _list@1;\ndrop_list([_|_tail@1], _counter@1) ->\n drop_list(_tail@1, _counter@1 - 1);\ndrop_list([], _) ->\n [].\n\ndrop_while(_enumerable@1, _fun@1) when is_list(_enumerable@1) ->\n drop_while_list(_enumerable@1, _fun@1);\ndrop_while(_enumerable@1, _fun@1) ->\n {_res@1,_} =\n reduce(_enumerable@1,\n {[],true},\n fun(__@1, {__@3,__@4} = __@2) ->\n case\n case __@4 of\n false ->\n false;\n true ->\n _fun@1(__@1);\n __@5 ->\n error({badbool,'and',__@5})\n end\n of\n __@6\n when\n __@6 =:= nil\n orelse\n __@6 =:= false ->\n {[__@1|__@3],false};\n _ ->\n __@2\n end\n end),\n lists:reverse(_res@1).\n\ndrop_while_list([_head@1|_tail@1], _fun@1) ->\n case _fun@1(_head@1) of\n __@1\n when\n __@1 =:= nil\n orelse\n __@1 =:= false ->\n [_head@1|_tail@1];\n _ ->\n drop_while_list(_tail@1, _fun@1)\n end;\ndrop_while_list([], _) ->\n [].\n\neach(_enumerable@1, _fun@1) when is_list(_enumerable@1) ->\n lists:foreach(_fun@1, _enumerable@1),\n ok;\neach(_enumerable@1, _fun@1) ->\n reduce(_enumerable@1,\n nil,\n fun(_entry@1, _) ->\n _fun@1(_entry@1),\n nil\n end),\n ok.\n\n'empty?'(_enumerable@1) when is_list(_enumerable@1) ->\n _enumerable@1 == [];\n'empty?'(_enumerable@1) ->\n case backwards_compatible_slice(_enumerable@1) of\n {ok,_value@1,_} ->\n _value@1 == 0;\n {error,_module@1} ->\n element(2,\n _module@1:reduce(_enumerable@1,\n {cont,true},\n fun(_, _) ->\n {halt,false}\n end))\n end.\n\nentry_to_string(_entry@1) when is_binary(_entry@1) ->\n _entry@1;\nentry_to_string(_entry@1) ->\n case _entry@1 of\n _rewrite@1 when is_binary(_rewrite@1) ->\n _rewrite@1;\n _rewrite@1 ->\n 'Elixir.String.Chars':to_string(_rewrite@1)\n end.\n\nfetch(_enumerable@1, _index@1) ->\n case slice_any(_enumerable@1, _index@1, 1) of\n [_value@1] ->\n {ok,_value@1};\n [] ->\n error\n end.\n\n'fetch!'(_enumerable@1, _index@1) ->\n case slice_any(_enumerable@1, _index@1, 1) of\n [_value@1] ->\n _value@1;\n [] ->\n error('Elixir.Enum.OutOfBoundsError':exception([]))\n end.\n\nfilter(_enumerable@1, _fun@1) when is_list(_enumerable@1) ->\n filter_list(_enumerable@1, _fun@1);\nfilter(_enumerable@1, _fun@1) ->\n lists:reverse(reduce(_enumerable@1,\n [],\n fun(__@1, __@2) ->\n case _fun@1(__@1) of\n __@3\n when\n __@3 =:= nil\n orelse\n __@3 =:= false ->\n __@2;\n _ ->\n [__@1|__@2]\n end\n end)).\n\nfilter_list([_head@1|_tail@1], _fun@1) ->\n case _fun@1(_head@1) of\n __@1\n when\n __@1 =:= nil\n orelse\n __@1 =:= false ->\n filter_list(_tail@1, _fun@1);\n _ ->\n [_head@1|filter_list(_tail@1, _fun@1)]\n end;\nfilter_list([], __fun@1) ->\n [].\n\nfilter_map(_enumerable@1, _filter@1, _mapper@1)\n when is_list(_enumerable@1) ->\n lists:reverse('Elixir.Enum':reduce(_enumerable@1,\n [],\n fun(_item@1, __@2) ->\n case _filter@1(_item@1) of\n __@1\n when\n __@1 == false;\n __@1 == nil ->\n __@2;\n _ ->\n [_mapper@1(_item@1)|\n __@2]\n end\n end));\nfilter_map(_enumerable@1, _filter@1, _mapper@1) ->\n lists:reverse(reduce(_enumerable@1,\n [],\n fun(__@1, __@2) ->\n case _filter@1(__@1) of\n __@3\n when\n __@3 =:= nil\n orelse\n __@3 =:= false ->\n __@2;\n _ ->\n [_mapper@1(__@1)|__@2]\n end\n end)).\n\nfind(__@1, __@2) ->\n find(__@1, nil, __@2).\n\nfind(_enumerable@1, _default@1, _fun@1) when is_list(_enumerable@1) ->\n find_list(_enumerable@1, _default@1, _fun@1);\nfind(_enumerable@1, _default@1, _fun@1) ->\n element(2,\n 'Elixir.Enumerable':reduce(_enumerable@1,\n {cont,_default@1},\n fun(_entry@1, _default@2) ->\n case _fun@1(_entry@1) of\n __@1\n when\n __@1 =:= nil\n orelse\n __@1 =:= false ->\n {cont,_default@2};\n _ ->\n {halt,_entry@1}\n end\n end)).\n\nfind_index(_enumerable@1, _fun@1) when is_list(_enumerable@1) ->\n find_index_list(_enumerable@1, 0, _fun@1);\nfind_index(_enumerable@1, _fun@1) ->\n _result@1 =\n 'Elixir.Enumerable':reduce(_enumerable@1,\n {cont,{not_found,0}},\n fun(_entry@1, {_,_index@1}) ->\n case _fun@1(_entry@1) of\n __@1\n when\n __@1 =:= nil\n orelse\n __@1 =:= false ->\n {cont,\n {not_found,\n _index@1 + 1}};\n _ ->\n {halt,\n {found,_index@1}}\n end\n end),\n case element(2, _result@1) of\n {found,_index@2} ->\n _index@2;\n {not_found,_} ->\n nil\n end.\n\nfind_index_list([_head@1|_tail@1], _counter@1, _fun@1) ->\n case _fun@1(_head@1) of\n __@1\n when\n __@1 =:= nil\n orelse\n __@1 =:= false ->\n find_index_list(_tail@1, _counter@1 + 1, _fun@1);\n _ ->\n _counter@1\n end;\nfind_index_list([], _, _) ->\n nil.\n\nfind_list([_head@1|_tail@1], _default@1, _fun@1) ->\n case _fun@1(_head@1) of\n __@1\n when\n __@1 =:= nil\n orelse\n __@1 =:= false ->\n find_list(_tail@1, _default@1, _fun@1);\n _ ->\n _head@1\n end;\nfind_list([], _default@1, _) ->\n _default@1.\n\nfind_value(__@1, __@2) ->\n find_value(__@1, nil, __@2).\n\nfind_value(_enumerable@1, _default@1, _fun@1)\n when is_list(_enumerable@1) ->\n find_value_list(_enumerable@1, _default@1, _fun@1);\nfind_value(_enumerable@1, _default@1, _fun@1) ->\n element(2,\n 'Elixir.Enumerable':reduce(_enumerable@1,\n {cont,_default@1},\n fun(_entry@1, _default@2) ->\n _fun_entry@1 =\n _fun@1(_entry@1),\n case _fun_entry@1 of\n __@1\n when\n __@1 =:= nil\n orelse\n __@1 =:= false ->\n {cont,_default@2};\n _ ->\n {halt,\n _fun_entry@1}\n end\n end)).\n\nfind_value_list([_head@1|_tail@1], _default@1, _fun@1) ->\n case _fun@1(_head@1) of\n __@1\n when\n __@1 =:= nil\n orelse\n __@1 =:= false ->\n find_value_list(_tail@1, _default@1, _fun@1);\n __@2 ->\n __@2\n end;\nfind_value_list([], _default@1, _) ->\n _default@1.\n\nflat_map(_enumerable@1, _fun@1) when is_list(_enumerable@1) ->\n flat_map_list(_enumerable@1, _fun@1);\nflat_map(_enumerable@1, _fun@1) ->\n lists:reverse(reduce(_enumerable@1,\n [],\n fun(_entry@1, _acc@1) ->\n case _fun@1(_entry@1) of\n _list@1 when is_list(_list@1) ->\n lists:reverse(_list@1, _acc@1);\n _other@1 ->\n reduce(_other@1,\n _acc@1,\n fun(__@1, __@2) ->\n [__@1|__@2]\n end)\n end\n end)).\n\nflat_map_list([_head@1|_tail@1], _fun@1) ->\n case _fun@1(_head@1) of\n _list@1 when is_list(_list@1) ->\n _list@1 ++ flat_map_list(_tail@1, _fun@1);\n _other@1 ->\n to_list(_other@1) ++ flat_map_list(_tail@1, _fun@1)\n end;\nflat_map_list([], __fun@1) ->\n [].\n\nflat_map_reduce(_enumerable@1, _acc@1, _fun@1) ->\n {_,{_list@2,_acc@7}} =\n 'Elixir.Enumerable':reduce(_enumerable@1,\n {cont,{[],_acc@1}},\n fun(_entry@1, {_list@1,_acc@2}) ->\n case\n _fun@1(_entry@1, _acc@2)\n of\n {halt,_acc@3} ->\n {halt,\n {_list@1,_acc@3}};\n {[],_acc@4} ->\n {cont,\n {_list@1,_acc@4}};\n {[_entry@2],_acc@5} ->\n {cont,\n {[_entry@2|_list@1],\n _acc@5}};\n {_entries@1,_acc@6} ->\n {cont,\n {reduce(_entries@1,\n _list@1,\n fun(__@1,\n __@2) ->\n [__@1|\n __@2]\n end),\n _acc@6}}\n end\n end),\n {lists:reverse(_list@2),_acc@7}.\n\ngroup_by(__@1, __@2) ->\n group_by(__@1,\n __@2,\n fun(_x@1) ->\n _x@1\n end).\n\ngroup_by(_enumerable@1, _key_fun@1, _value_fun@1)\n when is_function(_key_fun@1) ->\n reduce(reverse(_enumerable@1),\n #{},\n fun(_entry@1, _acc@1) ->\n _key@1 = _key_fun@1(_entry@1),\n _value@1 = _value_fun@1(_entry@1),\n case _acc@1 of\n #{_key@1 := _existing@1} ->\n _acc@1#{_key@1 => [_value@1|_existing@1]};\n #{} ->\n _acc@1#{_key@1 => [_value@1]}\n end\n end);\ngroup_by(_enumerable@1, _dict@1, _fun@1) ->\n 'Elixir.IO':warn(<<\"Enum.group_by/3 with a map/dictionary as second\"\n \" element is deprecated. \",\n \"A map is used by default and it is no longer re\"\n \"quired to pass one to this function\">>),\n _dict_module@1 = 'Elixir.Dict',\n reduce(reverse(_enumerable@1),\n _dict@1,\n fun(_entry@1, _categories@1) ->\n _dict_module@1:update(_categories@1,\n _fun@1(_entry@1),\n [_entry@1],\n fun(__@1) ->\n [_entry@1|__@1]\n end)\n end).\n\nhead_slice(_rest@1, 0, _acc@1) ->\n {_acc@1,_rest@1};\nhead_slice([_elem@1|_rest@1], _count@1, _acc@1) ->\n head_slice(_rest@1, _count@1 - 1, [_elem@1|_acc@1]).\n\nintersperse(_enumerable@1, _element@1) ->\n _list@1 =\n lists:reverse(reduce(_enumerable@1,\n [],\n fun(_x@1, _acc@1) ->\n [_x@1,_element@1|_acc@1]\n end)),\n case _list@1 of\n [] ->\n [];\n [_|_t@1] ->\n _t@1\n end.\n\ninto(_enumerable@1, []) ->\n to_list(_enumerable@1);\ninto(#{'__struct__' := __@1 = _} = _enumerable@1, _collectable@1)\n when is_atom(__@1) ->\n into_protocol(_enumerable@1, _collectable@1);\ninto(_enumerable@1, #{'__struct__' := __@1 = _} = _collectable@1)\n when is_atom(__@1) ->\n into_protocol(_enumerable@1, _collectable@1);\ninto(#{} = _enumerable@1, #{} = _collectable@1) ->\n maps:merge(_collectable@1, _enumerable@1);\ninto(_enumerable@1, #{} = _collectable@1) when is_list(_enumerable@1) ->\n maps:merge(_collectable@1, maps:from_list(_enumerable@1));\ninto(_enumerable@1, #{} = _collectable@1) ->\n reduce(_enumerable@1,\n _collectable@1,\n fun({_key@1,_val@1}, _acc@1) ->\n _acc@1#{_key@1 => _val@1}\n end);\ninto(_enumerable@1, _collectable@1) ->\n into_protocol(_enumerable@1, _collectable@1).\n\ninto(_enumerable@1, _collectable@1, _transform@1)\n when is_list(_collectable@1) ->\n _collectable@1 ++ map(_enumerable@1, _transform@1);\ninto(_enumerable@1, _collectable@1, _transform@1) ->\n {_initial@1,_fun@1} = 'Elixir.Collectable':into(_collectable@1),\n into(_enumerable@1,\n _initial@1,\n _fun@1,\n fun(_entry@1, _acc@1) ->\n _fun@1(_acc@1, {cont,_transform@1(_entry@1)})\n end).\n\ninto(_enumerable@1, _initial@1, _fun@1, _callback@1) ->\n try reduce(_enumerable@1, _initial@1, _callback@1) of\n _acc@1 ->\n _fun@1(_acc@1, done)\n catch\n _kind@1:_reason@1:___STACKTRACE__@1 ->\n _fun@1(_initial@1, halt),\n erlang:raise(_kind@1, _reason@1, ___STACKTRACE__@1)\n end.\n\ninto_protocol(_enumerable@1, _collectable@1) ->\n {_initial@1,_fun@1} = 'Elixir.Collectable':into(_collectable@1),\n into(_enumerable@1,\n _initial@1,\n _fun@1,\n fun(_entry@1, _acc@1) ->\n _fun@1(_acc@1, {cont,_entry@1})\n end).\n\njoin(__@1) ->\n join(__@1, <<>>).\n\njoin(_enumerable@1, _joiner@1) when is_binary(_joiner@1) ->\n _reduced@1 =\n reduce(_enumerable@1,\n first,\n fun(_entry@1, first) ->\n entry_to_string(_entry@1);\n (_entry@2, _acc@1) ->\n [_acc@1,_joiner@1|entry_to_string(_entry@2)]\n end),\n case _reduced@1 == first of\n false ->\n iolist_to_binary(_reduced@1);\n true ->\n <<>>\n end.\n\nmap(_enumerable@1, _fun@1) when is_list(_enumerable@1) ->\n lists:map(_fun@1, _enumerable@1);\nmap(_enumerable@1, _fun@1) ->\n lists:reverse(reduce(_enumerable@1,\n [],\n fun(__@1, __@2) ->\n [_fun@1(__@1)|__@2]\n end)).\n\nmap_every(_enumerable@1, 1, _fun@1) ->\n map(_enumerable@1, _fun@1);\nmap_every(_enumerable@1, 0, __fun@1) ->\n to_list(_enumerable@1);\nmap_every([], _nth@1, __fun@1)\n when\n is_integer(_nth@1)\n andalso\n _nth@1 > 1 ->\n [];\nmap_every(_enumerable@1, _nth@1, _fun@1)\n when\n is_integer(_nth@1)\n andalso\n _nth@1 > 1 ->\n {_res@1,_} =\n reduce(_enumerable@1,\n {[],first},\n fun(__@1, {__@2,__@3})\n when\n __@3 =:= first\n orelse\n __@3 =:= _nth@1 ->\n {[_fun@1(__@1)|__@2],1};\n (__@4, {__@5,__@6}) ->\n {[__@4|__@5],__@6 + 1}\n end),\n lists:reverse(_res@1).\n\nmap_join(__@1, __@2) ->\n map_join(__@1, <<>>, __@2).\n\nmap_join(_enumerable@1, _joiner@1, _mapper@1) when is_binary(_joiner@1) ->\n _reduced@1 =\n reduce(_enumerable@1,\n first,\n fun(_entry@1, first) ->\n entry_to_string(_mapper@1(_entry@1));\n (_entry@2, _acc@1) ->\n [_acc@1,\n _joiner@1|\n entry_to_string(_mapper@1(_entry@2))]\n end),\n case _reduced@1 == first of\n false ->\n iolist_to_binary(_reduced@1);\n true ->\n <<>>\n end.\n\nmap_reduce(_enumerable@1, _acc@1, _fun@1) when is_list(_enumerable@1) ->\n lists:mapfoldl(_fun@1, _acc@1, _enumerable@1);\nmap_reduce(_enumerable@1, _acc@1, _fun@1) ->\n {_list@2,_acc@4} =\n reduce(_enumerable@1,\n {[],_acc@1},\n fun(_entry@1, {_list@1,_acc@2}) ->\n {_new_entry@1,_acc@3} = _fun@1(_entry@1, _acc@2),\n {[_new_entry@1|_list@1],_acc@3}\n end),\n {lists:reverse(_list@2),_acc@4}.\n\nmax(__@1) ->\n max(__@1,\n fun() ->\n error('Elixir.Enum.EmptyError':exception([]))\n end).\n\nmax(_enumerable@1, _empty_fallback@1)\n when is_function(_empty_fallback@1, 0) ->\n aggregate(_enumerable@1, fun erlang:max/2, _empty_fallback@1).\n\nmax_by(__@1, __@2) ->\n max_by(__@1,\n __@2,\n fun() ->\n error('Elixir.Enum.EmptyError':exception([]))\n end).\n\nmax_by(_enumerable@1, _fun@1, _empty_fallback@1)\n when\n is_function(_fun@1, 1)\n andalso\n is_function(_empty_fallback@1, 0) ->\n _first_fun@1 =\n fun(__@1) ->\n {__@1,_fun@1(__@1)}\n end,\n _reduce_fun@1 =\n fun(_entry@1, {_,_fun_max@1} = _old@1) ->\n _fun_entry@1 = _fun@1(_entry@1),\n case _fun_entry@1 > _fun_max@1 of\n false ->\n _old@1;\n true ->\n {_entry@1,_fun_entry@1}\n end\n end,\n case reduce_by(_enumerable@1, _first_fun@1, _reduce_fun@1) of\n empty ->\n _empty_fallback@1();\n {_entry@2,_} ->\n _entry@2\n end.\n\n'member?'(_enumerable@1, _element@1) when is_list(_enumerable@1) ->\n lists:member(_element@1, _enumerable@1);\n'member?'(_enumerable@1, _element@1) ->\n case 'Elixir.Enumerable':'member?'(_enumerable@1, _element@1) of\n {ok,_element@2} when is_boolean(_element@2) ->\n _element@2;\n {error,_module@1} ->\n element(2,\n _module@1:reduce(_enumerable@1,\n {cont,false},\n fun(_v@1, _)\n when _v@1 =:= _element@1 ->\n {halt,true};\n (_, _) ->\n {cont,false}\n end))\n end.\n\nmin(__@1) ->\n min(__@1,\n fun() ->\n error('Elixir.Enum.EmptyError':exception([]))\n end).\n\nmin(_enumerable@1, _empty_fallback@1)\n when is_function(_empty_fallback@1, 0) ->\n aggregate(_enumerable@1, fun erlang:min/2, _empty_fallback@1).\n\nmin_by(__@1, __@2) ->\n min_by(__@1,\n __@2,\n fun() ->\n error('Elixir.Enum.EmptyError':exception([]))\n end).\n\nmin_by(_enumerable@1, _fun@1, _empty_fallback@1)\n when\n is_function(_fun@1, 1)\n andalso\n is_function(_empty_fallback@1, 0) ->\n _first_fun@1 =\n fun(__@1) ->\n {__@1,_fun@1(__@1)}\n end,\n _reduce_fun@1 =\n fun(_entry@1, {_,_fun_min@1} = _old@1) ->\n _fun_entry@1 = _fun@1(_entry@1),\n case _fun_entry@1 < _fun_min@1 of\n false ->\n _old@1;\n true ->\n {_entry@1,_fun_entry@1}\n end\n end,\n case reduce_by(_enumerable@1, _first_fun@1, _reduce_fun@1) of\n empty ->\n _empty_fallback@1();\n {_entry@2,_} ->\n _entry@2\n end.\n\nmin_max(__@1) ->\n min_max(__@1,\n fun() ->\n error('Elixir.Enum.EmptyError':exception([]))\n end).\n\nmin_max(#{'__struct__' := 'Elixir.Range',\n first := _first@1,\n last := _last@1},\n _empty_fallback@1)\n when is_function(_empty_fallback@1, 0) ->\n {min(_first@1, _last@1),max(_first@1, _last@1)};\nmin_max(_enumerable@1, _empty_fallback@1)\n when is_function(_empty_fallback@1, 0) ->\n _first_fun@1 =\n fun(__@1) ->\n {__@1,__@1}\n end,\n _reduce_fun@1 =\n fun(_entry@1, {_min@1,_max@1}) ->\n {min(_entry@1, _min@1),max(_entry@1, _max@1)}\n end,\n case reduce_by(_enumerable@1, _first_fun@1, _reduce_fun@1) of\n empty ->\n _empty_fallback@1();\n _entry@2 ->\n _entry@2\n end.\n\nmin_max_by(__@1, __@2) ->\n min_max_by(__@1,\n __@2,\n fun() ->\n error('Elixir.Enum.EmptyError':exception([]))\n end).\n\nmin_max_by(_enumerable@1, _fun@1, _empty_fallback@1)\n when\n is_function(_fun@1, 1)\n andalso\n is_function(_empty_fallback@1, 0) ->\n _first_fun@1 =\n fun(_entry@1) ->\n _fun_entry@1 = _fun@1(_entry@1),\n {{_entry@1,_entry@1},{_fun_entry@1,_fun_entry@1}}\n end,\n _reduce_fun@1 =\n fun(_entry@2,\n {{_prev_min@1,_prev_max@1},{_fun_min@1,_fun_max@1}} = _acc@1) ->\n _fun_entry@2 = _fun@1(_entry@2),\n case _fun_entry@2 < _fun_min@1 of\n true ->\n {{_entry@2,_prev_max@1},\n {_fun_entry@2,_fun_max@1}};\n false ->\n case _fun_entry@2 > _fun_max@1 of\n true ->\n {{_prev_min@1,_entry@2},\n {_fun_min@1,_fun_entry@2}};\n false ->\n case true of\n true ->\n _acc@1;\n false ->\n error(cond_clause)\n end\n end\n end\n end,\n case reduce_by(_enumerable@1, _first_fun@1, _reduce_fun@1) of\n empty ->\n _empty_fallback@1();\n {_entry@3,_} ->\n _entry@3\n end.\n\npartition(_enumerable@1, _fun@1) ->\n split_with(_enumerable@1, _fun@1).\n\nrandom(_enumerable@1) when is_list(_enumerable@1) ->\n case take_random(_enumerable@1, 1) of\n [] ->\n error('Elixir.Enum.EmptyError':exception([]));\n [_elem@1] ->\n _elem@1\n end;\nrandom(_enumerable@1) ->\n _result@1 =\n case backwards_compatible_slice(_enumerable@1) of\n {ok,0,_} ->\n [];\n {ok,_count@1,_fun@1} when is_function(_fun@1) ->\n _fun@1(random_integer(0, _count@1 - 1), 1);\n {error,_} ->\n take_random(_enumerable@1, 1)\n end,\n case _result@1 of\n [] ->\n error('Elixir.Enum.EmptyError':exception([]));\n [_elem@1] ->\n _elem@1\n end.\n\nrandom_integer(_limit@1, _limit@1) when is_integer(_limit@1) ->\n _limit@1;\nrandom_integer(_lower_limit@1, _upper_limit@1)\n when _upper_limit@1 < _lower_limit@1 ->\n random_integer(_upper_limit@1, _lower_limit@1);\nrandom_integer(_lower_limit@1, _upper_limit@1) ->\n _lower_limit@1 + rand:uniform(_upper_limit@1 - _lower_limit@1 + 1)\n -\n 1.\n\nreduce([_h@1|_t@1], _fun@1) ->\n reduce(_t@1, _h@1, _fun@1);\nreduce([], __fun@1) ->\n error('Elixir.Enum.EmptyError':exception([]));\nreduce(_enumerable@1, _fun@1) ->\n _result@1 =\n element(2,\n 'Elixir.Enumerable':reduce(_enumerable@1,\n {cont,first},\n fun(_x@1, first) ->\n {cont,{acc,_x@1}};\n (_x@2, {acc,_acc@1}) ->\n {cont,\n {acc,\n _fun@1(_x@2, _acc@1)}}\n end)),\n case _result@1 of\n first ->\n error('Elixir.Enum.EmptyError':exception([]));\n {acc,_acc@2} ->\n _acc@2\n end.\n\nreduce(_enumerable@1, _acc@1, _fun@1) when is_list(_enumerable@1) ->\n lists:foldl(_fun@1, _acc@1, _enumerable@1);\nreduce(#{'__struct__' := 'Elixir.Range',\n first := _first@1,\n last := _last@1},\n _acc@1,\n _fun@1) ->\n case _first@1 =< _last@1 of\n false ->\n reduce_range_dec(_first@1, _last@1, _acc@1, _fun@1);\n true ->\n reduce_range_inc(_first@1, _last@1, _acc@1, _fun@1)\n end;\nreduce(#{'__struct__' := __@1 = _} = _enumerable@1, _acc@1, _fun@1)\n when is_atom(__@1) ->\n reduce_enumerable(_enumerable@1, _acc@1, _fun@1);\nreduce(#{} = _enumerable@1, _acc@1, _fun@1) ->\n maps:fold(fun(_k@1, _v@1, _acc@2) ->\n _fun@1({_k@1,_v@1}, _acc@2)\n end,\n _acc@1,\n _enumerable@1);\nreduce(_enumerable@1, _acc@1, _fun@1) ->\n reduce_enumerable(_enumerable@1, _acc@1, _fun@1).\n\nreduce_by([_head@1|_tail@1], _first@1, _fun@1) ->\n lists:foldl(_fun@1, _first@1(_head@1), _tail@1);\nreduce_by([], __first@1, __fun@1) ->\n empty;\nreduce_by(_enumerable@1, _first@1, _fun@1) ->\n reduce(_enumerable@1,\n empty,\n fun(_element@1, {_,_} = _acc@1) ->\n _fun@1(_element@1, _acc@1);\n (_element@2, empty) ->\n _first@1(_element@2)\n end).\n\nreduce_enumerable(_enumerable@1, _acc@1, _fun@1) ->\n element(2,\n 'Elixir.Enumerable':reduce(_enumerable@1,\n {cont,_acc@1},\n fun(_x@1, _acc@2) ->\n {cont,\n _fun@1(_x@1, _acc@2)}\n end)).\n\nreduce_range_dec(_first@1, _first@1, _acc@1, _fun@1) ->\n _fun@1(_first@1, _acc@1);\nreduce_range_dec(_first@1, _last@1, _acc@1, _fun@1) ->\n reduce_range_dec(_first@1 - 1,\n _last@1,\n _fun@1(_first@1, _acc@1),\n _fun@1).\n\nreduce_range_inc(_first@1, _first@1, _acc@1, _fun@1) ->\n _fun@1(_first@1, _acc@1);\nreduce_range_inc(_first@1, _last@1, _acc@1, _fun@1) ->\n reduce_range_inc(_first@1 + 1,\n _last@1,\n _fun@1(_first@1, _acc@1),\n _fun@1).\n\nreduce_while(_enumerable@1, _acc@1, _fun@1) ->\n element(2,\n 'Elixir.Enumerable':reduce(_enumerable@1,\n {cont,_acc@1},\n _fun@1)).\n\nreject(_enumerable@1, _fun@1) when is_list(_enumerable@1) ->\n reject_list(_enumerable@1, _fun@1);\nreject(_enumerable@1, _fun@1) ->\n lists:reverse(reduce(_enumerable@1,\n [],\n fun(__@1, __@2) ->\n case _fun@1(__@1) of\n __@3\n when\n __@3 =:= nil\n orelse\n __@3 =:= false ->\n [__@1|__@2];\n _ ->\n __@2\n end\n end)).\n\nreject_list([_head@1|_tail@1], _fun@1) ->\n case _fun@1(_head@1) of\n __@1\n when\n __@1 =:= nil\n orelse\n __@1 =:= false ->\n [_head@1|reject_list(_tail@1, _fun@1)];\n _ ->\n reject_list(_tail@1, _fun@1)\n end;\nreject_list([], __fun@1) ->\n [].\n\nreverse([]) ->\n [];\nreverse([_] = _list@1) ->\n _list@1;\nreverse([_item1@1,_item2@1]) ->\n [_item2@1,_item1@1];\nreverse([_item1@1,_item2@1|_rest@1]) ->\n lists:reverse(_rest@1, [_item2@1,_item1@1]);\nreverse(_enumerable@1) ->\n reduce(_enumerable@1,\n [],\n fun(__@1, __@2) ->\n [__@1|__@2]\n end).\n\nreverse(_enumerable@1, _tail@1) when is_list(_enumerable@1) ->\n lists:reverse(_enumerable@1, to_list(_tail@1));\nreverse(_enumerable@1, _tail@1) ->\n reduce(_enumerable@1,\n to_list(_tail@1),\n fun(_entry@1, _acc@1) ->\n [_entry@1|_acc@1]\n end).\n\nreverse_slice(_enumerable@1, _start_index@1, _count@1)\n when\n ((is_integer(_start_index@1)\n andalso\n _start_index@1 >= 0)\n andalso\n is_integer(_count@1))\n andalso\n _count@1 >= 0 ->\n _list@1 = reverse(_enumerable@1),\n _length@1 = length(_list@1),\n _count@2 = min(_count@1, _length@1 - _start_index@1),\n case _count@2 > 0 of\n false ->\n lists:reverse(_list@1);\n true ->\n reverse_slice(_list@1,\n _length@1,\n _start_index@1 + _count@2,\n _count@2,\n [])\n end.\n\nreverse_slice(_rest@1, _idx@1, _idx@1, _count@1, _acc@1) ->\n {_slice@1,_rest@2} = head_slice(_rest@1, _count@1, []),\n lists:reverse(_rest@2, lists:reverse(_slice@1, _acc@1));\nreverse_slice([_elem@1|_rest@1], _idx@1, _start@1, _count@1, _acc@1) ->\n reverse_slice(_rest@1,\n _idx@1 - 1,\n _start@1,\n _count@1,\n [_elem@1|_acc@1]).\n\nreverse_sort_merge([[_h2@1|_t2@1],_t1@1|_l@1], _acc@1, _fun@1, true) ->\n reverse_sort_merge(_l@1,\n [sort_merge1(_t1@1,\n _h2@1,\n _t2@1,\n [],\n _fun@1,\n true)|\n _acc@1],\n _fun@1,\n true);\nreverse_sort_merge([_t1@1,[_h2@1|_t2@1]|_l@1], _acc@1, _fun@1, false) ->\n reverse_sort_merge(_l@1,\n [sort_merge1(_t1@1,\n _h2@1,\n _t2@1,\n [],\n _fun@1,\n true)|\n _acc@1],\n _fun@1,\n false);\nreverse_sort_merge([_l@1], _acc@1, _fun@1, _bool@1) ->\n sort_merge([lists:reverse(_l@1, [])|_acc@1], [], _fun@1, _bool@1);\nreverse_sort_merge([], _acc@1, _fun@1, _bool@1) ->\n sort_merge(_acc@1, [], _fun@1, _bool@1).\n\nscan(_enumerable@1, _fun@1) ->\n {_res@1,_} =\n reduce(_enumerable@1,\n {[],first},\n fun(__@1, {__@2,first}) ->\n {[__@1|__@2],{ok,__@1}};\n (__@3, {__@4,{ok,__@5}}) ->\n __@6 = _fun@1(__@3, __@5),\n {[__@6|__@4],{ok,__@6}}\n end),\n lists:reverse(_res@1).\n\nscan(_enumerable@1, _acc@1, _fun@1) ->\n {_res@1,_} =\n reduce(_enumerable@1,\n {[],_acc@1},\n fun(__@1, {__@2,__@3}) ->\n __@4 = _fun@1(__@1, __@3),\n {[__@4|__@2],__@4}\n end),\n lists:reverse(_res@1).\n\nshuffle(_enumerable@1) ->\n _randomized@1 =\n reduce(_enumerable@1,\n [],\n fun(_x@1, _acc@1) ->\n [{rand:uniform(),_x@1}|_acc@1]\n end),\n shuffle_unwrap(lists:keysort(1, _randomized@1), []).\n\nshuffle_unwrap([{_,_h@1}|_enumerable@1], _t@1) ->\n shuffle_unwrap(_enumerable@1, [_h@1|_t@1]);\nshuffle_unwrap([], _t@1) ->\n _t@1.\n\nslice(_enumerable@1,\n #{'__struct__' := 'Elixir.Range',\n first := _first@1,\n last := _last@1}) ->\n {_count@1,_fun@1} = slice_count_and_fun(_enumerable@1),\n _corr_first@1 =\n case _first@1 >= 0 of\n false ->\n _first@1 + _count@1;\n true ->\n _first@1\n end,\n _corr_last@1 =\n case _last@1 >= 0 of\n false ->\n _last@1 + _count@1;\n true ->\n _last@1\n end,\n _amount@1 = _corr_last@1 - _corr_first@1 + 1,\n case\n case\n case _corr_first@1 >= 0 of\n false ->\n false;\n true ->\n _corr_first@1 < _count@1\n end\n of\n false ->\n false;\n true ->\n _amount@1 > 0\n end\n of\n false ->\n [];\n true ->\n _fun@1(_corr_first@1,\n min(_amount@1, _count@1 - _corr_first@1))\n end.\n\nslice(__enumerable@1, _start_index@1, 0) when is_integer(_start_index@1) ->\n [];\nslice(_enumerable@1, _start_index@1, _amount@1)\n when\n (is_integer(_start_index@1)\n andalso\n is_integer(_amount@1))\n andalso\n _amount@1 >= 0 ->\n slice_any(_enumerable@1, _start_index@1, _amount@1).\n\nslice_any(_enumerable@1, _start@1, _amount@1) when _start@1 < 0 ->\n {_count@1,_fun@1} = slice_count_and_fun(_enumerable@1),\n _start@2 = _count@1 + _start@1,\n case _start@2 >= 0 of\n false ->\n [];\n true ->\n _fun@1(_start@2, min(_amount@1, _count@1 - _start@2))\n end;\nslice_any(_list@1, _start@1, _amount@1) when is_list(_list@1) ->\n 'Elixir.Enumerable.List':slice(_list@1, _start@1, _amount@1);\nslice_any(_enumerable@1, _start@1, _amount@1) ->\n case backwards_compatible_slice(_enumerable@1) of\n {ok,_count@1,_} when _start@1 >= _count@1 ->\n [];\n {ok,_count@2,_fun@1} when is_function(_fun@1) ->\n _fun@1(_start@1, min(_amount@1, _count@2 - _start@1));\n {error,_module@1} ->\n slice_enum(_enumerable@1, _module@1, _start@1, _amount@1)\n end.\n\nslice_count_and_fun(_enumerable@1) when is_list(_enumerable@1) ->\n {length(_enumerable@1),\n fun(__@1, __@2) ->\n 'Elixir.Enumerable.List':slice(_enumerable@1, __@1, __@2)\n end};\nslice_count_and_fun(_enumerable@1) ->\n case backwards_compatible_slice(_enumerable@1) of\n {ok,_count@1,_fun@1} when is_function(_fun@1) ->\n {_count@1,_fun@1};\n {error,_module@1} ->\n {_,{_list@1,_count@3}} =\n _module@1:reduce(_enumerable@1,\n {cont,{[],0}},\n fun(_elem@1, {_acc@1,_count@2}) ->\n {cont,\n {[_elem@1|_acc@1],_count@2 + 1}}\n end),\n {_count@3,\n fun(__@1, __@2) ->\n 'Elixir.Enumerable.List':slice(lists:reverse(_list@1),\n __@1,\n __@2)\n end}\n end.\n\nslice_enum(_enumerable@1, _module@1, _start@1, _amount@1) ->\n {_,{_,_,_slice@1}} =\n _module@1:reduce(_enumerable@1,\n {cont,{_start@1,_amount@1,[]}},\n fun(__entry@1, {_start@2,_amount@2,__list@1})\n when _start@2 > 0 ->\n {cont,{_start@2 - 1,_amount@2,[]}};\n (_entry@1, {_start@3,_amount@3,_list@1})\n when _amount@3 > 1 ->\n {cont,\n {_start@3,\n _amount@3 - 1,\n [_entry@1|_list@1]}};\n (_entry@2, {_start@4,_amount@4,_list@2}) ->\n {halt,\n {_start@4,_amount@4,[_entry@2|_list@2]}}\n end),\n lists:reverse(_slice@1).\n\nsort(_enumerable@1) when is_list(_enumerable@1) ->\n lists:sort(_enumerable@1);\nsort(_enumerable@1) ->\n sort(_enumerable@1, fun erlang:'=<'/2).\n\nsort(_enumerable@1, _fun@1) when is_list(_enumerable@1) ->\n lists:sort(_fun@1, _enumerable@1);\nsort(_enumerable@1, _fun@1) ->\n sort_terminator(reduce(_enumerable@1,\n [],\n fun(__@1, __@2) ->\n sort_reducer(__@1, __@2, _fun@1)\n end),\n _fun@1).\n\nsort_by(__@1, __@2) ->\n sort_by(__@1, __@2, fun erlang:'=<'/2).\n\nsort_by(_enumerable@1, _mapper@1, _sorter@1) ->\n map(sort(map(_enumerable@1,\n fun(__@1) ->\n {__@1,_mapper@1(__@1)}\n end),\n fun(__@2, __@3) ->\n _sorter@1(element(2, __@2), element(2, __@3))\n end),\n fun(__@4) ->\n element(1, __@4)\n end).\n\nsort_merge(_list@1, _fun@1, true) ->\n reverse_sort_merge(_list@1, [], _fun@1, true);\nsort_merge(_list@1, _fun@1, false) ->\n sort_merge(_list@1, [], _fun@1, false).\n\nsort_merge([_t1@1,[_h2@1|_t2@1]|_l@1], _acc@1, _fun@1, true) ->\n sort_merge(_l@1,\n [sort_merge1(_t1@1, _h2@1, _t2@1, [], _fun@1, false)|\n _acc@1],\n _fun@1,\n true);\nsort_merge([[_h2@1|_t2@1],_t1@1|_l@1], _acc@1, _fun@1, false) ->\n sort_merge(_l@1,\n [sort_merge1(_t1@1, _h2@1, _t2@1, [], _fun@1, false)|\n _acc@1],\n _fun@1,\n false);\nsort_merge([_l@1], [], __fun@1, __bool@1) ->\n _l@1;\nsort_merge([_l@1], _acc@1, _fun@1, _bool@1) ->\n reverse_sort_merge([lists:reverse(_l@1, [])|_acc@1],\n [],\n _fun@1,\n _bool@1);\nsort_merge([], _acc@1, _fun@1, _bool@1) ->\n reverse_sort_merge(_acc@1, [], _fun@1, _bool@1).\n\nsort_merge1([_h1@1|_t1@1], _h2@1, _t2@1, _m@1, _fun@1, _bool@1) ->\n case _fun@1(_h1@1, _h2@1) == _bool@1 of\n false ->\n sort_merge1(_t1@1,\n _h2@1,\n _t2@1,\n [_h1@1|_m@1],\n _fun@1,\n _bool@1);\n true ->\n sort_merge2(_h1@1,\n _t1@1,\n _t2@1,\n [_h2@1|_m@1],\n _fun@1,\n _bool@1)\n end;\nsort_merge1([], _h2@1, _t2@1, _m@1, __fun@1, __bool@1) ->\n lists:reverse(_t2@1, [_h2@1|_m@1]).\n\nsort_merge2(_h1@1, _t1@1, [_h2@1|_t2@1], _m@1, _fun@1, _bool@1) ->\n case _fun@1(_h1@1, _h2@1) == _bool@1 of\n false ->\n sort_merge1(_t1@1,\n _h2@1,\n _t2@1,\n [_h1@1|_m@1],\n _fun@1,\n _bool@1);\n true ->\n sort_merge2(_h1@1,\n _t1@1,\n _t2@1,\n [_h2@1|_m@1],\n _fun@1,\n _bool@1)\n end;\nsort_merge2(_h1@1, _t1@1, [], _m@1, __fun@1, __bool@1) ->\n lists:reverse(_t1@1, [_h1@1|_m@1]).\n\nsort_reducer(_entry@1, {split,_y@1,_x@1,_r@1,_rs@1,_bool@1}, _fun@1) ->\n case _fun@1(_y@1, _entry@1) == _bool@1 of\n true ->\n {split,_entry@1,_y@1,[_x@1|_r@1],_rs@1,_bool@1};\n false ->\n case _fun@1(_x@1, _entry@1) == _bool@1 of\n true ->\n {split,_y@1,_entry@1,[_x@1|_r@1],_rs@1,_bool@1};\n false ->\n case _r@1 == [] of\n true ->\n {split,_y@1,_x@1,[_entry@1],_rs@1,_bool@1};\n false ->\n case true of\n true ->\n {pivot,\n _y@1,\n _x@1,\n _r@1,\n _rs@1,\n _entry@1,\n _bool@1};\n false ->\n error(cond_clause)\n end\n end\n end\n end;\nsort_reducer(_entry@1,\n {pivot,_y@1,_x@1,_r@1,_rs@1,_s@1,_bool@1},\n _fun@1) ->\n case _fun@1(_y@1, _entry@1) == _bool@1 of\n true ->\n {pivot,_entry@1,_y@1,[_x@1|_r@1],_rs@1,_s@1,_bool@1};\n false ->\n case _fun@1(_x@1, _entry@1) == _bool@1 of\n true ->\n {pivot,_y@1,_entry@1,[_x@1|_r@1],_rs@1,_s@1,_bool@1};\n false ->\n case _fun@1(_s@1, _entry@1) == _bool@1 of\n true ->\n {split,\n _entry@1,\n _s@1,\n [],\n [[_y@1,_x@1|_r@1]|_rs@1],\n _bool@1};\n false ->\n case true of\n true ->\n {split,\n _s@1,\n _entry@1,\n [],\n [[_y@1,_x@1|_r@1]|_rs@1],\n _bool@1};\n false ->\n error(cond_clause)\n end\n end\n end\n end;\nsort_reducer(_entry@1, [_x@1], _fun@1) ->\n {split,_entry@1,_x@1,[],[],_fun@1(_x@1, _entry@1)};\nsort_reducer(_entry@1, _acc@1, __fun@1) ->\n [_entry@1|_acc@1].\n\nsort_terminator({split,_y@1,_x@1,_r@1,_rs@1,_bool@1}, _fun@1) ->\n sort_merge([[_y@1,_x@1|_r@1]|_rs@1], _fun@1, _bool@1);\nsort_terminator({pivot,_y@1,_x@1,_r@1,_rs@1,_s@1,_bool@1}, _fun@1) ->\n sort_merge([[_s@1],[_y@1,_x@1|_r@1]|_rs@1], _fun@1, _bool@1);\nsort_terminator(_acc@1, __fun@1) ->\n _acc@1.\n\nsplit(_enumerable@1, _count@1)\n when\n is_list(_enumerable@1)\n andalso\n _count@1 >= 0 ->\n split_list(_enumerable@1, _count@1, []);\nsplit(_enumerable@1, _count@1) when _count@1 >= 0 ->\n {_,_list1@1,_list2@1} =\n reduce(_enumerable@1,\n {_count@1,[],[]},\n fun(_entry@1, {_counter@1,_acc1@1,_acc2@1}) ->\n case _counter@1 > 0 of\n false ->\n {_counter@1,_acc1@1,[_entry@1|_acc2@1]};\n true ->\n {_counter@1 - 1,\n [_entry@1|_acc1@1],\n _acc2@1}\n end\n end),\n {lists:reverse(_list1@1),lists:reverse(_list2@1)};\nsplit(_enumerable@1, _count@1) when _count@1 < 0 ->\n split_reverse_list(reverse(_enumerable@1), - _count@1, []).\n\nsplit_list([_head@1|_tail@1], _counter@1, _acc@1) when _counter@1 > 0 ->\n split_list(_tail@1, _counter@1 - 1, [_head@1|_acc@1]);\nsplit_list(_list@1, 0, _acc@1) ->\n {lists:reverse(_acc@1),_list@1};\nsplit_list([], _, _acc@1) ->\n {lists:reverse(_acc@1),[]}.\n\nsplit_reverse_list([_head@1|_tail@1], _counter@1, _acc@1)\n when _counter@1 > 0 ->\n split_reverse_list(_tail@1, _counter@1 - 1, [_head@1|_acc@1]);\nsplit_reverse_list(_list@1, 0, _acc@1) ->\n {lists:reverse(_list@1),_acc@1};\nsplit_reverse_list([], _, _acc@1) ->\n {[],_acc@1}.\n\nsplit_while(_enumerable@1, _fun@1) when is_list(_enumerable@1) ->\n split_while_list(_enumerable@1, _fun@1, []);\nsplit_while(_enumerable@1, _fun@1) ->\n {_list1@1,_list2@1} =\n reduce(_enumerable@1,\n {[],[]},\n fun(_entry@1, {_acc1@1,[]}) ->\n case _fun@1(_entry@1) of\n __@1\n when\n __@1 =:= nil\n orelse\n __@1 =:= false ->\n {_acc1@1,[_entry@1]};\n _ ->\n {[_entry@1|_acc1@1],[]}\n end;\n (_entry@2, {_acc1@2,_acc2@1}) ->\n {_acc1@2,[_entry@2|_acc2@1]}\n end),\n {lists:reverse(_list1@1),lists:reverse(_list2@1)}.\n\nsplit_while_list([_head@1|_tail@1], _fun@1, _acc@1) ->\n case _fun@1(_head@1) of\n __@1\n when\n __@1 =:= nil\n orelse\n __@1 =:= false ->\n {lists:reverse(_acc@1),[_head@1|_tail@1]};\n _ ->\n split_while_list(_tail@1, _fun@1, [_head@1|_acc@1])\n end;\nsplit_while_list([], _, _acc@1) ->\n {lists:reverse(_acc@1),[]}.\n\nsplit_with(_enumerable@1, _fun@1) ->\n {_acc1@2,_acc2@2} =\n reduce(_enumerable@1,\n {[],[]},\n fun(_entry@1, {_acc1@1,_acc2@1}) ->\n case _fun@1(_entry@1) of\n __@1\n when\n __@1 =:= nil\n orelse\n __@1 =:= false ->\n {_acc1@1,[_entry@1|_acc2@1]};\n _ ->\n {[_entry@1|_acc1@1],_acc2@1}\n end\n end),\n {lists:reverse(_acc1@2),lists:reverse(_acc2@2)}.\n\nsum(#{'__struct__' := 'Elixir.Range',first := _first@1,last := _last@1}) ->\n (_last@1 + _first@1) * (abs(_last@1 - _first@1) + 1) div 2;\nsum(_enumerable@1) ->\n reduce(_enumerable@1, 0, fun erlang:'+'/2).\n\ntake(__enumerable@1, 0) ->\n [];\ntake(_enumerable@1, _amount@1)\n when\n (is_list(_enumerable@1)\n andalso\n is_integer(_amount@1))\n andalso\n _amount@1 > 0 ->\n take_list(_enumerable@1, _amount@1);\ntake(_enumerable@1, _amount@1)\n when\n is_integer(_amount@1)\n andalso\n _amount@1 > 0 ->\n {_,{_res@1,_}} =\n 'Elixir.Enumerable':reduce(_enumerable@1,\n {cont,{[],_amount@1}},\n fun(_entry@1, {_list@1,_n@1}) ->\n case _n@1 of\n 1 ->\n {halt,\n {[_entry@1|_list@1],\n _n@1 - 1}};\n _ ->\n {cont,\n {[_entry@1|_list@1],\n _n@1 - 1}}\n end\n end),\n lists:reverse(_res@1);\ntake(_enumerable@1, _amount@1)\n when\n is_integer(_amount@1)\n andalso\n _amount@1 < 0 ->\n {_count@1,_fun@1} = slice_count_and_fun(_enumerable@1),\n _first@1 = max(_amount@1 + _count@1, 0),\n _fun@1(_first@1, _count@1 - _first@1).\n\ntake_every(_enumerable@1, 1) ->\n to_list(_enumerable@1);\ntake_every(__enumerable@1, 0) ->\n [];\ntake_every([], _nth@1)\n when\n is_integer(_nth@1)\n andalso\n _nth@1 > 1 ->\n [];\ntake_every(_enumerable@1, _nth@1)\n when\n is_integer(_nth@1)\n andalso\n _nth@1 > 1 ->\n {_res@1,_} =\n reduce(_enumerable@1,\n {[],first},\n fun(__@1, {__@2,__@3})\n when\n __@3 =:= first\n orelse\n __@3 =:= _nth@1 ->\n {[__@1|__@2],1};\n (__@4, {__@5,__@6}) ->\n {__@5,__@6 + 1}\n end),\n lists:reverse(_res@1).\n\ntake_list([_head@1|_], 1) ->\n [_head@1];\ntake_list([_head@1|_tail@1], _counter@1) ->\n [_head@1|take_list(_tail@1, _counter@1 - 1)];\ntake_list([], __counter@1) ->\n [].\n\ntake_random(__enumerable@1, 0) ->\n [];\ntake_random(_enumerable@1, _count@1)\n when\n is_integer(_count@1)\n andalso\n _count@1 > 128 ->\n _reducer@1 =\n fun(_elem@1, {_idx@1,_sample@1}) ->\n _jdx@1 = random_integer(0, _idx@1),\n case _idx@1 < _count@1 of\n true ->\n _value@1 = 'Elixir.Map':get(_sample@1, _jdx@1),\n {_idx@1 + 1,\n _sample@1#{_idx@1 => _value@1,_jdx@1 => _elem@1}};\n false ->\n case _jdx@1 < _count@1 of\n true ->\n {_idx@1 + 1,\n _sample@1#{_jdx@1 => _elem@1}};\n false ->\n case true of\n true ->\n {_idx@1 + 1,_sample@1};\n false ->\n error(cond_clause)\n end\n end\n end\n end,\n {_size@1,_sample@2} = reduce(_enumerable@1, {0,#{}}, _reducer@1),\n take_random(_sample@2, min(_count@1, _size@1), []);\ntake_random(_enumerable@1, _count@1)\n when\n is_integer(_count@1)\n andalso\n _count@1 > 0 ->\n _sample@1 = erlang:make_tuple(_count@1, nil),\n _reducer@1 =\n fun(_elem@1, {_idx@1,_sample@2}) ->\n _jdx@1 = random_integer(0, _idx@1),\n case _idx@1 < _count@1 of\n true ->\n _value@1 = element(_jdx@1 + 1, _sample@2),\n {_idx@1 + 1,\n setelement(_jdx@1 + 1,\n setelement(_idx@1 + 1,\n _sample@2,\n _value@1),\n _elem@1)};\n false ->\n case _jdx@1 < _count@1 of\n true ->\n {_idx@1 + 1,\n setelement(_jdx@1 + 1,\n _sample@2,\n _elem@1)};\n false ->\n case true of\n true ->\n {_idx@1 + 1,_sample@2};\n false ->\n error(cond_clause)\n end\n end\n end\n end,\n {_size@1,_sample@3} =\n reduce(_enumerable@1, {0,_sample@1}, _reducer@1),\n take(tuple_to_list(_sample@3), min(_count@1, _size@1)).\n\ntake_random(__sample@1, 0, _acc@1) ->\n _acc@1;\ntake_random(_sample@1, _position@1, _acc@1) ->\n _position@2 = _position@1 - 1,\n take_random(_sample@1,\n _position@2,\n ['Elixir.Map':get(_sample@1, _position@2)|_acc@1]).\n\ntake_while(_enumerable@1, _fun@1) when is_list(_enumerable@1) ->\n take_while_list(_enumerable@1, _fun@1);\ntake_while(_enumerable@1, _fun@1) ->\n {_,_res@1} =\n 'Elixir.Enumerable':reduce(_enumerable@1,\n {cont,[]},\n fun(_entry@1, _acc@1) ->\n case _fun@1(_entry@1) of\n __@1\n when\n __@1 =:= nil\n orelse\n __@1 =:= false ->\n {halt,_acc@1};\n _ ->\n {cont,\n [_entry@1|_acc@1]}\n end\n end),\n lists:reverse(_res@1).\n\ntake_while_list([_head@1|_tail@1], _fun@1) ->\n case _fun@1(_head@1) of\n __@1\n when\n __@1 =:= nil\n orelse\n __@1 =:= false ->\n [];\n _ ->\n [_head@1|take_while_list(_tail@1, _fun@1)]\n end;\ntake_while_list([], _) ->\n [].\n\nto_list(_enumerable@1) when is_list(_enumerable@1) ->\n _enumerable@1;\nto_list(#{'__struct__' := __@1 = _} = _enumerable@1) when is_atom(__@1) ->\n lists:reverse(reverse(_enumerable@1));\nto_list(#{} = _enumerable@1) ->\n maps:to_list(_enumerable@1);\nto_list(_enumerable@1) ->\n lists:reverse(reverse(_enumerable@1)).\n\nuniq(_enumerable@1) ->\n uniq_by(_enumerable@1,\n fun(_x@1) ->\n _x@1\n end).\n\nuniq(_enumerable@1, _fun@1) ->\n uniq_by(_enumerable@1, _fun@1).\n\nuniq_by(_enumerable@1, _fun@1) when is_list(_enumerable@1) ->\n uniq_list(_enumerable@1, #{}, _fun@1);\nuniq_by(_enumerable@1, _fun@1) ->\n {_list@1,_} =\n reduce(_enumerable@1,\n {[],#{}},\n fun(__@1, {__@3,__@4} = __@2) ->\n __@5 = _fun@1(__@1),\n case maps:is_key(__@5, __@4) of\n __@6\n when\n __@6 =:= nil\n orelse\n __@6 =:= false ->\n {[__@1|__@3],__@4#{__@5 => true}};\n _ ->\n __@2\n end\n end),\n lists:reverse(_list@1).\n\nuniq_list([_head@1|_tail@1], _set@1, _fun@1) ->\n _value@1 = _fun@1(_head@1),\n case _set@1 of\n #{_value@1 := true} ->\n uniq_list(_tail@1, _set@1, _fun@1);\n #{} ->\n [_head@1|\n uniq_list(_tail@1, _set@1#{_value@1 => true}, _fun@1)]\n end;\nuniq_list([], __set@1, __fun@1) ->\n [].\n\nunzip(_enumerable@1) ->\n {_list1@2,_list2@2} =\n reduce(_enumerable@1,\n {[],[]},\n fun({_el1@1,_el2@1}, {_list1@1,_list2@1}) ->\n {[_el1@1|_list1@1],[_el2@1|_list2@1]}\n end),\n {lists:reverse(_list1@2),lists:reverse(_list2@2)}.\n\nwith_index(__@1) ->\n with_index(__@1, 0).\n\nwith_index(_enumerable@1, _offset@1) ->\n element(1,\n map_reduce(_enumerable@1,\n _offset@1,\n fun(_x@1, _acc@1) ->\n {{_x@1,_acc@1},_acc@1 + 1}\n end)).\n\nzip([]) ->\n [];\nzip(_enumerables@1) ->\n lists:reverse(element(2,\n ('Elixir.Stream':zip(_enumerables@1))({cont,\n []},\n fun(__@1,\n __@2) ->\n {cont,\n [__@1|\n __@2]}\n end))).\n\nzip(_enumerable1@1, _enumerable2@1)\n when\n is_list(_enumerable1@1)\n andalso\n is_list(_enumerable2@1) ->\n zip_list(_enumerable1@1, _enumerable2@1);\nzip(_enumerable1@1, _enumerable2@1) ->\n zip([_enumerable1@1,_enumerable2@1]).\n\nzip_list([_h1@1|_next1@1], [_h2@1|_next2@1]) ->\n [{_h1@1,_h2@1}|zip_list(_next1@1, _next2@1)];\nzip_list(_, []) ->\n [];\nzip_list([], _) ->\n [].\n\n" }, { "path": "test_data/README.md", "content": "* basic_regress - Large amount of tiny snippets, checked for panics or errors, not valid output\n" }, { "path": "test_data/application_controller.core", "content": "module 'application_controller' ['change_application_data'/2,\n\t\t\t\t 'code_change'/3,\n\t\t\t\t 'config_change'/1,\n\t\t\t\t 'control_application'/1,\n\t\t\t\t 'do_config_diff'/2,\n\t\t\t\t 'get_all_env'/1,\n\t\t\t\t 'get_all_key'/1,\n\t\t\t\t 'get_application'/1,\n\t\t\t\t 'get_application_module'/1,\n\t\t\t\t 'get_env'/2,\n\t\t\t\t 'get_key'/2,\n\t\t\t\t 'get_loaded'/1,\n\t\t\t\t 'get_master'/1,\n\t\t\t\t 'get_pid_all_env'/1,\n\t\t\t\t 'get_pid_all_key'/1,\n\t\t\t\t 'get_pid_env'/2,\n\t\t\t\t 'get_pid_key'/2,\n\t\t\t\t 'handle_call'/3,\n\t\t\t\t 'handle_cast'/2,\n\t\t\t\t 'handle_info'/2,\n\t\t\t\t 'info'/0,\n\t\t\t\t 'init_starter'/4,\n\t\t\t\t 'load_application'/1,\n\t\t\t\t 'loaded_applications'/0,\n\t\t\t\t 'module_info'/0,\n\t\t\t\t 'module_info'/1,\n\t\t\t\t 'permit_application'/2,\n\t\t\t\t 'prep_config_change'/0,\n\t\t\t\t 'set_env'/3,\n\t\t\t\t 'set_env'/4,\n\t\t\t\t 'start'/1,\n\t\t\t\t 'start_application'/2,\n\t\t\t\t 'start_boot_application'/2,\n\t\t\t\t 'start_type'/1,\n\t\t\t\t 'stop_application'/1,\n\t\t\t\t 'terminate'/2,\n\t\t\t\t 'test_change_apps'/2,\n\t\t\t\t 'unload_application'/1,\n\t\t\t\t 'unset_env'/2,\n\t\t\t\t 'unset_env'/3,\n\t\t\t\t 'which_applications'/0,\n\t\t\t\t 'which_applications'/1]\n attributes [%% Line 1\n\t\t'file' =\n\t\t %% Line 1\n\t\t [{[97|[112|[112|[108|[105|[99|[97|[116|[105|[111|[110|[95|[99|[111|[110|[116|[114|[111|[108|[108|[101|[114|[46|[101|[114|[108]]]]]]]]]]]]]]]]]]]]]]]]]],1}],\n\t\t%% Line 1\n\t\t'file' =\n\t\t %% Line 1\n\t\t [{[97|[112|[112|[108|[105|[99|[97|[116|[105|[111|[110|[95|[109|[97|[115|[116|[101|[114|[46|[104|[114|[108]]]]]]]]]]]]]]]]]]]]]],1}],\n\t\t%% Line 20\n\t\t'record' =\n\t\t %% Line 20\n\t\t [{'appl_data',[{'record_field',20,{'atom',20,'name'}}|[{'record_field',20,{'atom',20,'regs'},{'nil',20}}|[{'record_field',20,{'atom',20,'phases'}}|[{'record_field',20,{'atom',20,'mod'}}|[{'record_field',20,{'atom',20,'mods'},{'nil',20}}|[{'record_field',21,{'atom',21,'inc_apps'}}|[{'record_field',21,{'atom',21,'maxP'},{'atom',21,'infinity'}}|[{'record_field',21,{'atom',21,'maxT'},{'atom',21,'infinity'}}]]]]]]]]}],\n\t\t%% Line 47\n\t\t'file' =\n\t\t %% Line 47\n\t\t [{[97|[112|[112|[108|[105|[99|[97|[116|[105|[111|[110|[95|[99|[111|[110|[116|[114|[111|[108|[108|[101|[114|[46|[101|[114|[108]]]]]]]]]]]]]]]]]]]]]]]]]],47}],\n\t\t%% Line 1\n\t\t'file' =\n\t\t %% Line 1\n\t\t [{[47|[104|[111|[109|[101|[47|[104|[97|[110|[115|[105|[104|[101|[47|[103|[105|[116|[47|[99|[111|[114|[101|[95|[101|[114|[108|[97|[110|[103|[47|[111|[116|[112|[47|[108|[105|[98|[47|[107|[101|[114|[110|[101|[108|[47|[115|[114|[99|[47|[46|[46|[47|[105|[110|[99|[108|[117|[100|[101|[47|[108|[111|[103|[103|[101|[114|[46|[104|[114|[108]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]],1}],\n\t\t%% Line 48\n\t\t'file' =\n\t\t %% Line 48\n\t\t [{[97|[112|[112|[108|[105|[99|[97|[116|[105|[111|[110|[95|[99|[111|[110|[116|[114|[111|[108|[108|[101|[114|[46|[101|[114|[108]]]]]]]]]]]]]]]]]]]]]]]]]],48}],\n\t\t%% Line 134\n\t\t'type' =\n\t\t %% Line 134\n\t\t [{'appname',{'type',134,'atom',[]},[]}],\n\t\t%% Line 136\n\t\t'record' =\n\t\t %% Line 136\n\t\t [{'state',[{'record_field',136,{'atom',136,'loading'},{'nil',136}}|[{'record_field',136,{'atom',136,'starting'},{'nil',136}}|[{'record_field',136,{'atom',136,'start_p_false'},{'nil',136}}|[{'record_field',136,{'atom',136,'running'},{'nil',136}}|[{'record_field',137,{'atom',137,'control'},{'nil',137}}|[{'record_field',137,{'atom',137,'started'},{'nil',137}}|[{'record_field',137,{'atom',137,'start_req'},{'nil',137}}|[{'record_field',137,{'atom',137,'conf_data'}}]]]]]]]]}],\n\t\t%% Line 138\n\t\t'type' =\n\t\t %% Line 138\n\t\t [{'state',{'type',138,'record',[{'atom',138,'state'}]},[]}],\n\t\t%% Line 158\n\t\t'record' =\n\t\t %% Line 158\n\t\t [{'appl',[{'record_field',158,{'atom',158,'name'}}|[{'record_field',158,{'atom',158,'appl_data'}}|[{'record_field',158,{'atom',158,'descr'}}|[{'record_field',158,{'atom',158,'id'}}|[{'record_field',158,{'atom',158,'vsn'}}|[{'record_field',158,{'atom',158,'restart_type'}}|[{'record_field',158,{'atom',158,'inc_apps'}}|[{'record_field',158,{'atom',158,'apps'}}]]]]]]]]}],\n\t\t%% Line 610\n\t\t'type' =\n\t\t %% Line 610\n\t\t [{'calls',{'type',610,'union',[{'atom',610,'info'}|[{'atom',610,'prep_config_change'}|[{'atom',610,'which_applications'}|[{'type',611,'tuple',[{'type',611,'union',[{'atom',611,'config_change'}|[{'atom',611,'control_application'}|[{'atom',612,'load_application'}|[{'atom',612,'start_type'}|[{'atom',612,'stop_application'}|[{'atom',613,'unload_application'}]]]]]]}|[{'type',613,'term',[]}]]}|[{'type',614,'tuple',[{'atom',614,'change_application_data'}|[{'var',614,'_'}|[{'var',614,'_'}]]]}|[{'type',615,'tuple',[{'atom',615,'permit_application'}|[{'type',615,'union',[{'type',615,'atom',[]}|[{'type',615,'tuple',[{'atom',615,'application'}|[{'type',615,'atom',[]}|[{'var',615,'_'}]]]}]]}|[{'var',615,'_'}]]]}|[{'type',616,'tuple',[{'atom',616,'start_application'}|[{'var',616,'_'}|[{'var',616,'_'}]]]}|[{'type',617,'tuple',[{'atom',617,'unset_env'}|[{'var',617,'_'}|[{'var',617,'_'}|[{'var',617,'_'}]]]]}|[{'type',618,'tuple',[{'atom',618,'set_env'}|[{'var',618,'_'}|[{'var',618,'_'}|[{'var',618,'_'}|[{'var',618,'_'}]]]]]}]]]]]]]]]},[]}],\n\t\t%% Line 620\n\t\t'spec' =\n\t\t %% Line 620\n\t\t [{{'handle_call',3},[{'type',620,'fun',[{'type',620,'product',[{'user_type',620,'calls',[]}|[{'type',620,'tuple',[{'type',620,'pid',[]}|[{'type',620,'term',[]}]]}|[{'user_type',620,'state',[]}]]]}|[{'type',621,'union',[{'type',621,'tuple',[{'atom',621,'noreply'}|[{'user_type',621,'state',[]}]]}|[{'type',621,'tuple',[{'atom',621,'reply'}|[{'type',621,'term',[]}|[{'user_type',621,'state',[]}]]]}]]}]]}]}],\n\t\t%% Line 915\n\t\t'spec' =\n\t\t %% Line 915\n\t\t [{{'handle_cast',2},[{'type',915,'fun',[{'type',915,'product',[{'type',915,'tuple',[{'atom',915,'application_started'}|[{'user_type',915,'appname',[]}|[{'var',915,'_'}]]]}|[{'user_type',915,'state',[]}]]}|[{'type',916,'union',[{'type',916,'tuple',[{'atom',916,'noreply'}|[{'user_type',916,'state',[]}]]}|[{'type',916,'tuple',[{'atom',916,'stop'}|[{'type',916,'string',[]}|[{'user_type',916,'state',[]}]]]}]]}]]}]}],\n\t\t%% Line 1005\n\t\t'spec' =\n\t\t %% Line 1005\n\t\t [{{'handle_info',2},[{'type',1005,'fun',[{'type',1005,'product',[{'type',1005,'term',[]}|[{'user_type',1005,'state',[]}]]}|[{'type',1006,'union',[{'type',1006,'tuple',[{'atom',1006,'noreply'}|[{'user_type',1006,'state',[]}]]}|[{'type',1006,'tuple',[{'atom',1006,'stop'}|[{'type',1006,'string',[]}|[{'user_type',1006,'state',[]}]]]}]]}]]}]}],\n\t\t%% Line 1182\n\t\t'spec' =\n\t\t %% Line 1182\n\t\t [{{'terminate',2},[{'type',1182,'fun',[{'type',1182,'product',[{'type',1182,'term',[]}|[{'user_type',1182,'state',[]}]]}|[{'atom',1182,'ok'}]]}]}],\n\t\t%% Line 1219\n\t\t'spec' =\n\t\t %% Line 1219\n\t\t [{{'code_change',3},[{'type',1219,'fun',[{'type',1219,'product',[{'type',1219,'term',[]}|[{'user_type',1219,'state',[]}|[{'type',1219,'term',[]}]]]}|[{'type',1219,'tuple',[{'atom',1219,'ok'}|[{'user_type',1219,'state',[]}]]}]]}]}],\n\t\t%% Line 2021\n\t\t'spec' =\n\t\t %% Line 2021\n\t\t [{{'to_string',1},[{'type',2021,'fun',[{'type',2021,'product',[{'type',2021,'term',[]}]}|[{'type',2021,'string',[]}]]}]}]]\n'start'/1 =\n %% Line 186\n fun (_0) ->\n\tlet =\n\t call %% Line 189\n\t\t 'erlang':%% Line 189\n\t\t\t 'self'\n\t\t()\n\tin let <_2> =\n\t\tfun () ->\n\t\t %% Line 190\n\t\t apply 'init'/2\n\t\t\t(Init, _0)\n\t in let =\n\t\t call %% Line 190\n\t\t\t 'erlang':%% Line 190\n\t\t\t\t 'spawn_link'\n\t\t\t(_2)\n\t\tin %% Line 191\n\t\t receive\n\t\t %% Line 192\n\t\t <{'ack',_5,'ok'}>\n\t\t\t when call 'erlang':'=:='\n\t\t\t\t(_5,\n\t\t\t\t AC) ->\n\t\t\t %% Line 193\n\t\t\t {'ok',AC}\n\t\t %% Line 194\n\t\t <{'ack',_6,{'error',Reason}}>\n\t\t\t when call 'erlang':'=:='\n\t\t\t\t(_6,\n\t\t\t\t AC) ->\n\t\t\t %% Line 195\n\t\t\t apply 'to_string'/1\n\t\t\t (Reason)\n\t\t %% Line 196\n\t\t <{'EXIT',_X_Pid,Reason}> when 'true' ->\n\t\t\t %% Line 197\n\t\t\t apply 'to_string'/1\n\t\t\t (Reason)\n\t\t after 'infinity' ->\n\t\t 'true'\n'load_application'/1 =\n %% Line 207\n fun (_0) ->\n\t%% Line 208\n\tcall 'gen_server':'call'\n\t ('application_controller', {'load_application',_0}, 'infinity')\n'unload_application'/1 =\n %% Line 210\n fun (_0) ->\n\t%% Line 211\n\tcall 'gen_server':'call'\n\t ('application_controller', {'unload_application',_0}, 'infinity')\n'start_application'/2 =\n %% Line 234\n fun (_1,_0) ->\n\t%% Line 235\n\tcall 'gen_server':'call'\n\t ('application_controller', {'start_application',_1,_0}, 'infinity')\n'start_boot_application'/2 =\n %% Line 244\n fun (_1,_0) ->\n\tlet <_2> =\n\t call %% Line 245\n\t\t 'application':%% Line 245\n\t\t\t 'load'\n\t\t(_1)\n\tin %% Line 245\n\t case <_2,_0> of\n\t %% Line 246\n\t <( 'ok'\n\t\t -| ['compiler_generated'] ),_10> when 'true' ->\n\t\t let =\n\t\t apply %% Line 247\n\t\t\t 'get_appl_name'/1\n\t\t\t (_1)\n\t\t in %% Line 248\n\t\t call 'gen_server':'call'\n\t\t\t ('application_controller', {'start_application',AppName,_0}, 'infinity')\n\t %% Line 249\n\t <( {( 'error'\n\t\t -| ['compiler_generated'] ),( {( 'already_loaded'\n\t\t\t\t\t\t -| ['compiler_generated'] ),AppName}\n\t\t\t\t\t\t -| ['compiler_generated'] )}\n\t\t -| ['compiler_generated'] ),_11> when 'true' ->\n\t\t %% Line 250\n\t\t call 'gen_server':'call'\n\t\t ('application_controller', {'start_application',AppName,_0}, 'infinity')\n\t %% Line 251\n\t <( {( 'error'\n\t\t -| ['compiler_generated'] ),( {( 'bad_environment_value'\n\t\t\t\t\t\t -| ['compiler_generated'] ),Env}\n\t\t\t\t\t\t -| ['compiler_generated'] )}\n\t\t -| ['compiler_generated'] ),( 'permanent'\n\t\t\t\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t let =\n\t\t call %% Line 252\n\t\t\t 'io_lib':%% Line 252\n\t\t\t\t 'format'\n\t\t\t (%% Line 252\n\t\t\t [66|[97|[100|[32|[101|[110|[118|[105|[114|[111|[110|[109|[101|[110|[116|[32|[118|[97|[114|[105|[97|[98|[108|[101|[58|[32|[126|[116|[112|[32|[32|[65|[112|[112|[108|[105|[99|[97|[116|[105|[111|[110|[58|[32|[126|[112]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]], %% Line 253\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t[Env|[_1|[]]])\n\t\t in let <_5> =\n\t\t\t call %% Line 254\n\t\t\t 'lists':%% Line 254\n\t\t\t\t 'flatten'\n\t\t\t (%% Line 254\n\t\t\t Txt)\n\t\t in let <_6> =\n\t\t\t call %% Line 254\n\t\t\t\t 'erlang':%% Line 254\n\t\t\t\t\t 'list_to_atom'\n\t\t\t\t (_5)\n\t\t\t in %% Line 254\n\t\t\t call 'erlang':'exit'\n\t\t\t\t ({'error',_6})\n\t %% Line 255\n\t when 'true' ->\n\t\t %% Line 256\n\t\t Error\n\t end\n'stop_application'/1 =\n %% Line 259\n fun (_0) ->\n\t%% Line 260\n\tcall 'gen_server':'call'\n\t ('application_controller', {'stop_application',_0}, 'infinity')\n'which_applications'/0 =\n %% Line 265\n fun () ->\n\t%% Line 266\n\tcall 'gen_server':'call'\n\t ('application_controller', 'which_applications')\n'which_applications'/1 =\n %% Line 267\n fun (_0) ->\n\t%% Line 268\n\tcall 'gen_server':'call'\n\t ('application_controller', 'which_applications', _0)\n'loaded_applications'/0 =\n %% Line 270\n fun () ->\n\tlet <_2> =\n\t fun (_0) ->\n\t\t%% Line 272\n\t\tcase _0 of\n\t\t <[{{'loaded',AppName},{'appl',_3,_4,Descr,_5,Vsn,_6,_7,_8}}|[]]> when 'true' ->\n\t\t %% Line 273\n\t\t {'true',{AppName,Descr,Vsn}}\n\t\t %% Line 274\n\t\t <_9> when 'true' ->\n\t\t %% Line 275\n\t\t 'false'\n\t\tend\n\tin %% Line 271\n\t call 'ets':'filter'\n\t\t('ac_tab', _2, %% Line 277\n\t\t\t [])\n'info'/0 =\n %% Line 280\n fun () ->\n\t%% Line 281\n\tcall 'gen_server':'call'\n\t ('application_controller', 'info')\n'control_application'/1 =\n %% Line 283\n fun (_0) ->\n\t%% Line 284\n\tcall 'gen_server':'call'\n\t ('application_controller', {'control_application',_0}, 'infinity')\n'change_application_data'/2 =\n %% Line 308\n fun (_1,_0) ->\n\t%% Line 309\n\tcall 'gen_server':'call'\n\t ('application_controller', %% Line 310\n\t\t\t\t {'change_application_data',_1,_0}, %% Line 311\n\t\t\t\t\t\t\t\t\t 'infinity')\n'prep_config_change'/0 =\n %% Line 313\n fun () ->\n\t%% Line 314\n\tcall 'gen_server':'call'\n\t ('application_controller', %% Line 315\n\t\t\t\t 'prep_config_change', %% Line 316\n\t\t\t\t\t\t\t 'infinity')\n'config_change'/1 =\n %% Line 319\n fun (_0) ->\n\t%% Line 320\n\tcall 'gen_server':'call'\n\t ('application_controller', %% Line 321\n\t\t\t\t {'config_change',_0}, %% Line 322\n\t\t\t\t\t\t\t 'infinity')\n'get_pid_env'/2 =\n %% Line 326\n fun (_1,_0) ->\n\t%% Line 327\n\tcase call 'ets':'match'\n\t\t ('ac_tab', {{'application_master','$1'},_1}) of\n\t %% Line 328\n\t <[[AppName|[]]|[]]> when 'true' ->\n\t apply 'get_env'/2\n\t\t (AppName, _0)\n\t %% Line 329\n\t <_5> when 'true' ->\n\t 'undefined'\n\tend\n'get_env'/2 =\n %% Line 332\n fun (_1,_0) ->\n\t%% Line 333\n\tcase call 'ets':'lookup'\n\t\t ('ac_tab', {'env',_1,_0}) of\n\t %% Line 334\n\t <[{_5,Val}|[]]> when 'true' ->\n\t {'ok',Val}\n\t %% Line 335\n\t <_6> when 'true' ->\n\t 'undefined'\n\tend\n'get_pid_all_env'/1 =\n %% Line 338\n fun (_0) ->\n\t%% Line 339\n\tcase call 'ets':'match'\n\t\t ('ac_tab', {{'application_master','$1'},_0}) of\n\t %% Line 340\n\t <[[AppName|[]]|[]]> when 'true' ->\n\t apply 'get_all_env'/1\n\t\t (AppName)\n\t %% Line 341\n\t <_3> when 'true' ->\n\t []\n\tend\n'get_all_env'/1 =\n %% Line 344\n fun (_0) ->\n\tlet <_4> =\n\t fun (_2) ->\n\t\t%% Line 345\n\t\tcase _2 of\n\t\t <[Key|[Val|[]]]> when 'true' ->\n\t\t {Key,Val}\n\t\t ( <_3> when 'true' ->\n\t\t\t( primop 'match_fail'\n\t\t\t ({'function_clause',_3})\n\t\t\t -| [{'function_name',{'-get_all_env/1-fun-0-',1}}] )\n\t\t -| ['compiler_generated'] )\n\t\tend\n\tin let <_1> =\n\t\tcall %% Line 346\n\t\t 'ets':%% Line 346\n\t\t\t 'match'\n\t\t (%% Line 346\n\t\t 'ac_tab', %% Line 346\n\t\t\t {{'env',_0,'$1'},'$2'})\n\t in %% Line 345\n\t\tcall 'lists':'map'\n\t\t (_4, _1)\n'get_pid_key'/2 =\n %% Line 351\n fun (_1,_0) ->\n\t%% Line 352\n\tcase call 'ets':'match'\n\t\t ('ac_tab', {{'application_master','$1'},_1}) of\n\t %% Line 353\n\t <[[AppName|[]]|[]]> when 'true' ->\n\t apply 'get_key'/2\n\t\t (AppName, _0)\n\t %% Line 354\n\t <_5> when 'true' ->\n\t 'undefined'\n\tend\n'get_key'/2 =\n %% Line 357\n fun (_1,_0) ->\n\t%% Line 358\n\tcase call 'ets':'lookup'\n\t\t ('ac_tab', {'loaded',_1}) of\n\t %% Line 359\n\t <[{_41,Appl}|[]]> when 'true' ->\n\t %% Line 360\n\t case _0 of\n\t\t%% Line 361\n\t\t<'description'> when 'true' ->\n\t\t %% Line 362\n\t\t ( case Appl of\n\t\t\t( <( {'appl',_42,_43,_rec0,_44,_45,_46,_47,_48}\n\t\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\t {'ok',_rec0}\n\t\t\t -| ['compiler_generated'] )\n\t\t\t( <_49> when 'true' ->\n\t\t\t ( call ( 'erlang'\n\t\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t (( {'badrecord','appl'}\n\t\t\t\t -| ['compiler_generated'] ))\n\t\t\t\t-| ['compiler_generated'] )\n\t\t\t -| ['compiler_generated'] )\n\t\t end\n\t\t -| ['compiler_generated'] )\n\t\t%% Line 363\n\t\t<'id'> when 'true' ->\n\t\t %% Line 364\n\t\t ( case Appl of\n\t\t\t( <( {'appl',_50,_51,_52,_rec1,_53,_54,_55,_56}\n\t\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\t {'ok',_rec1}\n\t\t\t -| ['compiler_generated'] )\n\t\t\t( <_57> when 'true' ->\n\t\t\t ( call ( 'erlang'\n\t\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t (( {'badrecord','appl'}\n\t\t\t\t -| ['compiler_generated'] ))\n\t\t\t\t-| ['compiler_generated'] )\n\t\t\t -| ['compiler_generated'] )\n\t\t end\n\t\t -| ['compiler_generated'] )\n\t\t%% Line 365\n\t\t<'vsn'> when 'true' ->\n\t\t %% Line 366\n\t\t ( case Appl of\n\t\t\t( <( {'appl',_58,_59,_60,_61,_rec2,_62,_63,_64}\n\t\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\t {'ok',_rec2}\n\t\t\t -| ['compiler_generated'] )\n\t\t\t( <_65> when 'true' ->\n\t\t\t ( call ( 'erlang'\n\t\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t (( {'badrecord','appl'}\n\t\t\t\t -| ['compiler_generated'] ))\n\t\t\t\t-| ['compiler_generated'] )\n\t\t\t -| ['compiler_generated'] )\n\t\t end\n\t\t -| ['compiler_generated'] )\n\t\t%% Line 367\n\t\t<'modules'> when 'true' ->\n\t\t %% Line 368\n\t\t ( case Appl of\n\t\t\t( <( {'appl',_66,_rec4,_67,_68,_69,_70,_71,_72}\n\t\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\t ( case _rec4 of\n\t\t\t\t ( <( {'appl_data',_74,_75,_76,_77,_rec3,_78,_79,_80}\n\t\t\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\t\t\t{'ok',_rec3}\n\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t ( <_81> when 'true' ->\n\t\t\t\t\t( call ( 'erlang'\n\t\t\t\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t (( {'badrecord','appl_data'}\n\t\t\t\t\t\t -| ['compiler_generated'] ))\n\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\tend\n\t\t\t\t-| ['compiler_generated'] )\n\t\t\t -| ['compiler_generated'] )\n\t\t\t( <_73> when 'true' ->\n\t\t\t ( call ( 'erlang'\n\t\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t (( {'badrecord','appl'}\n\t\t\t\t -| ['compiler_generated'] ))\n\t\t\t\t-| ['compiler_generated'] )\n\t\t\t -| ['compiler_generated'] )\n\t\t end\n\t\t -| ['compiler_generated'] )\n\t\t%% Line 369\n\t\t<'maxP'> when 'true' ->\n\t\t %% Line 370\n\t\t ( case Appl of\n\t\t\t( <( {'appl',_82,_rec6,_83,_84,_85,_86,_87,_88}\n\t\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\t ( case _rec6 of\n\t\t\t\t ( <( {'appl_data',_90,_91,_92,_93,_94,_95,_rec5,_96}\n\t\t\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\t\t\t{'ok',_rec5}\n\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t ( <_97> when 'true' ->\n\t\t\t\t\t( call ( 'erlang'\n\t\t\t\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t (( {'badrecord','appl_data'}\n\t\t\t\t\t\t -| ['compiler_generated'] ))\n\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\tend\n\t\t\t\t-| ['compiler_generated'] )\n\t\t\t -| ['compiler_generated'] )\n\t\t\t( <_89> when 'true' ->\n\t\t\t ( call ( 'erlang'\n\t\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t (( {'badrecord','appl'}\n\t\t\t\t -| ['compiler_generated'] ))\n\t\t\t\t-| ['compiler_generated'] )\n\t\t\t -| ['compiler_generated'] )\n\t\t end\n\t\t -| ['compiler_generated'] )\n\t\t%% Line 371\n\t\t<'maxT'> when 'true' ->\n\t\t %% Line 372\n\t\t ( case Appl of\n\t\t\t( <( {'appl',_98,_rec8,_99,_100,_101,_102,_103,_104}\n\t\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\t ( case _rec8 of\n\t\t\t\t ( <( {'appl_data',_106,_107,_108,_109,_110,_111,_112,_rec7}\n\t\t\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\t\t\t{'ok',_rec7}\n\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t ( <_113> when 'true' ->\n\t\t\t\t\t( call ( 'erlang'\n\t\t\t\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t (( {'badrecord','appl_data'}\n\t\t\t\t\t\t -| ['compiler_generated'] ))\n\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\tend\n\t\t\t\t-| ['compiler_generated'] )\n\t\t\t -| ['compiler_generated'] )\n\t\t\t( <_105> when 'true' ->\n\t\t\t ( call ( 'erlang'\n\t\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t (( {'badrecord','appl'}\n\t\t\t\t -| ['compiler_generated'] ))\n\t\t\t\t-| ['compiler_generated'] )\n\t\t\t -| ['compiler_generated'] )\n\t\t end\n\t\t -| ['compiler_generated'] )\n\t\t%% Line 373\n\t\t<'registered'> when 'true' ->\n\t\t %% Line 374\n\t\t ( case Appl of\n\t\t\t( <( {'appl',_114,_rec10,_115,_116,_117,_118,_119,_120}\n\t\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\t ( case _rec10 of\n\t\t\t\t ( <( {'appl_data',_122,_rec9,_123,_124,_125,_126,_127,_128}\n\t\t\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\t\t\t{'ok',_rec9}\n\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t ( <_129> when 'true' ->\n\t\t\t\t\t( call ( 'erlang'\n\t\t\t\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t (( {'badrecord','appl_data'}\n\t\t\t\t\t\t -| ['compiler_generated'] ))\n\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\tend\n\t\t\t\t-| ['compiler_generated'] )\n\t\t\t -| ['compiler_generated'] )\n\t\t\t( <_121> when 'true' ->\n\t\t\t ( call ( 'erlang'\n\t\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t (( {'badrecord','appl'}\n\t\t\t\t -| ['compiler_generated'] ))\n\t\t\t\t-| ['compiler_generated'] )\n\t\t\t -| ['compiler_generated'] )\n\t\t end\n\t\t -| ['compiler_generated'] )\n\t\t%% Line 375\n\t\t<'included_applications'> when 'true' ->\n\t\t %% Line 376\n\t\t ( case Appl of\n\t\t\t( <( {'appl',_130,_131,_132,_133,_134,_135,_rec11,_136}\n\t\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\t {'ok',_rec11}\n\t\t\t -| ['compiler_generated'] )\n\t\t\t( <_137> when 'true' ->\n\t\t\t ( call ( 'erlang'\n\t\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t (( {'badrecord','appl'}\n\t\t\t\t -| ['compiler_generated'] ))\n\t\t\t\t-| ['compiler_generated'] )\n\t\t\t -| ['compiler_generated'] )\n\t\t end\n\t\t -| ['compiler_generated'] )\n\t\t%% Line 377\n\t\t<'applications'> when 'true' ->\n\t\t %% Line 378\n\t\t ( case Appl of\n\t\t\t( <( {'appl',_138,_139,_140,_141,_142,_143,_144,_rec12}\n\t\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\t {'ok',_rec12}\n\t\t\t -| ['compiler_generated'] )\n\t\t\t( <_145> when 'true' ->\n\t\t\t ( call ( 'erlang'\n\t\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t (( {'badrecord','appl'}\n\t\t\t\t -| ['compiler_generated'] ))\n\t\t\t\t-| ['compiler_generated'] )\n\t\t\t -| ['compiler_generated'] )\n\t\t end\n\t\t -| ['compiler_generated'] )\n\t\t%% Line 379\n\t\t<'env'> when 'true' ->\n\t\t let <_28> =\n\t\t\tapply %% Line 380\n\t\t\t 'get_all_env'/1\n\t\t\t (_1)\n\t\t in %% Line 380\n\t\t\t{'ok',_28}\n\t\t%% Line 381\n\t\t<'mod'> when 'true' ->\n\t\t %% Line 382\n\t\t ( case Appl of\n\t\t\t( <( {'appl',_146,_rec14,_147,_148,_149,_150,_151,_152}\n\t\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\t ( case _rec14 of\n\t\t\t\t ( <( {'appl_data',_154,_155,_156,_rec13,_157,_158,_159,_160}\n\t\t\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\t\t\t{'ok',_rec13}\n\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t ( <_161> when 'true' ->\n\t\t\t\t\t( call ( 'erlang'\n\t\t\t\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t (( {'badrecord','appl_data'}\n\t\t\t\t\t\t -| ['compiler_generated'] ))\n\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\tend\n\t\t\t\t-| ['compiler_generated'] )\n\t\t\t -| ['compiler_generated'] )\n\t\t\t( <_153> when 'true' ->\n\t\t\t ( call ( 'erlang'\n\t\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t (( {'badrecord','appl'}\n\t\t\t\t -| ['compiler_generated'] ))\n\t\t\t\t-| ['compiler_generated'] )\n\t\t\t -| ['compiler_generated'] )\n\t\t end\n\t\t -| ['compiler_generated'] )\n\t\t%% Line 383\n\t\t<'start_phases'> when 'true' ->\n\t\t %% Line 384\n\t\t ( case Appl of\n\t\t\t( <( {'appl',_162,_rec16,_163,_164,_165,_166,_167,_168}\n\t\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\t ( case _rec16 of\n\t\t\t\t ( <( {'appl_data',_170,_171,_rec15,_172,_173,_174,_175,_176}\n\t\t\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\t\t\t{'ok',_rec15}\n\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t ( <_177> when 'true' ->\n\t\t\t\t\t( call ( 'erlang'\n\t\t\t\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t (( {'badrecord','appl_data'}\n\t\t\t\t\t\t -| ['compiler_generated'] ))\n\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\tend\n\t\t\t\t-| ['compiler_generated'] )\n\t\t\t -| ['compiler_generated'] )\n\t\t\t( <_169> when 'true' ->\n\t\t\t ( call ( 'erlang'\n\t\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t (( {'badrecord','appl'}\n\t\t\t\t -| ['compiler_generated'] ))\n\t\t\t\t-| ['compiler_generated'] )\n\t\t\t -| ['compiler_generated'] )\n\t\t end\n\t\t -| ['compiler_generated'] )\n\t\t%% Line 385\n\t\t<_178> when 'true' ->\n\t\t 'undefined'\n\t end\n\t %% Line 387\n\t <_179> when 'true' ->\n\t %% Line 388\n\t 'undefined'\n\tend\n'get_pid_all_key'/1 =\n %% Line 391\n fun (_0) ->\n\t%% Line 392\n\tcase call 'ets':'match'\n\t\t ('ac_tab', {{'application_master','$1'},_0}) of\n\t %% Line 393\n\t <[[AppName|[]]|[]]> when 'true' ->\n\t apply 'get_all_key'/1\n\t\t (AppName)\n\t %% Line 394\n\t <_3> when 'true' ->\n\t []\n\tend\n'get_all_key'/1 =\n %% Line 397\n fun (_0) ->\n\t%% Line 398\n\tcase call 'ets':'lookup'\n\t\t ('ac_tab', {'loaded',_0}) of\n\t %% Line 399\n\t <[{_38,Appl}|[]]> when 'true' ->\n\t %% Line 400\n\t ( case Appl of\n\t\t ( <( {'appl',_39,_40,_rec17,_41,_42,_43,_44,_45}\n\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\t%% Line 403\n\t\t\t( case _40 of\n\t\t\t ( <( {'appl_data',_71,_72,_73,_74,_rec20,_75,_76,_77}\n\t\t\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\t\t let <_27> =\n\t\t\t\t apply %% Line 409\n\t\t\t\t\t 'get_all_env'/1\n\t\t\t\t\t (_0)\n\t\t\t\t in {'ok',[{'description',_rec17}|[{'id',_41}|[{'vsn',_42}|[{'modules',_rec20}|%% Line 404\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t [{'maxP',_76}|%% Line 405\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t [{'maxT',_77}|%% Line 406\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t [{'registered',_72}|%% Line 407\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t [{'included_applications',_44}|%% Line 408\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t[{'applications',_45}|%% Line 409\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t [{'env',_27}|%% Line 410\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t [{'mod',_74}|%% Line 411\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t[{'start_phases',_73}|%% Line 412\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t []]]]]]]]]]]]]}\n\t\t\t -| ['compiler_generated'] )\n\t\t\t ( <_78> when 'true' ->\n\t\t\t\t ( call ( 'erlang'\n\t\t\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t(( {'badrecord','appl_data'}\n\t\t\t\t\t -| ['compiler_generated'] ))\n\t\t\t\t -| ['compiler_generated'] )\n\t\t\t -| ['compiler_generated'] )\n\t\t\t end\n\t\t\t -| ['compiler_generated'] )\n\t\t -| ['compiler_generated'] )\n\t\t ( <_46> when 'true' ->\n\t\t\t( call ( 'erlang'\n\t\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t (( {'badrecord','appl'}\n\t\t\t\t -| ['compiler_generated'] ))\n\t\t\t -| ['compiler_generated'] )\n\t\t -| ['compiler_generated'] )\n\t\tend\n\t\t-| ['compiler_generated'] )\n\t %% Line 413\n\t <_175> when 'true' ->\n\t %% Line 414\n\t 'undefined'\n\tend\n'start_type'/1 =\n %% Line 418\n fun (_0) ->\n\t%% Line 419\n\tcase call 'ets':'match'\n\t\t ('ac_tab', {{'application_master','$1'},_0}) of\n\t %% Line 420\n\t <[[AppName|[]]|[]]> when 'true' ->\n\t %% Line 421\n\t call 'gen_server':'call'\n\t\t ('application_controller', {'start_type',AppName}, 'infinity')\n\t %% Line 422\n\t <_X_X> when 'true' ->\n\t %% Line 423\n\t 'undefined'\n\tend\n'get_master'/1 =\n %% Line 431\n fun (_0) ->\n\t%% Line 432\n\tcase call 'ets':'lookup'\n\t\t ('ac_tab', {'application_master',_0}) of\n\t %% Line 433\n\t <[{_3,Pid}|[]]> when 'true' ->\n\t Pid\n\t %% Line 434\n\t <_4> when 'true' ->\n\t 'undefined'\n\tend\n'get_application'/1 =\n %% Line 437\n fun (_0) ->\n\t%% Line 438\n\tcase call 'ets':'match'\n\t\t ('ac_tab', {{'application_master','$1'},_0}) of\n\t %% Line 439\n\t <[[AppName|[]]|[]]> when 'true' ->\n\t {'ok',AppName}\n\t %% Line 440\n\t <_3> when 'true' ->\n\t 'undefined'\n\tend\n'get_application_module'/1 =\n %% Line 443\n fun (_0) ->\n\tlet =\n\t call %% Line 446\n\t\t 'ets':%% Line 446\n\t\t 'match'\n\t\t(%% Line 446\n\t\t 'ac_tab', %% Line 446\n\t\t\t {{'loaded','$1'},{'appl','_',{'appl_data','_','_','_','_','$2','_','_','_'},'_','_','_','_','_','_'}})\n\tin %% Line 447\n\t apply 'get_application_module'/2\n\t\t(_0, AppModules)\n'get_application_module'/2 =\n %% Line 449\n fun (_1,_0) ->\n\tcase <_1,_0> of\n\t when 'true' ->\n\t %% Line 450\n\t case call 'lists':'member'\n\t\t (Module, Modules) of\n\t\t%% Line 451\n\t\t<'true'> when 'true' ->\n\t\t %% Line 452\n\t\t {'ok',AppName}\n\t\t%% Line 453\n\t\t<'false'> when 'true' ->\n\t\t %% Line 454\n\t\t apply 'get_application_module'/2\n\t\t\t(Module, AppModules)\n\t\t( <_2> when 'true' ->\n\t\t primop 'match_fail'\n\t\t\t ({'case_clause',_2})\n\t\t -| ['compiler_generated'] )\n\t end\n\t %% Line 456\n\t <_X_Module,[]> when 'true' ->\n\t %% Line 457\n\t 'undefined'\n\t ( <_4,_3> when 'true' ->\n\t\t( primop 'match_fail'\n\t\t ({'function_clause',_4,_3})\n\t\t -| [{'function_name',{'get_application_module',2}}] )\n\t -| ['compiler_generated'] )\n\tend\n'permit_application'/2 =\n %% Line 459\n fun (_1,_0) ->\n\t%% Line 460\n\tcall 'gen_server':'call'\n\t ('application_controller', %% Line 461\n\t\t\t\t {'permit_application',_1,_0}, %% Line 462\n\t\t\t\t\t\t\t\t 'infinity')\n'set_env'/3 =\n %% Line 465\n fun (_2,_1,_0) ->\n\t%% Line 466\n\tcall 'gen_server':'call'\n\t ('application_controller', {'set_env',_2,_1,_0,[]})\n'set_env'/4 =\n %% Line 467\n fun (_3,_2,_1,_0) ->\n\tlet =\n\t call %% Line 468\n\t\t 'proplists':%% Line 468\n\t\t\t 'get_value'\n\t\t(%% Line 468\n\t\t 'timeout', _0, %% Line 468\n\t\t\t\t5000)\n\tin %% Line 469\n\t call 'gen_server':'call'\n\t\t('application_controller', {'set_env',_3,_2,_1,_0}, Timeout)\n'unset_env'/2 =\n %% Line 471\n fun (_1,_0) ->\n\t%% Line 472\n\tcall 'gen_server':'call'\n\t ('application_controller', {'unset_env',_1,_0,[]})\n'unset_env'/3 =\n %% Line 473\n fun (_2,_1,_0) ->\n\tlet =\n\t call %% Line 474\n\t\t 'proplists':%% Line 474\n\t\t\t 'get_value'\n\t\t(%% Line 474\n\t\t 'timeout', _0, %% Line 474\n\t\t\t\t5000)\n\tin %% Line 475\n\t call 'gen_server':'call'\n\t\t('application_controller', {'unset_env',_2,_1,_0}, Timeout)\n'init'/2 =\n %% Line 480\n fun (_1,_0) ->\n\tlet <_2> =\n\t call %% Line 481\n\t\t 'erlang':%% Line 481\n\t\t\t 'self'\n\t\t()\n\tin do %% Line 481\n\t\tcall 'erlang':'register'\n\t\t ('application_controller', _2)\n\t\tdo %% Line 482\n\t\t call 'erlang':'process_flag'\n\t\t\t('trap_exit', 'true')\n\t\t do %% Line 483\n\t\t\tcall 'erlang':'put'\n\t\t\t ('$ancestors', [_1|[]])\n\t\t\tdo %% Line 484\n\t\t\t call 'erlang':'put'\n\t\t\t\t('$initial_call', {'application_controller','start',1})\n\t\t\t let <_3> =\n\t\t\t\tcatch\n\t\t\t\t %% Line 486\n\t\t\t\t apply 'check_conf'/0\n\t\t\t\t\t()\n\t\t\t in %% Line 486\n\t\t\t\tcase _3 of\n\t\t\t\t %% Line 487\n\t\t\t\t <{'ok',ConfData}> when 'true' ->\n\t\t\t\t %% Line 493\n\t\t\t\t case apply 'check_conf_data'/1\n\t\t\t\t\t (ConfData) of\n\t\t\t\t\t%% Line 494\n\t\t\t\t\t<'ok'> when 'true' ->\n\t\t\t\t\t do %% Line 495\n\t\t\t\t\t\t( call ( 'ets'\n\t\t\t\t\t\t\t -| ['result_not_wanted'] ):( 'new'\n\t\t\t\t\t\t\t\t\t\t -| ['result_not_wanted'] )\n\t\t\t\t\t\t (( 'ac_tab'\n\t\t\t\t\t\t\t -| ['result_not_wanted'] ), ( ['set'|['public'|['named_table'|[{'read_concurrency','true'}]]]]\n\t\t\t\t\t\t\t\t\t\t -| ['result_not_wanted'] ))\n\t\t\t\t\t\t -| ['result_not_wanted'] )\n\t\t\t\t\t\tlet =\n\t\t\t\t\t\t {%% Line 497\n\t\t\t\t\t\t 'state',[],[],[],[],[],[],[],%% Line 497\n\t\t\t\t\t\t\t\t\t\t ConfData}\n\t\t\t\t\t\tin %% Line 498\n\t\t\t\t\t\t case apply 'make_appl'/1\n\t\t\t\t\t\t\t (_0) of\n\t\t\t\t\t\t <{'ok',KAppl}> when 'true' ->\n\t\t\t\t\t\t\t let <_7> =\n\t\t\t\t\t\t\t catch\n\t\t\t\t\t\t\t\t %% Line 499\n\t\t\t\t\t\t\t\t apply 'load'/2\n\t\t\t\t\t\t\t\t (S, KAppl)\n\t\t\t\t\t\t\t in %% Line 499\n\t\t\t\t\t\t\t case _7 of\n\t\t\t\t\t\t\t\t%% Line 500\n\t\t\t\t\t\t\t\t<{'EXIT',LoadError}> when 'true' ->\n\t\t\t\t\t\t\t\t let = {%% Line 501\n\t\t\t\t\t\t\t\t\t 'load error',%% Line 501\n\t\t\t\t\t\t\t\t\t\t LoadError}\n\t\t\t\t\t\t\t\t in let <_10> =\n\t\t\t\t\t\t\t\t\t call %% Line 502\n\t\t\t\t\t\t\t\t\t\t 'erlang':%% Line 502\n\t\t\t\t\t\t\t\t\t\t\t 'self'\n\t\t\t\t\t\t\t\t\t\t()\n\t\t\t\t\t\t\t\t\tin let <_9> =\n\t\t\t\t\t\t\t\t\t\tapply %% Line 502\n\t\t\t\t\t\t\t\t\t\t 'to_string'/1\n\t\t\t\t\t\t\t\t\t\t (%% Line 502\n\t\t\t\t\t\t\t\t\t\t Reason)\n\t\t\t\t\t\t\t\t\t in %% Line 502\n\t\t\t\t\t\t\t\t\t\tcall 'erlang':'!'\n\t\t\t\t\t\t\t\t\t\t (_1, {'ack',_10,{'error',_9}})\n\t\t\t\t\t\t\t\t%% Line 503\n\t\t\t\t\t\t\t\t<{'error',Error}> when 'true' ->\n\t\t\t\t\t\t\t\t let <_12> =\n\t\t\t\t\t\t\t\t\tcall %% Line 504\n\t\t\t\t\t\t\t\t\t 'erlang':%% Line 504\n\t\t\t\t\t\t\t\t\t\t 'self'\n\t\t\t\t\t\t\t\t\t ()\n\t\t\t\t\t\t\t\t in let <_11> =\n\t\t\t\t\t\t\t\t\t apply %% Line 504\n\t\t\t\t\t\t\t\t\t\t 'to_string'/1\n\t\t\t\t\t\t\t\t\t\t(%% Line 504\n\t\t\t\t\t\t\t\t\t\t Error)\n\t\t\t\t\t\t\t\t\tin %% Line 504\n\t\t\t\t\t\t\t\t\t call 'erlang':'!'\n\t\t\t\t\t\t\t\t\t\t(_1, {'ack',_12,{'error',_11}})\n\t\t\t\t\t\t\t\t%% Line 505\n\t\t\t\t\t\t\t\t<{'ok',NewS}> when 'true' ->\n\t\t\t\t\t\t\t\t let <_13> =\n\t\t\t\t\t\t\t\t\tcall %% Line 506\n\t\t\t\t\t\t\t\t\t 'erlang':%% Line 506\n\t\t\t\t\t\t\t\t\t\t 'self'\n\t\t\t\t\t\t\t\t\t ()\n\t\t\t\t\t\t\t\t in do %% Line 506\n\t\t\t\t\t\t\t\t\t call 'erlang':'!'\n\t\t\t\t\t\t\t\t\t\t(_1, {'ack',_13,'ok'})\n\t\t\t\t\t\t\t\t\t %% Line 507\n\t\t\t\t\t\t\t\t\t call 'gen_server':'enter_loop'\n\t\t\t\t\t\t\t\t\t\t('application_controller', [], NewS, %% Line 508\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t {'local','application_controller'})\n\t\t\t\t\t\t\t\t( <_14> when 'true' ->\n\t\t\t\t\t\t\t\t primop 'match_fail'\n\t\t\t\t\t\t\t\t\t ({'case_clause',_14})\n\t\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t\t\t end\n\t\t\t\t\t\t ( <_6> when 'true' ->\n\t\t\t\t\t\t\t primop 'match_fail'\n\t\t\t\t\t\t\t\t({'badmatch',_6})\n\t\t\t\t\t\t\t-| ['compiler_generated'] )\n\t\t\t\t\t\t end\n\t\t\t\t\t%% Line 510\n\t\t\t\t\t<{'error',ErrorStr}> when 'true' ->\n\t\t\t\t\t let <_15> =\n\t\t\t\t\t\tcall %% Line 511\n\t\t\t\t\t\t 'io_lib':%% Line 511\n\t\t\t\t\t\t\t 'format'\n\t\t\t\t\t\t (%% Line 511\n\t\t\t\t\t\t [105|[110|[118|[97|[108|[105|[100|[32|[99|[111|[110|[102|[105|[103|[32|[100|[97|[116|[97|[58|[32|[126|[116|[115]]]]]]]]]]]]]]]]]]]]]]]], %% Line 511\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t [ErrorStr|[]])\n\t\t\t\t\t in let =\n\t\t\t\t\t\t call %% Line 511\n\t\t\t\t\t\t\t 'lists':%% Line 511\n\t\t\t\t\t\t\t\t 'flatten'\n\t\t\t\t\t\t\t(_15)\n\t\t\t\t\t\tin let <_18> =\n\t\t\t\t\t\t\tcall %% Line 512\n\t\t\t\t\t\t\t 'erlang':%% Line 512\n\t\t\t\t\t\t\t\t 'self'\n\t\t\t\t\t\t\t ()\n\t\t\t\t\t\t in let <_17> =\n\t\t\t\t\t\t\t apply %% Line 512\n\t\t\t\t\t\t\t\t 'to_string'/1\n\t\t\t\t\t\t\t\t(%% Line 512\n\t\t\t\t\t\t\t\t Str)\n\t\t\t\t\t\t\tin %% Line 512\n\t\t\t\t\t\t\t call 'erlang':'!'\n\t\t\t\t\t\t\t\t(_1, {'ack',_18,{'error',_17}})\n\t\t\t\t\t( <_19> when 'true' ->\n\t\t\t\t\t primop 'match_fail'\n\t\t\t\t\t\t ({'case_clause',_19})\n\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t end\n\t\t\t\t %% Line 514\n\t\t\t\t <{'error',{File,Line,Str}}> when 'true' ->\n\t\t\t\t let <_20> =\n\t\t\t\t\t call %% Line 516\n\t\t\t\t\t 'io_lib':%% Line 516\n\t\t\t\t\t\t\t'format'\n\t\t\t\t\t (%% Line 516\n\t\t\t\t\t [101|[114|[114|[111|[114|[32|[105|[110|[32|[99|[111|[110|[102|[105|[103|[32|[102|[105|[108|[101|[32|[126|[116|[112|[32|[40|[126|[119|[41|[58|[32|[126|[116|[115]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]], %% Line 518\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t [File|[Line|[Str|[]]]])\n\t\t\t\t in let =\n\t\t\t\t\t call %% Line 516\n\t\t\t\t\t\t 'lists':%% Line 516\n\t\t\t\t\t\t\t 'flatten'\n\t\t\t\t\t\t (_20)\n\t\t\t\t\t in let <_23> =\n\t\t\t\t\t\t call %% Line 519\n\t\t\t\t\t\t 'erlang':%% Line 519\n\t\t\t\t\t\t\t\t'self'\n\t\t\t\t\t\t ()\n\t\t\t\t\t in let <_22> =\n\t\t\t\t\t\t apply %% Line 519\n\t\t\t\t\t\t\t 'to_string'/1\n\t\t\t\t\t\t\t (%% Line 519\n\t\t\t\t\t\t\t ReasonStr)\n\t\t\t\t\t\t in %% Line 519\n\t\t\t\t\t\t call 'erlang':'!'\n\t\t\t\t\t\t\t (_1, {'ack',_23,{'error',_22}})\n\t\t\t\t ( <_24> when 'true' ->\n\t\t\t\t\tprimop 'match_fail'\n\t\t\t\t\t ({'case_clause',_24})\n\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\tend\n'check_conf_data'/1 =\n %% Line 526\n fun (_0) ->\n\tcase _0 of\n\t <[]> when 'true' ->\n\t %% Line 527\n\t 'ok'\n\t %% Line 528\n\t \n\t when call 'erlang':'is_list'\n\t\t (_0) ->\n\t %% Line 529\n\t case ConfData of\n\t\t<[Application|ConfDataRem]> when 'true' ->\n\t\t %% Line 530\n\t\t case Application of\n\t\t %% Line 531\n\t\t <{'kernel',List}>\n\t\t\t when call 'erlang':'is_list'\n\t\t\t\t(List) ->\n\t\t\t %% Line 532\n\t\t\t case apply 'check_para_kernel'/1\n\t\t\t\t (List) of\n\t\t\t %% Line 533\n\t\t\t <'ok'> when 'true' ->\n\t\t\t\t%% Line 534\n\t\t\t\tapply 'check_conf_data'/1\n\t\t\t\t (ConfDataRem)\n\t\t\t %% Line 535\n\t\t\t when 'true' ->\n\t\t\t\t%% Line 536\n\t\t\t\tError1\n\t\t\t end\n\t\t %% Line 538\n\t\t <{AppName,List}>\n\t\t\t when let <_3> =\n\t\t\t\tcall 'erlang':'is_atom'\n\t\t\t\t (AppName)\n\t\t\t in let <_4> =\n\t\t\t\t call 'erlang':'is_list'\n\t\t\t\t\t(List)\n\t\t\t\tin call 'erlang':'and'\n\t\t\t\t\t(_3, _4) ->\n\t\t\t let <_5> =\n\t\t\t call %% Line 539\n\t\t\t\t 'erlang':%% Line 539\n\t\t\t\t\t 'atom_to_list'\n\t\t\t\t (%% Line 539\n\t\t\t\t AppName)\n\t\t\t in %% Line 539\n\t\t\t case apply 'check_para'/2\n\t\t\t\t (List, _5) of\n\t\t\t\t%% Line 540\n\t\t\t\t<'ok'> when 'true' ->\n\t\t\t\t %% Line 541\n\t\t\t\t apply 'check_conf_data'/1\n\t\t\t\t\t(ConfDataRem)\n\t\t\t\t%% Line 542\n\t\t\t\t when 'true' ->\n\t\t\t\t %% Line 543\n\t\t\t\t Error2\n\t\t\t end\n\t\t %% Line 545\n\t\t <{AppName,List}>\n\t\t\t when call 'erlang':'is_list'\n\t\t\t\t(List) ->\n\t\t\t let <_7> =\n\t\t\t call %% Line 547\n\t\t\t\t 'io_lib':%% Line 547\n\t\t\t\t\t 'format'\n\t\t\t\t (%% Line 547\n\t\t\t\t [126|[116|[112]]], %% Line 547\n\t\t\t\t\t\t [AppName|[]])\n\t\t\t in let <_8> =\n\t\t\t\t call %% Line 547\n\t\t\t\t 'lists':%% Line 547\n\t\t\t\t\t 'flatten'\n\t\t\t\t (_7)\n\t\t\t in let <_9> =\n\t\t\t\t call %% Line 548\n\t\t\t\t\t 'erlang':%% Line 548\n\t\t\t\t\t\t '++'\n\t\t\t\t\t (_8, %% Line 548\n\t\t\t\t\t [59|[32|[97|[112|[112|[108|[105|[99|[97|[116|[105|[111|[110|[32|[110|[97|[109|[101|[32|[109|[117|[115|[116|[32|[98|[101|[32|[97|[110|[32|[97|[116|[111|[109]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]])\n\t\t\t\t in let =\n\t\t\t\t\t call %% Line 547\n\t\t\t\t\t 'erlang':%% Line 547\n\t\t\t\t\t\t\t'++'\n\t\t\t\t\t (%% Line 546\n\t\t\t\t\t [97|[112|[112|[108|[105|[99|[97|[116|[105|[111|[110|[58|[32]]]]]]]]]]]]], _9)\n\t\t\t\t in %% Line 549\n\t\t\t\t\t {'error',ErrMsg}\n\t\t %% Line 550\n\t\t <{AppName,_X_List}> when 'true' ->\n\t\t\t let <_11> =\n\t\t\t call %% Line 552\n\t\t\t\t 'io_lib':%% Line 552\n\t\t\t\t\t 'format'\n\t\t\t\t (%% Line 552\n\t\t\t\t [126|[116|[112]]], %% Line 552\n\t\t\t\t\t\t [AppName|[]])\n\t\t\t in let <_12> =\n\t\t\t\t call %% Line 552\n\t\t\t\t 'lists':%% Line 552\n\t\t\t\t\t 'flatten'\n\t\t\t\t (_11)\n\t\t\t in let <_13> =\n\t\t\t\t call %% Line 553\n\t\t\t\t\t 'erlang':%% Line 553\n\t\t\t\t\t\t '++'\n\t\t\t\t\t (_12, %% Line 553\n\t\t\t\t\t\t[59|[32|[112|[97|[114|[97|[109|[101|[116|[101|[114|[115|[32|[109|[117|[115|[116|[32|[98|[101|[32|[97|[32|[108|[105|[115|[116]]]]]]]]]]]]]]]]]]]]]]]]]]])\n\t\t\t\t in let =\n\t\t\t\t\t call %% Line 552\n\t\t\t\t\t 'erlang':%% Line 552\n\t\t\t\t\t\t\t'++'\n\t\t\t\t\t (%% Line 551\n\t\t\t\t\t [97|[112|[112|[108|[105|[99|[97|[116|[105|[111|[110|[58|[32]]]]]]]]]]]]], _13)\n\t\t\t\t in %% Line 554\n\t\t\t\t\t {'error',ErrMsg}\n\t\t %% Line 555\n\t\t when 'true' ->\n\t\t\t let <_15> =\n\t\t\t call %% Line 557\n\t\t\t\t 'io_lib':%% Line 557\n\t\t\t\t\t 'format'\n\t\t\t\t (%% Line 557\n\t\t\t\t [32|[126|[116|[112]]]], %% Line 557\n\t\t\t\t\t\t\t [Else|[]])\n\t\t\t in let <_16> =\n\t\t\t\t call %% Line 557\n\t\t\t\t 'lists':%% Line 557\n\t\t\t\t\t 'flatten'\n\t\t\t\t (_15)\n\t\t\t in let =\n\t\t\t\t call %% Line 556\n\t\t\t\t\t 'erlang':%% Line 556\n\t\t\t\t\t\t '++'\n\t\t\t\t\t (%% Line 556\n\t\t\t\t\t [105|[110|[118|[97|[108|[105|[100|[32|[97|[112|[112|[108|[105|[99|[97|[116|[105|[111|[110|[32|[110|[97|[109|[101|[58|[32]]]]]]]]]]]]]]]]]]]]]]]]]], _16)\n\t\t\t\t in %% Line 558\n\t\t\t\t {'error',ErrMsg}\n\t\t end\n\t\t( <_1> when 'true' ->\n\t\t primop 'match_fail'\n\t\t\t ({'badmatch',_1})\n\t\t -| ['compiler_generated'] )\n\t end\n\t %% Line 560\n\t <_X_ConfData> when 'true' ->\n\t %% Line 561\n\t {'error','configuration must be a list ended by '}\n\tend\n'check_para_kernel'/1 =\n %% Line 565\n fun (_0) ->\n\tcase _0 of\n\t <[]> when 'true' ->\n\t %% Line 566\n\t 'ok'\n\t %% Line 567\n\t <[{'distributed',Apps}|ParaList]>\n\t when call 'erlang':'is_list'\n\t\t (Apps) ->\n\t %% Line 568\n\t case apply 'check_distributed'/1\n\t\t (Apps) of\n\t\t%% Line 569\n\t\t when 'true' ->\n\t\t %% Line 570\n\t\t Error\n\t\t%% Line 571\n\t\t<_9> when 'true' ->\n\t\t %% Line 572\n\t\t apply 'check_para_kernel'/1\n\t\t\t(ParaList)\n\t end\n\t %% Line 574\n\t <[{'distributed',_X_Apps}|_X_ParaList]> when 'true' ->\n\t %% Line 575\n\t {'error',[97|[112|[112|[108|[105|[99|[97|[116|[105|[111|[110|[58|[32|[107|[101|[114|[110|[101|[108|[59|[32|[101|[114|[114|[111|[110|[101|[111|[117|[115|[32|[112|[97|[114|[97|[109|[101|[116|[101|[114|[58|[32|[100|[105|[115|[116|[114|[105|[98|[117|[116|[101|[100]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]}\n\t %% Line 576\n\t <[{Para,_X_Val}|ParaList]>\n\t when call 'erlang':'is_atom'\n\t\t (Para) ->\n\t %% Line 577\n\t apply 'check_para_kernel'/1\n\t\t (ParaList)\n\t %% Line 578\n\t <[{Para,_X_Val}|_X_ParaList]> when 'true' ->\n\t let <_2> =\n\t\t call %% Line 580\n\t\t 'io_lib':%% Line 580\n\t\t\t\t'format'\n\t\t (%% Line 580\n\t\t [126|[116|[112]]], %% Line 580\n\t\t\t\t\t [Para|[]])\n\t in let <_3> =\n\t\t call %% Line 580\n\t\t\t 'lists':%% Line 580\n\t\t\t\t 'flatten'\n\t\t\t (_2)\n\t\t in let <_4> =\n\t\t\t call %% Line 579\n\t\t\t 'erlang':%% Line 579\n\t\t\t\t\t'++'\n\t\t\t (%% Line 579\n\t\t\t [97|[112|[112|[108|[105|[99|[97|[116|[105|[111|[110|[58|[32|[107|[101|[114|[110|[101|[108|[59|[32|[105|[110|[118|[97|[108|[105|[100|[32|[112|[97|[114|[97|[109|[101|[116|[101|[114|[58|[32]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]], _3)\n\t\t in %% Line 579\n\t\t\t {'error',_4}\n\t %% Line 581\n\t when 'true' ->\n\t let <_5> =\n\t\t call %% Line 583\n\t\t 'io_lib':%% Line 583\n\t\t\t\t'format'\n\t\t (%% Line 583\n\t\t [126|[116|[112]]], %% Line 583\n\t\t\t\t\t [Else|[]])\n\t in let <_6> =\n\t\t call %% Line 583\n\t\t\t 'lists':%% Line 583\n\t\t\t\t 'flatten'\n\t\t\t (_5)\n\t\t in let <_7> =\n\t\t\t call %% Line 582\n\t\t\t 'erlang':%% Line 582\n\t\t\t\t\t'++'\n\t\t\t (%% Line 582\n\t\t\t [97|[112|[112|[108|[105|[99|[97|[116|[105|[111|[110|[58|[32|[107|[101|[114|[110|[101|[108|[59|[32|[105|[110|[118|[97|[108|[105|[100|[32|[112|[97|[114|[97|[109|[101|[116|[101|[114|[32|[108|[105|[115|[116|[58|[32]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]], _6)\n\t\t in %% Line 582\n\t\t\t {'error',_7}\n\tend\n'check_distributed'/1 =\n %% Line 586\n fun (_0) ->\n\tcase _0 of\n\t <[]> when 'true' ->\n\t %% Line 587\n\t 'ok'\n\t %% Line 588\n\t <[{App,List}|Apps]>\n\t when let <_1> =\n\t\t call 'erlang':'is_atom'\n\t\t\t(App)\n\t\tin let <_2> =\n\t\t\tcall 'erlang':'is_list'\n\t\t\t (List)\n\t\t in call 'erlang':'and'\n\t\t\t (_1, _2) ->\n\t %% Line 589\n\t apply 'check_distributed'/1\n\t\t (Apps)\n\t %% Line 590\n\t <[{App,'infinity',List}|Apps]>\n\t when let <_3> =\n\t\t call 'erlang':'is_atom'\n\t\t\t(App)\n\t\tin let <_4> =\n\t\t\tcall 'erlang':'is_list'\n\t\t\t (List)\n\t\t in call 'erlang':'and'\n\t\t\t (_3, _4) ->\n\t %% Line 591\n\t apply 'check_distributed'/1\n\t\t (Apps)\n\t %% Line 592\n\t <[{App,Time,List}|Apps]>\n\t when try\n\t\t let <_5> =\n\t\t\tcall 'erlang':'is_atom'\n\t\t\t (App)\n\t\t in let <_6> =\n\t\t\t call 'erlang':'is_integer'\n\t\t\t\t(Time)\n\t\t\tin let <_7> =\n\t\t\t\tcall 'erlang':'is_list'\n\t\t\t\t (List)\n\t\t\t in let <_8> =\n\t\t\t\t call 'erlang':'and'\n\t\t\t\t\t(_6, _7)\n\t\t\t\tin call 'erlang':'and'\n\t\t\t\t\t(_5, _8)\n\t\tof ->\n\t\t Try\n\t\tcatch ->\n\t\t 'false' ->\n\t %% Line 593\n\t apply 'check_distributed'/1\n\t\t (Apps)\n\t %% Line 594\n\t <_X_Else> when 'true' ->\n\t %% Line 595\n\t {'error',[97|[112|[112|[108|[105|[99|[97|[116|[105|[111|[110|[58|[32|[107|[101|[114|[110|[101|[108|[59|[32|[101|[114|[114|[111|[110|[101|[111|[117|[115|[32|[112|[97|[114|[97|[109|[101|[116|[101|[114|[58|[32|[100|[105|[115|[116|[114|[105|[98|[117|[116|[101|[100]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]}\n\tend\n'check_para'/2 =\n %% Line 598\n fun (_1,_0) ->\n\tcase <_1,_0> of\n\t <[],_X_AppName> when 'true' ->\n\t %% Line 599\n\t 'ok'\n\t %% Line 600\n\t <[{Para,_X_Val}|ParaList],AppName>\n\t when call 'erlang':'is_atom'\n\t\t (Para) ->\n\t %% Line 601\n\t apply 'check_para'/2\n\t\t (ParaList, AppName)\n\t %% Line 602\n\t <[{Para,_X_Val}|_X_ParaList],AppName> when 'true' ->\n\t let <_2> =\n\t\t call %% Line 604\n\t\t 'io_lib':%% Line 604\n\t\t\t\t'format'\n\t\t (%% Line 604\n\t\t [126|[116|[112]]], %% Line 604\n\t\t\t\t\t [Para|[]])\n\t in let <_3> =\n\t\t call %% Line 604\n\t\t\t 'lists':%% Line 604\n\t\t\t\t 'flatten'\n\t\t\t (_2)\n\t\t in let <_4> =\n\t\t\t call %% Line 603\n\t\t\t 'erlang':%% Line 603\n\t\t\t\t\t'++'\n\t\t\t (%% Line 603\n\t\t\t [59|[32|[105|[110|[118|[97|[108|[105|[100|[32|[112|[97|[114|[97|[109|[101|[116|[101|[114|[58|[32]]]]]]]]]]]]]]]]]]]]], _3)\n\t\t in let <_5> =\n\t\t\t call %% Line 603\n\t\t\t\t 'erlang':%% Line 603\n\t\t\t\t\t '++'\n\t\t\t\t (%% Line 603\n\t\t\t\t AppName, _4)\n\t\t\t in let <_6> =\n\t\t\t\t call %% Line 603\n\t\t\t\t 'erlang':%% Line 603\n\t\t\t\t\t\t'++'\n\t\t\t\t (%% Line 603\n\t\t\t\t [97|[112|[112|[108|[105|[99|[97|[116|[105|[111|[110|[58|[32]]]]]]]]]]]]], _5)\n\t\t\t in %% Line 603\n\t\t\t\t {'error',_6}\n\t %% Line 605\n\t <[Else|_X_ParaList],AppName> when 'true' ->\n\t let <_7> =\n\t\t call %% Line 607\n\t\t 'io_lib':%% Line 607\n\t\t\t\t'format'\n\t\t (%% Line 607\n\t\t [126|[116|[112]]], %% Line 607\n\t\t\t\t\t [Else|[]])\n\t in let <_8> =\n\t\t call %% Line 607\n\t\t\t 'lists':%% Line 607\n\t\t\t\t 'flatten'\n\t\t\t (_7)\n\t\t in let <_9> =\n\t\t\t call %% Line 606\n\t\t\t 'erlang':%% Line 606\n\t\t\t\t\t'++'\n\t\t\t (%% Line 606\n\t\t\t [59|[32|[105|[110|[118|[97|[108|[105|[100|[32|[112|[97|[114|[97|[109|[101|[116|[101|[114|[58|[32]]]]]]]]]]]]]]]]]]]]], _8)\n\t\t in let <_10> =\n\t\t\t call %% Line 606\n\t\t\t\t 'erlang':%% Line 606\n\t\t\t\t\t '++'\n\t\t\t\t (%% Line 606\n\t\t\t\t AppName, _9)\n\t\t\t in let <_11> =\n\t\t\t\t call %% Line 606\n\t\t\t\t 'erlang':%% Line 606\n\t\t\t\t\t\t'++'\n\t\t\t\t (%% Line 606\n\t\t\t\t [97|[112|[112|[108|[105|[99|[97|[116|[105|[111|[110|[58|[32]]]]]]]]]]]]], _10)\n\t\t\t in %% Line 606\n\t\t\t\t {'error',_11}\n\t ( <_13,_12> when 'true' ->\n\t\t( primop 'match_fail'\n\t\t ({'function_clause',_13,_12})\n\t\t -| [{'function_name',{'check_para',2}}] )\n\t -| ['compiler_generated'] )\n\tend\n'handle_call'/3 =\n %% Line 623\n fun (_2,_1,_0) ->\n\tcase <_2,_1,_0> of\n\t <{'load_application',Application},From,S> when 'true' ->\n\t let <_3> =\n\t\t catch\n\t\t %% Line 624\n\t\t apply 'do_load_application'/2\n\t\t\t (Application, S)\n\t in %% Line 624\n\t\t case _3 of\n\t\t %% Line 625\n\t\t <{'ok',NewS}> when 'true' ->\n\t\t\tlet =\n\t\t\t apply %% Line 626\n\t\t\t\t 'get_appl_name'/1\n\t\t\t\t(%% Line 626\n\t\t\t\t Application)\n\t\t\tin %% Line 627\n\t\t\t case apply 'cntrl'/3\n\t\t\t\t (AppName, S, {'ac_load_application_req',AppName}) of\n\t\t\t %% Line 628\n\t\t\t <'true'> when 'true' ->\n\t\t\t\t %% Line 630\n\t\t\t\t ( case S of\n\t\t\t\t ( <( {'state',_rec36,_203,_204,_205,_206,_207,_208,_209}\n\t\t\t\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\t\t\t let <_rec34> =\n\t\t\t\t\t\t[{AppName,From}|_rec36]\n\t\t\t\t\t in let <_10> =\n\t\t\t\t\t\t call 'erlang':'setelement'\n\t\t\t\t\t\t\t(2, S, _rec34)\n\t\t\t\t\t\tin {'noreply',_10}\n\t\t\t\t\t-| ['compiler_generated'] )\n\t\t\t\t ( <_210> when 'true' ->\n\t\t\t\t\t ( call ( 'erlang'\n\t\t\t\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t\t (( {'badrecord','state'}\n\t\t\t\t\t\t -| ['compiler_generated'] ))\n\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t-| ['compiler_generated'] )\n\t\t\t\t end\n\t\t\t\t -| ['compiler_generated'] )\n\t\t\t %% Line 631\n\t\t\t <'false'> when 'true' ->\n\t\t\t\t %% Line 632\n\t\t\t\t {'reply','ok',NewS}\n\t\t\t ( <_11> when 'true' ->\n\t\t\t\t primop 'match_fail'\n\t\t\t\t\t({'case_clause',_11})\n\t\t\t\t-| ['compiler_generated'] )\n\t\t\t end\n\t\t %% Line 634\n\t\t when 'true' ->\n\t\t\t%% Line 635\n\t\t\t{'reply',Error,S}\n\t\t %% Line 636\n\t\t <{'EXIT',R}> when 'true' ->\n\t\t\t%% Line 637\n\t\t\t{'reply',{'error',R},S}\n\t\t ( <_12> when 'true' ->\n\t\t\t primop 'match_fail'\n\t\t\t ({'case_clause',_12})\n\t\t -| ['compiler_generated'] )\n\t\t end\n\t %% Line 640\n\t <{'unload_application',AppName},_X_From,S> when 'true' ->\n\t %% Line 641\n\t ( case S of\n\t\t ( <( {'state',_221,_222,_223,_rec37,_224,_225,_226,_227}\n\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\tcase call 'lists':'keymember'\n\t\t\t\t (AppName, 1, _rec37) of\n\t\t\t %% Line 642\n\t\t\t <'true'> when 'true' ->\n\t\t\t {'reply',{'error',{'running',AppName}},S}\n\t\t\t %% Line 643\n\t\t\t <'false'> when 'true' ->\n\t\t\t %% Line 644\n\t\t\t case apply 'get_loaded'/1\n\t\t\t\t (AppName) of\n\t\t\t\t%% Line 645\n\t\t\t\t<{'true',_229}> when 'true' ->\n\t\t\t\t let =\n\t\t\t\t\tapply %% Line 646\n\t\t\t\t\t 'unload'/2\n\t\t\t\t\t (%% Line 646\n\t\t\t\t\t AppName, %% Line 646\n\t\t\t\t\t\t S)\n\t\t\t\t in do %% Line 647\n\t\t\t\t\t apply 'cntrl'/3\n\t\t\t\t\t\t(AppName, S, {'ac_application_unloaded',AppName})\n\t\t\t\t\t %% Line 648\n\t\t\t\t\t {'reply','ok',NewS}\n\t\t\t\t%% Line 649\n\t\t\t\t<'false'> when 'true' ->\n\t\t\t\t %% Line 650\n\t\t\t\t {'reply',{'error',{'not_loaded',AppName}},S}\n\t\t\t\t( <_16> when 'true' ->\n\t\t\t\t primop 'match_fail'\n\t\t\t\t\t ({'case_clause',_16})\n\t\t\t\t -| ['compiler_generated'] )\n\t\t\t end\n\t\t\t ( <_17> when 'true' ->\n\t\t\t\tprimop 'match_fail'\n\t\t\t\t ({'case_clause',_17})\n\t\t\t -| ['compiler_generated'] )\n\t\t\tend\n\t\t -| ['compiler_generated'] )\n\t\t ( <_228> when 'true' ->\n\t\t\t( call ( 'erlang'\n\t\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t (( {'badrecord','state'}\n\t\t\t\t -| ['compiler_generated'] ))\n\t\t\t -| ['compiler_generated'] )\n\t\t -| ['compiler_generated'] )\n\t\tend\n\t\t-| ['compiler_generated'] )\n\t %% Line 654\n\t <{'start_application',AppName,RestartType},From,S> when 'true' ->\n\t %% Line 656\n\t case S of\n\t\t<{'state',_230,Starting,SPF,Running,_231,Started,Start_req,_232}> when 'true' ->\n\t\t %% Line 661\n\t\t case call 'lists':'keyfind'\n\t\t\t (AppName, 1, Start_req) of\n\t\t %% Line 662\n\t\t <'false'> when 'true' ->\n\t\t\t let <_19> =\n\t\t\t catch\n\t\t\t\t %% Line 663\n\t\t\t\t apply 'check_start_cond'/4\n\t\t\t\t (AppName, RestartType, Started, Running)\n\t\t\t in %% Line 663\n\t\t\t case _19 of\n\t\t\t\t%% Line 664\n\t\t\t\t<{'ok',Appl}> when 'true' ->\n\t\t\t\t let =\n\t\t\t\t\tapply %% Line 665\n\t\t\t\t\t 'cntrl'/3\n\t\t\t\t\t (%% Line 665\n\t\t\t\t\t AppName, %% Line 665\n\t\t\t\t\t\t S, %% Line 665\n\t\t\t\t\t\t\t {'ac_start_application_req',AppName})\n\t\t\t\t in let =\n\t\t\t\t\t call %% Line 666\n\t\t\t\t\t\t 'application':%% Line 666\n\t\t\t\t\t\t\t 'get_env'\n\t\t\t\t\t\t(%% Line 666\n\t\t\t\t\t\t 'kernel', %% Line 666\n\t\t\t\t\t\t\t 'permissions')\n\t\t\t\t\tin %% Line 667\n\t\t\t\t\t case of\n\t\t\t\t\t %% Line 668\n\t\t\t\t\t <( 'true'\n\t\t\t\t\t\t -| ['compiler_generated'] ),_233> when 'true' ->\n\t\t\t\t\t\t let <_rec38> =\n\t\t\t\t\t\t [%% Line 669\n\t\t\t\t\t\t {AppName,RestartType,'normal',From}|%% Line 670\n\t\t\t\t\t\t\t\t\t\t\t Starting]\n\t\t\t\t\t\t in let <_rec39> =\n\t\t\t\t\t\t\t [%% Line 671\n\t\t\t\t\t\t\t {AppName,From}|%% Line 671\n\t\t\t\t\t\t\t\t\t Start_req]\n\t\t\t\t\t\t in let <_25> =\n\t\t\t\t\t\t\t call %% Line 671\n\t\t\t\t\t\t\t\t 'erlang':%% Line 671\n\t\t\t\t\t\t\t\t\t 'setelement'\n\t\t\t\t\t\t\t\t (%% Line 671\n\t\t\t\t\t\t\t\t 8, %% Line 669\n\t\t\t\t\t\t\t\t S, %% Line 671\n\t\t\t\t\t\t\t\t\t _rec39)\n\t\t\t\t\t\t\t in let <_27> =\n\t\t\t\t\t\t\t\t call %% Line 669\n\t\t\t\t\t\t\t\t 'erlang':%% Line 669\n\t\t\t\t\t\t\t\t\t\t'setelement'\n\t\t\t\t\t\t\t\t (%% Line 669\n\t\t\t\t\t\t\t\t 3, _25, %% Line 669\n\t\t\t\t\t\t\t\t\t _rec38)\n\t\t\t\t\t\t\t in %% Line 669\n\t\t\t\t\t\t\t\t {'noreply',_27}\n\t\t\t\t\t %% Line 672\n\t\t\t\t\t <'false','undefined'> when 'true' ->\n\t\t\t\t\t\t do %% Line 673\n\t\t\t\t\t\t apply 'spawn_starter'/4\n\t\t\t\t\t\t\t (From, Appl, S, 'normal')\n\t\t\t\t\t\t let <_rec41> =\n\t\t\t\t\t\t\t [%% Line 674\n\t\t\t\t\t\t\t {AppName,RestartType,'normal',From}|%% Line 675\n\t\t\t\t\t\t\t\t\t\t\t Starting]\n\t\t\t\t\t\t in let <_rec42> =\n\t\t\t\t\t\t\t [%% Line 676\n\t\t\t\t\t\t\t {AppName,From}|%% Line 676\n\t\t\t\t\t\t\t\t\t Start_req]\n\t\t\t\t\t\t\t in let <_31> =\n\t\t\t\t\t\t\t\t call %% Line 676\n\t\t\t\t\t\t\t\t 'erlang':%% Line 676\n\t\t\t\t\t\t\t\t\t\t'setelement'\n\t\t\t\t\t\t\t\t (%% Line 676\n\t\t\t\t\t\t\t\t 8, %% Line 674\n\t\t\t\t\t\t\t\t\t S, %% Line 676\n\t\t\t\t\t\t\t\t\t _rec42)\n\t\t\t\t\t\t\t in let <_33> =\n\t\t\t\t\t\t\t\t call %% Line 674\n\t\t\t\t\t\t\t\t\t 'erlang':%% Line 674\n\t\t\t\t\t\t\t\t\t\t 'setelement'\n\t\t\t\t\t\t\t\t\t (%% Line 674\n\t\t\t\t\t\t\t\t\t 3, _31, %% Line 674\n\t\t\t\t\t\t\t\t\t\t _rec41)\n\t\t\t\t\t\t\t\t in %% Line 674\n\t\t\t\t\t\t\t\t {'noreply',_33}\n\t\t\t\t\t %% Line 677\n\t\t\t\t\t <( 'false'\n\t\t\t\t\t\t -| ['compiler_generated'] ),( {( 'ok'\n\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] ),Perms}\n\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\t\t\t\t %% Line 678\n\t\t\t\t\t\t case call 'lists':'member'\n\t\t\t\t\t\t\t ({AppName,'false'}, Perms) of\n\t\t\t\t\t\t %% Line 679\n\t\t\t\t\t\t <'false'> when 'true' ->\n\t\t\t\t\t\t\tdo %% Line 680\n\t\t\t\t\t\t\t apply 'spawn_starter'/4\n\t\t\t\t\t\t\t\t(From, Appl, S, 'normal')\n\t\t\t\t\t\t\t let <_rec44> =\n\t\t\t\t\t\t\t\t[%% Line 681\n\t\t\t\t\t\t\t\t {AppName,RestartType,'normal',From}|%% Line 682\n\t\t\t\t\t\t\t\t\t\t\t\t Starting]\n\t\t\t\t\t\t\t in let <_rec45> =\n\t\t\t\t\t\t\t\t [%% Line 683\n\t\t\t\t\t\t\t\t {AppName,From}|%% Line 683\n\t\t\t\t\t\t\t\t\t\t Start_req]\n\t\t\t\t\t\t\t\tin let <_37> =\n\t\t\t\t\t\t\t\t\tcall %% Line 683\n\t\t\t\t\t\t\t\t\t 'erlang':%% Line 683\n\t\t\t\t\t\t\t\t\t\t 'setelement'\n\t\t\t\t\t\t\t\t\t (%% Line 683\n\t\t\t\t\t\t\t\t\t 8, %% Line 681\n\t\t\t\t\t\t\t\t\t\tS, %% Line 683\n\t\t\t\t\t\t\t\t\t\t _rec45)\n\t\t\t\t\t\t\t\t in let <_39> =\n\t\t\t\t\t\t\t\t\t call %% Line 681\n\t\t\t\t\t\t\t\t\t\t 'erlang':%% Line 681\n\t\t\t\t\t\t\t\t\t\t\t 'setelement'\n\t\t\t\t\t\t\t\t\t\t(%% Line 681\n\t\t\t\t\t\t\t\t\t\t 3, _37, %% Line 681\n\t\t\t\t\t\t\t\t\t\t\t _rec44)\n\t\t\t\t\t\t\t\t\tin %% Line 681\n\t\t\t\t\t\t\t\t\t {'noreply',_39}\n\t\t\t\t\t\t %% Line 684\n\t\t\t\t\t\t <'true'> when 'true' ->\n\t\t\t\t\t\t\tlet <_rec47> =\n\t\t\t\t\t\t\t [%% Line 685\n\t\t\t\t\t\t\t {AppName,RestartType,'normal',From}|%% Line 686\n\t\t\t\t\t\t\t\t\t\t\t\t SPF]\n\t\t\t\t\t\t\tin let <_43> =\n\t\t\t\t\t\t\t\tcall %% Line 685\n\t\t\t\t\t\t\t\t 'erlang':%% Line 685\n\t\t\t\t\t\t\t\t\t 'setelement'\n\t\t\t\t\t\t\t\t (%% Line 685\n\t\t\t\t\t\t\t\t 4, %% Line 685\n\t\t\t\t\t\t\t\t\tS, %% Line 685\n\t\t\t\t\t\t\t\t\t _rec47)\n\t\t\t\t\t\t\t in %% Line 687\n\t\t\t\t\t\t\t\t{'reply','ok',_43}\n\t\t\t\t\t\t ( <_45> when 'true' ->\n\t\t\t\t\t\t\t primop 'match_fail'\n\t\t\t\t\t\t\t ({'case_clause',_45})\n\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t\t end\n\t\t\t\t\t ( <( _561\n\t\t\t\t\t\t -| ['compiler_generated'] ),( _562\n\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\t\t\t\t let <_46> = {( _561\n\t\t\t\t\t\t\t -| ['compiler_generated'] ),( _562\n\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] )}\n\t\t\t\t\t\t in primop 'match_fail'\n\t\t\t\t\t\t\t ({'case_clause',_46})\n\t\t\t\t\t\t-| ['compiler_generated'] )\n\t\t\t\t\t end\n\t\t\t\t%% Line 690\n\t\t\t\t when 'true' ->\n\t\t\t\t %% Line 691\n\t\t\t\t {'reply',Error,S}\n\t\t\t\t( <_47> when 'true' ->\n\t\t\t\t primop 'match_fail'\n\t\t\t\t\t ({'case_clause',_47})\n\t\t\t\t -| ['compiler_generated'] )\n\t\t\t end\n\t\t %% Line 693\n\t\t <{_270,_X_FromX}>\n\t\t\t when call 'erlang':'=:='\n\t\t\t\t(_270,\n\t\t\t\t AppName) ->\n\t\t\t let <_rec49> =\n\t\t\t [%% Line 694\n\t\t\t {AppName,From}|%% Line 694\n\t\t\t\t\t Start_req]\n\t\t\t in let <_51> =\n\t\t\t\t call %% Line 694\n\t\t\t\t 'erlang':%% Line 694\n\t\t\t\t\t\t'setelement'\n\t\t\t\t (%% Line 694\n\t\t\t\t 8, %% Line 694\n\t\t\t\t\t S, %% Line 694\n\t\t\t\t\t _rec49)\n\t\t\t in %% Line 695\n\t\t\t\t {'noreply',_51}\n\t\t ( <_53> when 'true' ->\n\t\t\t primop 'match_fail'\n\t\t\t\t({'case_clause',_53})\n\t\t\t-| ['compiler_generated'] )\n\t\t end\n\t\t( <_18> when 'true' ->\n\t\t primop 'match_fail'\n\t\t\t ({'badmatch',_18})\n\t\t -| ['compiler_generated'] )\n\t end\n\t %% Line 698\n\t <{'permit_application',AppName,Bool},From,S> when 'true' ->\n\t %% Line 699\n\t ( case S of\n\t\t ( <( {'state',_280,_281,_282,_283,_rec51,_284,_285,_286}\n\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\tlet =\n\t\t\t apply %% Line 705\n\t\t\t\t 'get_loaded'/1\n\t\t\t\t(%% Line 705\n\t\t\t\t AppName)\n\t\t\tin let =\n\t\t\t\tcall %% Line 706\n\t\t\t\t 'lists':%% Line 706\n\t\t\t\t\t 'keysearch'\n\t\t\t\t (%% Line 706\n\t\t\t\t AppName, %% Line 706\n\t\t\t\t\t 1, _281)\n\t\t\t in let =\n\t\t\t\t call %% Line 707\n\t\t\t\t\t 'lists':%% Line 707\n\t\t\t\t\t\t 'keysearch'\n\t\t\t\t\t(%% Line 707\n\t\t\t\t\t AppName, %% Line 707\n\t\t\t\t\t\t 1, _282)\n\t\t\t\tin let =\n\t\t\t\t\tcall %% Line 708\n\t\t\t\t\t 'lists':%% Line 708\n\t\t\t\t\t\t 'keysearch'\n\t\t\t\t\t (%% Line 708\n\t\t\t\t\t AppName, %% Line 708\n\t\t\t\t\t\t 1, _284)\n\t\t\t\t in let =\n\t\t\t\t\t call %% Line 709\n\t\t\t\t\t\t 'lists':%% Line 709\n\t\t\t\t\t\t\t 'keysearch'\n\t\t\t\t\t\t(%% Line 709\n\t\t\t\t\t\t AppName, %% Line 709\n\t\t\t\t\t\t\t 1, _283)\n\t\t\t\t\tin %% Line 711\n\t\t\t\t\t case call 'lists':'keymember'\n\t\t\t\t\t\t (AppName, 1, _rec51) of\n\t\t\t\t\t %% Line 715\n\t\t\t\t\t <'true'> when 'true' ->\n\t\t\t\t\t\t %% Line 716\n\t\t\t\t\t\t case of\n\t\t\t\t\t\t %% Line 718\n\t\t\t\t\t\t <( 'false'\n\t\t\t\t\t\t -| ['compiler_generated'] ),_328,_329> when 'true' ->\n\t\t\t\t\t\t\t%% Line 719\n\t\t\t\t\t\t\t{'reply',{'error',{'not_loaded',AppName}},S}\n\t\t\t\t\t\t %% Line 721\n\t\t\t\t\t\t <( {( 'true'\n\t\t\t\t\t\t\t -| ['compiler_generated'] ),_X_Appl}\n\t\t\t\t\t\t -| ['compiler_generated'] ),( 'false'\n\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] ),( 'false'\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\t\t\t\t\tdo %% Line 722\n\t\t\t\t\t\t\t apply 'update_permissions'/2\n\t\t\t\t\t\t\t\t(AppName, Bool)\n\t\t\t\t\t\t\t %% Line 723\n\t\t\t\t\t\t\t {'reply',{'distributed_application','only_loaded'},S}\n\t\t\t\t\t\t %% Line 724\n\t\t\t\t\t\t <( _563\n\t\t\t\t\t\t -| ['compiler_generated'] ),( _564\n\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] ),( _565\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\t\t\t\t\tdo %% Line 725\n\t\t\t\t\t\t\t apply 'update_permissions'/2\n\t\t\t\t\t\t\t\t(AppName, Bool)\n\t\t\t\t\t\t\t %% Line 726\n\t\t\t\t\t\t\t {'reply','distributed_application',S}\n\t\t\t\t\t\t end\n\t\t\t\t\t %% Line 731\n\t\t\t\t\t <'false'> when 'true' ->\n\t\t\t\t\t\t %% Line 732\n\t\t\t\t\t\t case of\n\t\t\t\t\t\t %% Line 737\n\t\t\t\t\t\t <( 'true'\n\t\t\t\t\t\t -| ['compiler_generated'] ),_331,_332,_333,_334,( {( 'value'\n\t\t\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] ),_X_Tuple}\n\t\t\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\t\t\t\t\t%% Line 738\n\t\t\t\t\t\t\t{'reply','ok',S}\n\t\t\t\t\t\t %% Line 740\n\t\t\t\t\t\t <( 'true'\n\t\t\t\t\t\t -| ['compiler_generated'] ),( 'false'\n\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] ),_335,_336,_337,_338> when 'true' ->\n\t\t\t\t\t\t\t%% Line 741\n\t\t\t\t\t\t\t{'reply',{'error',{'not_loaded',AppName}},S}\n\t\t\t\t\t\t %% Line 743\n\t\t\t\t\t\t <( 'true'\n\t\t\t\t\t\t -| ['compiler_generated'] ),( {( 'true'\n\t\t\t\t\t\t\t\t\t\t\t-| ['compiler_generated'] ),_X_Appl}\n\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] ),( 'false'\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] ),( 'false'\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] ),( 'false'\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] ),( 'false'\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\t\t\t\t\tdo %% Line 744\n\t\t\t\t\t\t\t apply 'update_permissions'/2\n\t\t\t\t\t\t\t\t(AppName, Bool)\n\t\t\t\t\t\t\t %% Line 745\n\t\t\t\t\t\t\t {'reply','ok',S}\n\t\t\t\t\t\t %% Line 747\n\t\t\t\t\t\t <( 'true'\n\t\t\t\t\t\t -| ['compiler_generated'] ),( {( 'true'\n\t\t\t\t\t\t\t\t\t\t\t-| ['compiler_generated'] ),_X_Appl}\n\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] ),( {( 'value'\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] ),_X_Tuple}\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] ),( 'false'\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] ),( 'false'\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] ),( 'false'\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\t\t\t\t\tdo %% Line 748\n\t\t\t\t\t\t\t apply 'update_permissions'/2\n\t\t\t\t\t\t\t\t(AppName, Bool)\n\t\t\t\t\t\t\t %% Line 749\n\t\t\t\t\t\t\t {'reply','ok',S}\n\t\t\t\t\t\t %% Line 751\n\t\t\t\t\t\t <( 'true'\n\t\t\t\t\t\t -| ['compiler_generated'] ),( {( 'true'\n\t\t\t\t\t\t\t\t\t\t\t-| ['compiler_generated'] ),Appl}\n\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] ),( 'false'\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] ),( {( 'value'\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] ),Tuple}\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] ),( 'false'\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] ),( 'false'\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\t\t\t\t\tdo %% Line 752\n\t\t\t\t\t\t\t apply 'update_permissions'/2\n\t\t\t\t\t\t\t\t(AppName, Bool)\n\t\t\t\t\t\t\t %% Line 753\n\t\t\t\t\t\t\t case Tuple of\n\t\t\t\t\t\t\t <{_X_AppName2,RestartType,'normal',_X_From}> when 'true' ->\n\t\t\t\t\t\t\t\t do %% Line 754\n\t\t\t\t\t\t\t\t apply 'spawn_starter'/4\n\t\t\t\t\t\t\t\t\t (From, Appl, S, 'normal')\n\t\t\t\t\t\t\t\t let <_rec57> =\n\t\t\t\t\t\t\t\t\t [%% Line 755\n\t\t\t\t\t\t\t\t\t {AppName,RestartType,'normal',From}|_281]\n\t\t\t\t\t\t\t\t in let <_rec58> =\n\t\t\t\t\t\t\t\t\t call %% Line 756\n\t\t\t\t\t\t\t\t\t\t 'lists':%% Line 756\n\t\t\t\t\t\t\t\t\t\t\t 'keydelete'\n\t\t\t\t\t\t\t\t\t\t (%% Line 756\n\t\t\t\t\t\t\t\t\t\t AppName, %% Line 756\n\t\t\t\t\t\t\t\t\t\t\t 1, _282)\n\t\t\t\t\t\t\t\t\t in let <_rec59> =\n\t\t\t\t\t\t\t\t\t\t [%% Line 757\n\t\t\t\t\t\t\t\t\t\t {AppName,From}|_285]\n\t\t\t\t\t\t\t\t\t in let <_83> =\n\t\t\t\t\t\t\t\t\t\t call %% Line 757\n\t\t\t\t\t\t\t\t\t\t\t 'erlang':%% Line 757\n\t\t\t\t\t\t\t\t\t\t\t\t 'setelement'\n\t\t\t\t\t\t\t\t\t\t\t (%% Line 757\n\t\t\t\t\t\t\t\t\t\t\t 8, %% Line 755\n\t\t\t\t\t\t\t\t\t\t\t S, %% Line 757\n\t\t\t\t\t\t\t\t\t\t\t\t _rec59)\n\t\t\t\t\t\t\t\t\t\t in let <_84> =\n\t\t\t\t\t\t\t\t\t\t\t call %% Line 756\n\t\t\t\t\t\t\t\t\t\t\t 'erlang':%% Line 756\n\t\t\t\t\t\t\t\t\t\t\t\t\t'setelement'\n\t\t\t\t\t\t\t\t\t\t\t (%% Line 756\n\t\t\t\t\t\t\t\t\t\t\t 4, _83, %% Line 756\n\t\t\t\t\t\t\t\t\t\t\t\t _rec58)\n\t\t\t\t\t\t\t\t\t\t in let <_86> =\n\t\t\t\t\t\t\t\t\t\t\t call %% Line 755\n\t\t\t\t\t\t\t\t\t\t\t\t 'erlang':%% Line 755\n\t\t\t\t\t\t\t\t\t\t\t\t\t 'setelement'\n\t\t\t\t\t\t\t\t\t\t\t\t (%% Line 755\n\t\t\t\t\t\t\t\t\t\t\t\t 3, _84, %% Line 755\n\t\t\t\t\t\t\t\t\t\t\t\t\t _rec57)\n\t\t\t\t\t\t\t\t\t\t\t in %% Line 758\n\t\t\t\t\t\t\t\t\t\t\t {'noreply',_86}\n\t\t\t\t\t\t\t ( <_78> when 'true' ->\n\t\t\t\t\t\t\t\t primop 'match_fail'\n\t\t\t\t\t\t\t\t\t({'badmatch',_78})\n\t\t\t\t\t\t\t\t-| ['compiler_generated'] )\n\t\t\t\t\t\t\t end\n\t\t\t\t\t\t %% Line 760\n\t\t\t\t\t\t <( 'true'\n\t\t\t\t\t\t -| ['compiler_generated'] ),( {( 'true'\n\t\t\t\t\t\t\t\t\t\t\t-| ['compiler_generated'] ),Appl}\n\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] ),_348,_349,( {( 'value'\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t-| ['compiler_generated'] ),( {_350,RestartType}\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] )}\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] ),( 'false'\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] )>\n\t\t\t\t\t\t\twhen call 'erlang':'=:='\n\t\t\t\t\t\t\t (_350,\n\t\t\t\t\t\t\t AppName) ->\n\t\t\t\t\t\t\tdo %% Line 761\n\t\t\t\t\t\t\t apply 'update_permissions'/2\n\t\t\t\t\t\t\t\t(AppName, Bool)\n\t\t\t\t\t\t\t do %% Line 762\n\t\t\t\t\t\t\t\tapply 'spawn_starter'/4\n\t\t\t\t\t\t\t\t (From, Appl, S, 'normal')\n\t\t\t\t\t\t\t\tlet <_rec61> =\n\t\t\t\t\t\t\t\t [%% Line 763\n\t\t\t\t\t\t\t\t {AppName,RestartType,'normal',From}|_281]\n\t\t\t\t\t\t\t\tin let <_rec62> =\n\t\t\t\t\t\t\t\t\tcall %% Line 764\n\t\t\t\t\t\t\t\t\t 'lists':%% Line 764\n\t\t\t\t\t\t\t\t\t\t 'keydelete'\n\t\t\t\t\t\t\t\t\t (%% Line 764\n\t\t\t\t\t\t\t\t\t AppName, %% Line 764\n\t\t\t\t\t\t\t\t\t\t 1, _284)\n\t\t\t\t\t\t\t\t in let <_rec63> =\n\t\t\t\t\t\t\t\t\t [%% Line 765\n\t\t\t\t\t\t\t\t\t {AppName,From}|_285]\n\t\t\t\t\t\t\t\t\tin let <_92> =\n\t\t\t\t\t\t\t\t\t\tcall %% Line 765\n\t\t\t\t\t\t\t\t\t\t 'erlang':%% Line 765\n\t\t\t\t\t\t\t\t\t\t\t 'setelement'\n\t\t\t\t\t\t\t\t\t\t (%% Line 765\n\t\t\t\t\t\t\t\t\t\t 8, %% Line 763\n\t\t\t\t\t\t\t\t\t\t\tS, %% Line 765\n\t\t\t\t\t\t\t\t\t\t\t _rec63)\n\t\t\t\t\t\t\t\t\t in let <_93> =\n\t\t\t\t\t\t\t\t\t\t call %% Line 764\n\t\t\t\t\t\t\t\t\t\t\t 'erlang':%% Line 764\n\t\t\t\t\t\t\t\t\t\t\t\t 'setelement'\n\t\t\t\t\t\t\t\t\t\t\t(%% Line 764\n\t\t\t\t\t\t\t\t\t\t\t 7, _92, %% Line 764\n\t\t\t\t\t\t\t\t\t\t\t\t _rec62)\n\t\t\t\t\t\t\t\t\t\tin let <_95> =\n\t\t\t\t\t\t\t\t\t\t\tcall %% Line 763\n\t\t\t\t\t\t\t\t\t\t\t 'erlang':%% Line 763\n\t\t\t\t\t\t\t\t\t\t\t\t 'setelement'\n\t\t\t\t\t\t\t\t\t\t\t (%% Line 763\n\t\t\t\t\t\t\t\t\t\t\t 3, _93, %% Line 763\n\t\t\t\t\t\t\t\t\t\t\t\t _rec61)\n\t\t\t\t\t\t\t\t\t\t in %% Line 766\n\t\t\t\t\t\t\t\t\t\t\t{'noreply',_95}\n\t\t\t\t\t\t %% Line 772\n\t\t\t\t\t\t <( 'false'\n\t\t\t\t\t\t -| ['compiler_generated'] ),_360,_361,_362,_363,( {( 'value'\n\t\t\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] ),( {_X_AppName,Id}\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] )}\n\t\t\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\t\t\t\t\t%% Line 773\n\t\t\t\t\t\t\tcase call 'lists':'keyfind'\n\t\t\t\t\t\t\t\t (AppName, 1, _284) of\n\t\t\t\t\t\t\t <{_X_AppName2,Type}> when 'true' ->\n\t\t\t\t\t\t\t do %% Line 774\n\t\t\t\t\t\t\t\t apply 'stop_appl'/3\n\t\t\t\t\t\t\t\t (AppName, Id, Type)\n\t\t\t\t\t\t\t\t let =\n\t\t\t\t\t\t\t\t call %% Line 775\n\t\t\t\t\t\t\t\t\t 'lists':%% Line 775\n\t\t\t\t\t\t\t\t\t\t 'keydelete'\n\t\t\t\t\t\t\t\t\t (%% Line 775\n\t\t\t\t\t\t\t\t\t AppName, %% Line 775\n\t\t\t\t\t\t\t\t\t\t 1, _283)\n\t\t\t\t\t\t\t\t in let <_101> =\n\t\t\t\t\t\t\t\t\t call %% Line 776\n\t\t\t\t\t\t\t\t\t 'erlang':%% Line 776\n\t\t\t\t\t\t\t\t\t\t\t'setelement'\n\t\t\t\t\t\t\t\t\t (%% Line 776\n\t\t\t\t\t\t\t\t\t 5, %% Line 776\n\t\t\t\t\t\t\t\t\t\t S, %% Line 776\n\t\t\t\t\t\t\t\t\t\t NRunning)\n\t\t\t\t\t\t\t\t in %% Line 776\n\t\t\t\t\t\t\t\t\t {'reply','ok',_101}\n\t\t\t\t\t\t\t ( <_97> when 'true' ->\n\t\t\t\t\t\t\t\tprimop 'match_fail'\n\t\t\t\t\t\t\t\t ({'badmatch',_97})\n\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t\t\tend\n\t\t\t\t\t\t %% Line 778\n\t\t\t\t\t\t <( 'false'\n\t\t\t\t\t\t -| ['compiler_generated'] ),( 'false'\n\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] ),_373,_374,_375,_376> when 'true' ->\n\t\t\t\t\t\t\t%% Line 779\n\t\t\t\t\t\t\t{'reply',{'error',{'not_loaded',AppName}},S}\n\t\t\t\t\t\t %% Line 781\n\t\t\t\t\t\t <( 'false'\n\t\t\t\t\t\t -| ['compiler_generated'] ),( {( 'true'\n\t\t\t\t\t\t\t\t\t\t\t-| ['compiler_generated'] ),_X_Appl}\n\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] ),( 'false'\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] ),( 'false'\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] ),( 'false'\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] ),( 'false'\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\t\t\t\t\tdo %% Line 782\n\t\t\t\t\t\t\t apply 'update_permissions'/2\n\t\t\t\t\t\t\t\t(AppName, Bool)\n\t\t\t\t\t\t\t %% Line 783\n\t\t\t\t\t\t\t {'reply','ok',S}\n\t\t\t\t\t\t %% Line 785\n\t\t\t\t\t\t <( 'false'\n\t\t\t\t\t\t -| ['compiler_generated'] ),( {( 'true'\n\t\t\t\t\t\t\t\t\t\t\t-| ['compiler_generated'] ),_X_Appl}\n\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] ),( {( 'value'\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] ),_X_Tuple}\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] ),( 'false'\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] ),( 'false'\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] ),( 'false'\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\t\t\t\t\tdo %% Line 786\n\t\t\t\t\t\t\t apply 'update_permissions'/2\n\t\t\t\t\t\t\t\t(AppName, Bool)\n\t\t\t\t\t\t\t %% Line 787\n\t\t\t\t\t\t\t {'reply','ok',S}\n\t\t\t\t\t\t %% Line 789\n\t\t\t\t\t\t <( 'false'\n\t\t\t\t\t\t -| ['compiler_generated'] ),( {( 'true'\n\t\t\t\t\t\t\t\t\t\t\t-| ['compiler_generated'] ),_X_Appl}\n\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] ),( 'false'\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] ),( {( 'value'\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] ),_X_Tuple}\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] ),( 'false'\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] ),( 'false'\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\t\t\t\t\tdo %% Line 790\n\t\t\t\t\t\t\t apply 'update_permissions'/2\n\t\t\t\t\t\t\t\t(AppName, Bool)\n\t\t\t\t\t\t\t let <_rec66> =\n\t\t\t\t\t\t\t\tcall %% Line 791\n\t\t\t\t\t\t\t\t 'lists':%% Line 791\n\t\t\t\t\t\t\t\t\t 'keydelete'\n\t\t\t\t\t\t\t\t (%% Line 791\n\t\t\t\t\t\t\t\t AppName, %% Line 791\n\t\t\t\t\t\t\t\t\t 1, _282)\n\t\t\t\t\t\t\t in let <_105> =\n\t\t\t\t\t\t\t\t call %% Line 791\n\t\t\t\t\t\t\t\t\t 'erlang':%% Line 791\n\t\t\t\t\t\t\t\t\t\t 'setelement'\n\t\t\t\t\t\t\t\t\t(%% Line 791\n\t\t\t\t\t\t\t\t\t 4, %% Line 791\n\t\t\t\t\t\t\t\t\t S, %% Line 791\n\t\t\t\t\t\t\t\t\t _rec66)\n\t\t\t\t\t\t\t\tin %% Line 792\n\t\t\t\t\t\t\t\t {'reply','ok',_105}\n\t\t\t\t\t\t %% Line 794\n\t\t\t\t\t\t <( 'false'\n\t\t\t\t\t\t -| ['compiler_generated'] ),( {( 'true'\n\t\t\t\t\t\t\t\t\t\t\t-| ['compiler_generated'] ),_X_Appl}\n\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] ),_386,_387,( {( 'value'\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t-| ['compiler_generated'] ),_X_Tuple}\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] ),( 'false'\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\t\t\t\t\tdo %% Line 795\n\t\t\t\t\t\t\t apply 'update_permissions'/2\n\t\t\t\t\t\t\t\t(AppName, Bool)\n\t\t\t\t\t\t\t %% Line 796\n\t\t\t\t\t\t\t {'reply','ok',S}\n\t\t\t\t\t\t ( <( _569\n\t\t\t\t\t\t\t -| ['compiler_generated'] ),( _570\n\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] ),( _571\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] ),( _572\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] ),( _573\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] ),( _574\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\t\t\t\t\t let <_107> =\n\t\t\t\t\t\t\t {( _569\n\t\t\t\t\t\t\t\t -| ['compiler_generated'] ),( _570\n\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] ),( _571\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] ),( _572\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] ),( _573\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] ),( _574\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] )}\n\t\t\t\t\t\t\t in primop 'match_fail'\n\t\t\t\t\t\t\t\t ({'case_clause',_107})\n\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t\t end\n\t\t\t\t\t ( <_108> when 'true' ->\n\t\t\t\t\t\t primop 'match_fail'\n\t\t\t\t\t\t\t({'case_clause',_108})\n\t\t\t\t\t\t-| ['compiler_generated'] )\n\t\t\t\t\t end\n\t\t -| ['compiler_generated'] )\n\t\t ( <_287> when 'true' ->\n\t\t\t( call ( 'erlang'\n\t\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t (( {'badrecord','state'}\n\t\t\t\t -| ['compiler_generated'] ))\n\t\t\t -| ['compiler_generated'] )\n\t\t -| ['compiler_generated'] )\n\t\tend\n\t\t-| ['compiler_generated'] )\n\t %% Line 801\n\t <{'stop_application',AppName},_X_From,S> when 'true' ->\n\t %% Line 802\n\t case S of\n\t\t<{'state',_388,_389,_390,Running,_391,Started,_392,_393}> when 'true' ->\n\t\t %% Line 803\n\t\t case call 'lists':'keyfind'\n\t\t\t (AppName, 1, Running) of\n\t\t %% Line 804\n\t\t <{_X_AppName,Id}> when 'true' ->\n\t\t\t %% Line 805\n\t\t\t case call 'lists':'keyfind'\n\t\t\t\t (AppName, 1, Started) of\n\t\t\t <{_X_AppName2,Type}> when 'true' ->\n\t\t\t\tdo %% Line 806\n\t\t\t\t apply 'stop_appl'/3\n\t\t\t\t\t(AppName, Id, Type)\n\t\t\t\t let =\n\t\t\t\t\tcall %% Line 807\n\t\t\t\t\t 'lists':%% Line 807\n\t\t\t\t\t\t 'keydelete'\n\t\t\t\t\t (%% Line 807\n\t\t\t\t\t AppName, %% Line 807\n\t\t\t\t\t\t 1, %% Line 807\n\t\t\t\t\t\t\t Running)\n\t\t\t\t in let =\n\t\t\t\t\t call %% Line 808\n\t\t\t\t\t\t 'lists':%% Line 808\n\t\t\t\t\t\t\t 'keydelete'\n\t\t\t\t\t\t(%% Line 808\n\t\t\t\t\t\t AppName, %% Line 808\n\t\t\t\t\t\t\t 1, %% Line 808\n\t\t\t\t\t\t\t Started)\n\t\t\t\t\tin do %% Line 809\n\t\t\t\t\t\tapply 'cntrl'/3\n\t\t\t\t\t\t (AppName, S, {'ac_application_stopped',AppName})\n\t\t\t\t\t\tlet <_114> =\n\t\t\t\t\t\t call %% Line 810\n\t\t\t\t\t\t\t 'erlang':%% Line 810\n\t\t\t\t\t\t\t\t 'setelement'\n\t\t\t\t\t\t\t(%% Line 810\n\t\t\t\t\t\t\t 7, %% Line 810\n\t\t\t\t\t\t\t S, %% Line 810\n\t\t\t\t\t\t\t NStarted)\n\t\t\t\t\t\tin let <_116> =\n\t\t\t\t\t\t\tcall %% Line 810\n\t\t\t\t\t\t\t 'erlang':%% Line 810\n\t\t\t\t\t\t\t\t 'setelement'\n\t\t\t\t\t\t\t (%% Line 810\n\t\t\t\t\t\t\t 5, _114, %% Line 810\n\t\t\t\t\t\t\t\t NRunning)\n\t\t\t\t\t\t in %% Line 810\n\t\t\t\t\t\t\t{'reply','ok',_116}\n\t\t\t ( <_110> when 'true' ->\n\t\t\t\t primop 'match_fail'\n\t\t\t\t ({'badmatch',_110})\n\t\t\t -| ['compiler_generated'] )\n\t\t\t end\n\t\t %% Line 811\n\t\t <'false'> when 'true' ->\n\t\t\t %% Line 812\n\t\t\t case call 'lists':'keymember'\n\t\t\t\t (AppName, 1, Started) of\n\t\t\t %% Line 813\n\t\t\t <'true'> when 'true' ->\n\t\t\t\tlet =\n\t\t\t\t call %% Line 814\n\t\t\t\t\t 'lists':%% Line 814\n\t\t\t\t\t\t 'keydelete'\n\t\t\t\t\t(%% Line 814\n\t\t\t\t\t AppName, %% Line 814\n\t\t\t\t\t\t 1, %% Line 814\n\t\t\t\t\t\t Started)\n\t\t\t\tin do %% Line 815\n\t\t\t\t\tapply 'cntrl'/3\n\t\t\t\t\t (AppName, S, {'ac_application_stopped',AppName})\n\t\t\t\t\tlet <_120> =\n\t\t\t\t\t call %% Line 816\n\t\t\t\t\t\t 'erlang':%% Line 816\n\t\t\t\t\t\t\t 'setelement'\n\t\t\t\t\t\t(%% Line 816\n\t\t\t\t\t\t 7, %% Line 816\n\t\t\t\t\t\t S, %% Line 816\n\t\t\t\t\t\t NStarted)\n\t\t\t\t\tin %% Line 816\n\t\t\t\t\t {'reply','ok',_120}\n\t\t\t %% Line 817\n\t\t\t <'false'> when 'true' ->\n\t\t\t\t%% Line 818\n\t\t\t\t{'reply',{'error',{'not_started',AppName}},S}\n\t\t\t ( <_121> when 'true' ->\n\t\t\t\t primop 'match_fail'\n\t\t\t\t ({'case_clause',_121})\n\t\t\t -| ['compiler_generated'] )\n\t\t\t end\n\t\t ( <_122> when 'true' ->\n\t\t\t primop 'match_fail'\n\t\t\t\t({'case_clause',_122})\n\t\t\t-| ['compiler_generated'] )\n\t\t end\n\t\t( <_109> when 'true' ->\n\t\t primop 'match_fail'\n\t\t\t ({'badmatch',_109})\n\t\t -| ['compiler_generated'] )\n\t end\n\t %% Line 822\n\t <{'change_application_data',Applications,Config},_X_From,S> when 'true' ->\n\t let <_125> =\n\t\t fun (_123) ->\n\t\t %% Line 824\n\t\t case _123 of\n\t\t\t<[{{'loaded',_X_AppName},Appl}|[]]> when 'true' ->\n\t\t\t %% Line 825\n\t\t\t {'true',Appl}\n\t\t\t%% Line 826\n\t\t\t<_412> when 'true' ->\n\t\t\t %% Line 827\n\t\t\t 'false'\n\t\t end\n\t in let =\n\t\t call %% Line 823\n\t\t\t 'ets':%% Line 823\n\t\t\t\t 'filter'\n\t\t\t (%% Line 823\n\t\t\t 'ac_tab', _125, %% Line 829\n\t\t\t\t\t [])\n\t\t in let <_127> =\n\t\t\t catch\n\t\t\t %% Line 830\n\t\t\t apply 'do_change_apps'/3\n\t\t\t\t (Applications, Config, OldAppls)\n\t\t in %% Line 830\n\t\t\t case _127 of\n\t\t\t %% Line 831\n\t\t\t when 'true' ->\n\t\t\t\t%% Line 832\n\t\t\t\t{'reply',Error,S}\n\t\t\t %% Line 833\n\t\t\t <{'EXIT',R}> when 'true' ->\n\t\t\t\t%% Line 834\n\t\t\t\t{'reply',{'error',R},S}\n\t\t\t %% Line 835\n\t\t\t <{NewAppls,NewConfig}> when 'true' ->\n\t\t\t\tlet <_132> =\n\t\t\t\t fun (_130) ->\n\t\t\t\t\t%% Line 837\n\t\t\t\t\t( case _130 of\n\t\t\t\t\t ( <( {'appl',_rec70,_414,_415,_416,_417,_418,_419,_420}\n\t\t\t\t\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\t\t\t\t call 'ets':'insert'\n\t\t\t\t\t\t ('ac_tab', {{'loaded',_rec70},_130})\n\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t ( <_421> when 'true' ->\n\t\t\t\t\t\t ( call ( 'erlang'\n\t\t\t\t\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t\t\t(( {'badrecord','appl'}\n\t\t\t\t\t\t\t -| ['compiler_generated'] ))\n\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t end\n\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\tin do %% Line 836\n\t\t\t\t\tcall 'lists':'foreach'\n\t\t\t\t\t (_132, %% Line 839\n\t\t\t\t\t\t NewAppls)\n\t\t\t\t\t%% Line 840\n\t\t\t\t\tcase S of\n\t\t\t\t\t <{'state',_422,_423,_424,_425,_426,_427,_428,_429}> when 'true' ->\n\t\t\t\t\t let <_135> =\n\t\t\t\t\t\t call 'erlang':'setelement'\n\t\t\t\t\t\t (9, S, NewConfig)\n\t\t\t\t\t in {'reply','ok',_135}\n\t\t\t\t\t ( <_430> when 'true' ->\n\t\t\t\t\t\t( call ( 'erlang'\n\t\t\t\t\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t\t (( {'badrecord','state'}\n\t\t\t\t\t\t\t -| ['compiler_generated'] ))\n\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\tend\n\t\t\t ( <_136> when 'true' ->\n\t\t\t\t primop 'match_fail'\n\t\t\t\t ({'case_clause',_136})\n\t\t\t -| ['compiler_generated'] )\n\t\t\t end\n\t %% Line 843\n\t <'prep_config_change',_X_From,S> when 'true' ->\n\t %% Line 844\n\t ( case S of\n\t\t ( <( {'state',_431,_432,_433,_rec72,_434,_435,_436,_437}\n\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\tlet <_140> =\n\t\t\t apply %% Line 845\n\t\t\t\t 'do_prep_config_change'/1\n\t\t\t\t(_rec72)\n\t\t\tin let =\n\t\t\t\tcall %% Line 845\n\t\t\t\t 'lists':%% Line 845\n\t\t\t\t\t 'reverse'\n\t\t\t\t (_140)\n\t\t\t in %% Line 846\n\t\t\t\t{'reply',EnvBefore,S}\n\t\t -| ['compiler_generated'] )\n\t\t ( <_438> when 'true' ->\n\t\t\t( call ( 'erlang'\n\t\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t (( {'badrecord','state'}\n\t\t\t\t -| ['compiler_generated'] ))\n\t\t\t -| ['compiler_generated'] )\n\t\t -| ['compiler_generated'] )\n\t\tend\n\t\t-| ['compiler_generated'] )\n\t %% Line 848\n\t <{'config_change',EnvBefore},_X_From,S> when 'true' ->\n\t %% Line 849\n\t ( case S of\n\t\t ( <( {'state',_439,_440,_441,_rec73,_442,_443,_444,_445}\n\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\tlet =\n\t\t\t apply %% Line 850\n\t\t\t\t 'do_config_change'/2\n\t\t\t\t(_rec73, %% Line 850\n\t\t\t\t\t EnvBefore)\n\t\t\tin %% Line 851\n\t\t\t {'reply',R,S}\n\t\t -| ['compiler_generated'] )\n\t\t ( <_446> when 'true' ->\n\t\t\t( call ( 'erlang'\n\t\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t (( {'badrecord','state'}\n\t\t\t\t -| ['compiler_generated'] ))\n\t\t\t -| ['compiler_generated'] )\n\t\t -| ['compiler_generated'] )\n\t\tend\n\t\t-| ['compiler_generated'] )\n\t %% Line 853\n\t <'which_applications',_X_From,S> when 'true' ->\n\t let <_152> =\n\t\t fun (_150) ->\n\t\t %% Line 854\n\t\t case _150 of\n\t\t\t<{Name,Id}> when 'true' ->\n\t\t\t %% Line 855\n\t\t\t case Id of\n\t\t\t %% Line 856\n\t\t\t <{'distributed',_X_Node}> when 'true' ->\n\t\t\t\t %% Line 857\n\t\t\t\t 'false'\n\t\t\t %% Line 858\n\t\t\t <_447> when 'true' ->\n\t\t\t\t %% Line 859\n\t\t\t\t case %% Line 860\n\t\t\t\t apply 'get_loaded'/1\n\t\t\t\t\t (Name) of\n\t\t\t\t <{'true',{'appl',_448,_449,Descr,_450,Vsn,_451,_452,_453}}> when 'true' ->\n\t\t\t\t\t%% Line 861\n\t\t\t\t\t{'true',{Name,Descr,Vsn}}\n\t\t\t\t ( <_148> when 'true' ->\n\t\t\t\t\t primop 'match_fail'\n\t\t\t\t\t ({'badmatch',_148})\n\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t end\n\t\t\t end\n\t\t\t( <_151> when 'true' ->\n\t\t\t ( primop 'match_fail'\n\t\t\t\t ({'function_clause',_151})\n\t\t\t\t-| [{'function_name',{'-handle_call/3-fun-2-',1}}] )\n\t\t\t -| ['compiler_generated'] )\n\t\t end\n\t in %% Line 863\n\t\t ( case S of\n\t\t ( <( {'state',_454,_455,_456,_rec74,_457,_458,_459,_460}\n\t\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\t let =\n\t\t\t\tcall 'lists':'zf'\n\t\t\t\t (_152, _rec74)\n\t\t\t in %% Line 864\n\t\t\t\t{'reply',Reply,S}\n\t\t\t-| ['compiler_generated'] )\n\t\t ( <_461> when 'true' ->\n\t\t\t ( call ( 'erlang'\n\t\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t (( {'badrecord','state'}\n\t\t\t\t -| ['compiler_generated'] ))\n\t\t\t -| ['compiler_generated'] )\n\t\t\t-| ['compiler_generated'] )\n\t\t end\n\t\t -| ['compiler_generated'] )\n\t %% Line 866\n\t <{'set_env',AppName,Key,Val,Opts},_X_From,S> when 'true' ->\n\t do %% Line 867\n\t\t call 'ets':'insert'\n\t\t ('ac_tab', {{'env',AppName,Key},Val})\n\t\t %% Line 868\n\t\t case call 'proplists':'get_value'\n\t\t\t ('persistent', Opts, 'false') of\n\t\t %% Line 869\n\t\t <'true'> when 'true' ->\n\t\t\tlet =\n\t\t\t fun (_154) ->\n\t\t\t\t%% Line 870\n\t\t\t\tcall 'lists':'keystore'\n\t\t\t\t (Key, 1, _154, {Key,Val})\n\t\t\tin %% Line 871\n\t\t\t ( case S of\n\t\t\t\t( <( {'state',_462,_463,_464,_465,_466,_467,_468,_rec77}\n\t\t\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\t\t let <_rec75> =\n\t\t\t\t\t apply 'change_app_env'/3\n\t\t\t\t\t (_rec77, AppName, Fun)\n\t\t\t\t in let <_162> =\n\t\t\t\t\t call 'erlang':'setelement'\n\t\t\t\t\t\t (9, S, _rec75)\n\t\t\t\t\t in {'reply','ok',_162}\n\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t( <_469> when 'true' ->\n\t\t\t\t ( call ( 'erlang'\n\t\t\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t (( {'badrecord','state'}\n\t\t\t\t\t -| ['compiler_generated'] ))\n\t\t\t\t\t-| ['compiler_generated'] )\n\t\t\t\t -| ['compiler_generated'] )\n\t\t\t end\n\t\t\t -| ['compiler_generated'] )\n\t\t %% Line 872\n\t\t <'false'> when 'true' ->\n\t\t\t%% Line 873\n\t\t\t{'reply','ok',S}\n\t\t ( <_163> when 'true' ->\n\t\t\t primop 'match_fail'\n\t\t\t ({'case_clause',_163})\n\t\t -| ['compiler_generated'] )\n\t\t end\n\t %% Line 876\n\t <{'unset_env',AppName,Key,Opts},_X_From,S> when 'true' ->\n\t do %% Line 877\n\t\t call 'ets':'delete'\n\t\t ('ac_tab', {'env',AppName,Key})\n\t\t %% Line 878\n\t\t case call 'proplists':'get_value'\n\t\t\t ('persistent', Opts, 'false') of\n\t\t %% Line 879\n\t\t <'true'> when 'true' ->\n\t\t\tlet =\n\t\t\t fun (_164) ->\n\t\t\t\t%% Line 880\n\t\t\t\tcall 'lists':'keydelete'\n\t\t\t\t (Key, 1, _164)\n\t\t\tin %% Line 881\n\t\t\t ( case S of\n\t\t\t\t( <( {'state',_479,_480,_481,_482,_483,_484,_485,_rec80}\n\t\t\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\t\t let <_rec78> =\n\t\t\t\t\t apply 'change_app_env'/3\n\t\t\t\t\t (_rec80, AppName, Fun)\n\t\t\t\t in let <_172> =\n\t\t\t\t\t call 'erlang':'setelement'\n\t\t\t\t\t\t (9, S, _rec78)\n\t\t\t\t\t in {'reply','ok',_172}\n\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t( <_486> when 'true' ->\n\t\t\t\t ( call ( 'erlang'\n\t\t\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t (( {'badrecord','state'}\n\t\t\t\t\t -| ['compiler_generated'] ))\n\t\t\t\t\t-| ['compiler_generated'] )\n\t\t\t\t -| ['compiler_generated'] )\n\t\t\t end\n\t\t\t -| ['compiler_generated'] )\n\t\t %% Line 882\n\t\t <'false'> when 'true' ->\n\t\t\t%% Line 883\n\t\t\t{'reply','ok',S}\n\t\t ( <_173> when 'true' ->\n\t\t\t primop 'match_fail'\n\t\t\t ({'case_clause',_173})\n\t\t -| ['compiler_generated'] )\n\t\t end\n\t %% Line 886\n\t <{'control_application',AppName},{Pid,_X_Tag},S> when 'true' ->\n\t %% Line 887\n\t ( case S of\n\t\t ( <( {'state',_496,_497,_498,_499,_rec81,_500,_501,_502}\n\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\t%% Line 888\n\t\t\tcase call 'lists':'keymember'\n\t\t\t\t (AppName, 1, _rec81) of\n\t\t\t %% Line 889\n\t\t\t <'false'> when 'true' ->\n\t\t\t do %% Line 890\n\t\t\t\t call 'erlang':'link'\n\t\t\t\t (Pid)\n\t\t\t\t let <_rec82> =\n\t\t\t\t [%% Line 891\n\t\t\t\t {AppName,Pid}|_rec81]\n\t\t\t\t in let <_180> =\n\t\t\t\t\t call %% Line 891\n\t\t\t\t\t 'erlang':%% Line 891\n\t\t\t\t\t\t\t'setelement'\n\t\t\t\t\t (%% Line 891\n\t\t\t\t\t 6, %% Line 891\n\t\t\t\t\t\t S, %% Line 891\n\t\t\t\t\t\t _rec82)\n\t\t\t\t in %% Line 891\n\t\t\t\t\t {'reply','true',_180}\n\t\t\t %% Line 892\n\t\t\t <'true'> when 'true' ->\n\t\t\t %% Line 893\n\t\t\t {'reply','false',S}\n\t\t\t ( <_181> when 'true' ->\n\t\t\t\tprimop 'match_fail'\n\t\t\t\t ({'case_clause',_181})\n\t\t\t -| ['compiler_generated'] )\n\t\t\tend\n\t\t -| ['compiler_generated'] )\n\t\t ( <_503> when 'true' ->\n\t\t\t( call ( 'erlang'\n\t\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t (( {'badrecord','state'}\n\t\t\t\t -| ['compiler_generated'] ))\n\t\t\t -| ['compiler_generated'] )\n\t\t -| ['compiler_generated'] )\n\t\tend\n\t\t-| ['compiler_generated'] )\n\t %% Line 896\n\t <{'start_type',AppName},_X_From,S> when 'true' ->\n\t %% Line 897\n\t ( case S of\n\t\t ( <( {'state',_513,_rec84,_514,_515,_516,_517,_518,_519}\n\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\tlet <_186> =\n\t\t\t case %% Line 898\n\t\t\t\t call 'lists':'keyfind'\n\t\t\t\t (AppName, 1, _rec84) of\n\t\t\t %% Line 899\n\t\t\t <'false'> when 'true' ->\n\t\t\t\t %% Line 900\n\t\t\t\t 'local'\n\t\t\t %% Line 901\n\t\t\t <{_X_AppName,_X_RestartType,Type,_X_F}> when 'true' ->\n\t\t\t\t %% Line 902\n\t\t\t\t Type\n\t\t\t ( <_185> when 'true' ->\n\t\t\t\t %% Line 898\n\t\t\t\t primop 'match_fail'\n\t\t\t\t\t({'case_clause',_185})\n\t\t\t\t-| ['compiler_generated'] )\n\t\t\t end\n\t\t\tin %% Line 904\n\t\t\t {'reply',_186,S}\n\t\t -| ['compiler_generated'] )\n\t\t ( <_520> when 'true' ->\n\t\t\t( call ( 'erlang'\n\t\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t (( {'badrecord','state'}\n\t\t\t\t -| ['compiler_generated'] ))\n\t\t\t -| ['compiler_generated'] )\n\t\t -| ['compiler_generated'] )\n\t\tend\n\t\t-| ['compiler_generated'] )\n\t %% Line 906\n\t <'info',_X_From,S> when 'true' ->\n\t let <_188> =\n\t\t apply %% Line 907\n\t\t\t'loaded_applications'/0\n\t\t ()\n\t in %% Line 908\n\t\t ( case S of\n\t\t ( <( {'state',_rec85,_521,_522,_523,_524,_525,_526,_527}\n\t\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\t let =\n\t\t\t\t[{'loaded',_188}|[{'loading',_rec85}|%% Line 909\n\t\t\t\t\t\t\t\t [{'started',_525}|%% Line 910\n\t\t\t\t\t\t\t\t\t\t [{'start_p_false',_522}|%% Line 911\n\t\t\t\t\t\t\t\t\t\t\t\t\t [{'running',_523}|%% Line 912\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t [{'starting',_521}|[]]]]]]]\n\t\t\t in %% Line 913\n\t\t\t\t{'reply',Reply,S}\n\t\t\t-| ['compiler_generated'] )\n\t\t ( <_528> when 'true' ->\n\t\t\t ( call ( 'erlang'\n\t\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t (( {'badrecord','state'}\n\t\t\t\t -| ['compiler_generated'] ))\n\t\t\t -| ['compiler_generated'] )\n\t\t\t-| ['compiler_generated'] )\n\t\t end\n\t\t -| ['compiler_generated'] )\n\t ( <_202,_201,_200> when 'true' ->\n\t\t( primop 'match_fail'\n\t\t ({'function_clause',_202,_201,_200})\n\t\t -| [{'function_name',{'handle_call',3}}] )\n\t -| ['compiler_generated'] )\n\tend\n'handle_cast'/2 =\n %% Line 918\n fun (_1,_0) ->\n\tcase <_1,_0> of\n\t <{'application_started',AppName,Res},S> when 'true' ->\n\t %% Line 919\n\t apply 'handle_application_started'/3\n\t\t (AppName, Res, S)\n\t ( <_3,_2> when 'true' ->\n\t\t( primop 'match_fail'\n\t\t ({'function_clause',_3,_2})\n\t\t -| [{'function_name',{'handle_cast',2}}] )\n\t -| ['compiler_generated'] )\n\tend\n'handle_application_started'/3 =\n %% Line 921\n fun (_2,_1,_0) ->\n\t%% Line 923\n\tcase _0 of\n\t <{'state',_63,Starting,_64,Running,_65,Started,Start_req,_66}> when 'true' ->\n\t let =\n\t\t apply %% Line 924\n\t\t\t'reply_to_requester'/3\n\t\t (_2, %% Line 924\n\t\t\t Start_req, _1)\n\t in %% Line 925\n\t\t case call 'lists':'keyfind'\n\t\t\t (_2, 1, Starting) of\n\t\t <{_X_AppName,RestartType,_X_Type,_X_From}> when 'true' ->\n\t\t\t%% Line 926\n\t\t\tcase _1 of\n\t\t\t %% Line 927\n\t\t\t <{'ok',Id}> when 'true' ->\n\t\t\t do %% Line 928\n\t\t\t\t case _2 of\n\t\t\t\t %% Line 929\n\t\t\t\t <'kernel'> when 'true' ->\n\t\t\t\t\tapply 'check_user'/0\n\t\t\t\t\t ()\n\t\t\t\t %% Line 930\n\t\t\t\t <_67> when 'true' ->\n\t\t\t\t\t'ok'\n\t\t\t\t end\n\t\t\t\t let <_7> =\n\t\t\t\t apply %% Line 932\n\t\t\t\t\t 'nd'/1\n\t\t\t\t\t (%% Line 932\n\t\t\t\t\t Id)\n\t\t\t\t in do %% Line 932\n\t\t\t\t\t apply 'info_started'/2\n\t\t\t\t\t (_2, _7)\n\t\t\t\t\t do %% Line 933\n\t\t\t\t\t apply 'notify_cntrl_started'/4\n\t\t\t\t\t\t (_2, Id, _0, 'ok')\n\t\t\t\t\t let =\n\t\t\t\t\t\t apply %% Line 934\n\t\t\t\t\t\t\t'keyreplaceadd'/4\n\t\t\t\t\t\t (_2, %% Line 934\n\t\t\t\t\t\t\t 1, %% Line 934\n\t\t\t\t\t\t\t Running, %% Line 934\n\t\t\t\t\t\t\t\t {_2,Id})\n\t\t\t\t\t in let =\n\t\t\t\t\t\t apply %% Line 935\n\t\t\t\t\t\t\t 'keyreplaceadd'/4\n\t\t\t\t\t\t\t (_2, %% Line 935\n\t\t\t\t\t\t\t 1, %% Line 935\n\t\t\t\t\t\t\t\t Started, %% Line 935\n\t\t\t\t\t\t\t\t\t {_2,RestartType})\n\t\t\t\t\t\t in let <_rec90> =\n\t\t\t\t\t\t\t call %% Line 936\n\t\t\t\t\t\t\t 'lists':%% Line 936\n\t\t\t\t\t\t\t\t 'keydelete'\n\t\t\t\t\t\t\t (_2, %% Line 936\n\t\t\t\t\t\t\t\t 1, %% Line 936\n\t\t\t\t\t\t\t\t Starting)\n\t\t\t\t\t\t in let <_12> =\n\t\t\t\t\t\t\t call %% Line 939\n\t\t\t\t\t\t\t\t 'erlang':%% Line 939\n\t\t\t\t\t\t\t\t\t 'setelement'\n\t\t\t\t\t\t\t\t (%% Line 939\n\t\t\t\t\t\t\t\t 8, _0, %% Line 939\n\t\t\t\t\t\t\t\t\t Start_reqN)\n\t\t\t\t\t\t\t in let <_13> =\n\t\t\t\t\t\t\t\t call %% Line 938\n\t\t\t\t\t\t\t\t 'erlang':%% Line 938\n\t\t\t\t\t\t\t\t\t\t'setelement'\n\t\t\t\t\t\t\t\t (%% Line 938\n\t\t\t\t\t\t\t\t 7, _12, %% Line 938\n\t\t\t\t\t\t\t\t\t NStarted)\n\t\t\t\t\t\t\t in let <_14> =\n\t\t\t\t\t\t\t\t call %% Line 937\n\t\t\t\t\t\t\t\t\t 'erlang':%% Line 937\n\t\t\t\t\t\t\t\t\t\t 'setelement'\n\t\t\t\t\t\t\t\t\t (%% Line 937\n\t\t\t\t\t\t\t\t\t 5, _13, %% Line 937\n\t\t\t\t\t\t\t\t\t\t NRunning)\n\t\t\t\t\t\t\t\t in let <_16> =\n\t\t\t\t\t\t\t\t\t call %% Line 936\n\t\t\t\t\t\t\t\t\t 'erlang':%% Line 936\n\t\t\t\t\t\t\t\t\t\t\t'setelement'\n\t\t\t\t\t\t\t\t\t (%% Line 936\n\t\t\t\t\t\t\t\t\t 3, _14, %% Line 936\n\t\t\t\t\t\t\t\t\t\t _rec90)\n\t\t\t\t\t\t\t\t in let =\n\t\t\t\t\t\t\t\t\t call %% Line 941\n\t\t\t\t\t\t\t\t\t\t 'application':%% Line 941\n\t\t\t\t\t\t\t\t\t\t\t\t 'get_env'\n\t\t\t\t\t\t\t\t\t\t (%% Line 941\n\t\t\t\t\t\t\t\t\t\t 'kernel', %% Line 941\n\t\t\t\t\t\t\t\t\t\t\t 'permissions')\n\t\t\t\t\t\t\t\t\t in %% Line 942\n\t\t\t\t\t\t\t\t\t case of\n\t\t\t\t\t\t\t\t\t\t%% Line 943\n\t\t\t\t\t\t\t\t\t\t<( 'undefined'\n\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] ),_77> when 'true' ->\n\t\t\t\t\t\t\t\t\t\t %% Line 944\n\t\t\t\t\t\t\t\t\t\t {'noreply',_16}\n\t\t\t\t\t\t\t\t\t\t%% Line 946\n\t\t\t\t\t\t\t\t\t\t<( {( 'ok'\n\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] ),Perms}\n\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] ),( {( 'distributed'\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] ),StartNode}\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] )>\n\t\t\t\t\t\t\t\t\t\t when try\n\t\t\t\t\t\t\t\t\t\t\t let <_19> =\n\t\t\t\t\t\t\t\t\t\t\t call 'erlang':'node'\n\t\t\t\t\t\t\t\t\t\t\t\t ()\n\t\t\t\t\t\t\t\t\t\t\t in call 'erlang':'=:='\n\t\t\t\t\t\t\t\t\t\t\t\t (StartNode, _19)\n\t\t\t\t\t\t\t\t\t\t of ->\n\t\t\t\t\t\t\t\t\t\t\t Try\n\t\t\t\t\t\t\t\t\t\t catch ->\n\t\t\t\t\t\t\t\t\t\t\t 'false' ->\n\t\t\t\t\t\t\t\t\t\t %% Line 947\n\t\t\t\t\t\t\t\t\t\t case call 'lists':'member'\n\t\t\t\t\t\t\t\t\t\t\t ({_2,'false'}, Perms) of\n\t\t\t\t\t\t\t\t\t\t %% Line 948\n\t\t\t\t\t\t\t\t\t\t <'true'> when 'true' ->\n\t\t\t\t\t\t\t\t\t\t\t %% Line 949\n\t\t\t\t\t\t\t\t\t\t\t case _16 of\n\t\t\t\t\t\t\t\t\t\t\t <{'state',_78,_79,_80,StopRunning,_81,StopStarted,_82,_83}> when 'true' ->\n\t\t\t\t\t\t\t\t\t\t\t\t%% Line 950\n\t\t\t\t\t\t\t\t\t\t\t\tcase call 'lists':'keyfind'\n\t\t\t\t\t\t\t\t\t\t\t\t\t (_2, 1, StopRunning) of\n\t\t\t\t\t\t\t\t\t\t\t\t %% Line 951\n\t\t\t\t\t\t\t\t\t\t\t\t <{_84,_85}>\n\t\t\t\t\t\t\t\t\t\t\t\t when let <_86> =\n\t\t\t\t\t\t\t\t\t\t\t\t\t call 'erlang':'=:='\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t(_84, _X_AppName)\n\t\t\t\t\t\t\t\t\t\t\t\t\tin let <_87> =\n\t\t\t\t\t\t\t\t\t\t\t\t\t\tcall 'erlang':'=:='\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t (_85, Id)\n\t\t\t\t\t\t\t\t\t\t\t\t\t in call 'erlang':'and'\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t (_86, _87) ->\n\t\t\t\t\t\t\t\t\t\t\t\t %% Line 952\n\t\t\t\t\t\t\t\t\t\t\t\t case %% Line 953\n\t\t\t\t\t\t\t\t\t\t\t\t\t call 'lists':'keyfind'\n\t\t\t\t\t\t\t\t\t\t\t\t\t (_2, 1, StopStarted) of\n\t\t\t\t\t\t\t\t\t\t\t\t\t<{_X_AppName2,Type}> when 'true' ->\n\t\t\t\t\t\t\t\t\t\t\t\t\t do %% Line 954\n\t\t\t\t\t\t\t\t\t\t\t\t\t\tapply 'stop_appl'/3\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t (_2, Id, Type)\n\t\t\t\t\t\t\t\t\t\t\t\t\t\tlet =\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t call %% Line 955\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t 'lists':%% Line 955\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t 'keydelete'\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t(_2, %% Line 955\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t 1, %% Line 955\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\tStopRunning)\n\t\t\t\t\t\t\t\t\t\t\t\t\t\tin do %% Line 956\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\tapply 'cntrl'/3\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t (_2, _16, {'ac_application_stopped',_2})\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\tlet <_24> =\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t call %% Line 958\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t 'erlang':%% Line 958\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t 'setelement'\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t(%% Line 958\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t 7, _16, %% Line 958\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t StopStarted)\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\tin let <_26> =\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\tcall %% Line 957\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t 'erlang':%% Line 957\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t 'setelement'\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t (%% Line 957\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t 5, _24, %% Line 957\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t NStopRunning)\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t in %% Line 957\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t{'noreply',_26}\n\t\t\t\t\t\t\t\t\t\t\t\t\t( <_21> when 'true' ->\n\t\t\t\t\t\t\t\t\t\t\t\t\t primop 'match_fail'\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t ({'badmatch',_21})\n\t\t\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t\t\t\t\t\t\t\t end\n\t\t\t\t\t\t\t\t\t\t\t\t %% Line 959\n\t\t\t\t\t\t\t\t\t\t\t\t <'false'> when 'true' ->\n\t\t\t\t\t\t\t\t\t\t\t\t %% Line 960\n\t\t\t\t\t\t\t\t\t\t\t\t {'noreply',_16}\n\t\t\t\t\t\t\t\t\t\t\t\t ( <_27> when 'true' ->\n\t\t\t\t\t\t\t\t\t\t\t\t\tprimop 'match_fail'\n\t\t\t\t\t\t\t\t\t\t\t\t\t ({'case_clause',_27})\n\t\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t\t\t\t\t\t\t\tend\n\t\t\t\t\t\t\t\t\t\t\t ( <_20> when 'true' ->\n\t\t\t\t\t\t\t\t\t\t\t\t primop 'match_fail'\n\t\t\t\t\t\t\t\t\t\t\t\t ({'badmatch',_20})\n\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t\t\t\t\t\t\t end\n\t\t\t\t\t\t\t\t\t\t %% Line 962\n\t\t\t\t\t\t\t\t\t\t <'false'> when 'true' ->\n\t\t\t\t\t\t\t\t\t\t\t %% Line 963\n\t\t\t\t\t\t\t\t\t\t\t {'noreply',_16}\n\t\t\t\t\t\t\t\t\t\t ( <_28> when 'true' ->\n\t\t\t\t\t\t\t\t\t\t\t primop 'match_fail'\n\t\t\t\t\t\t\t\t\t\t\t\t({'case_clause',_28})\n\t\t\t\t\t\t\t\t\t\t\t-| ['compiler_generated'] )\n\t\t\t\t\t\t\t\t\t\t end\n\t\t\t\t\t\t\t\t\t\t%% Line 965\n\t\t\t\t\t\t\t\t\t\t<( _126\n\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] ),( _127\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\t\t\t\t\t\t\t\t %% Line 966\n\t\t\t\t\t\t\t\t\t\t {'noreply',_16}\n\t\t\t\t\t\t\t\t\t end\n\t\t\t %% Line 968\n\t\t\t \n\t\t\t when call 'erlang':'=:='\n\t\t\t\t (RestartType,\n\t\t\t\t 'temporary') ->\n\t\t\t do %% Line 969\n\t\t\t\t apply 'notify_cntrl_started'/4\n\t\t\t\t (_2, 'undefined', _0, Error)\n\t\t\t\t do %% Line 970\n\t\t\t\t apply 'info_exited'/3\n\t\t\t\t\t (_2, R, RestartType)\n\t\t\t\t let <_rec93> =\n\t\t\t\t\t call %% Line 971\n\t\t\t\t\t 'lists':%% Line 971\n\t\t\t\t\t\t 'keydelete'\n\t\t\t\t\t (_2, %% Line 971\n\t\t\t\t\t\t 1, %% Line 971\n\t\t\t\t\t\t Starting)\n\t\t\t\t in let <_32> =\n\t\t\t\t\t call %% Line 972\n\t\t\t\t\t\t 'erlang':%% Line 972\n\t\t\t\t\t\t\t 'setelement'\n\t\t\t\t\t\t (%% Line 972\n\t\t\t\t\t\t 8, _0, %% Line 972\n\t\t\t\t\t\t\t Start_reqN)\n\t\t\t\t\t in let <_34> =\n\t\t\t\t\t\t call %% Line 971\n\t\t\t\t\t\t 'erlang':%% Line 971\n\t\t\t\t\t\t\t\t'setelement'\n\t\t\t\t\t\t (%% Line 971\n\t\t\t\t\t\t 3, _32, %% Line 971\n\t\t\t\t\t\t\t _rec93)\n\t\t\t\t\t in %% Line 971\n\t\t\t\t\t\t {'noreply',_34}\n\t\t\t %% Line 973\n\t\t\t <{'info',R}>\n\t\t\t when call 'erlang':'=:='\n\t\t\t\t (RestartType,\n\t\t\t\t 'temporary') ->\n\t\t\t do %% Line 974\n\t\t\t\t apply 'notify_cntrl_started'/4\n\t\t\t\t (_2, 'undefined', _0, {'error',R})\n\t\t\t\t let <_rec95> =\n\t\t\t\t call %% Line 975\n\t\t\t\t\t 'lists':%% Line 975\n\t\t\t\t\t\t 'keydelete'\n\t\t\t\t\t (_2, %% Line 975\n\t\t\t\t\t 1, %% Line 975\n\t\t\t\t\t\t Starting)\n\t\t\t\t in let <_37> =\n\t\t\t\t\t call %% Line 976\n\t\t\t\t\t 'erlang':%% Line 976\n\t\t\t\t\t\t\t'setelement'\n\t\t\t\t\t (%% Line 976\n\t\t\t\t\t 8, _0, %% Line 976\n\t\t\t\t\t\t Start_reqN)\n\t\t\t\t in let <_39> =\n\t\t\t\t\t call %% Line 975\n\t\t\t\t\t\t 'erlang':%% Line 975\n\t\t\t\t\t\t\t 'setelement'\n\t\t\t\t\t\t (%% Line 975\n\t\t\t\t\t\t 3, _37, %% Line 975\n\t\t\t\t\t\t\t _rec95)\n\t\t\t\t\t in %% Line 975\n\t\t\t\t\t {'noreply',_39}\n\t\t\t %% Line 977\n\t\t\t <{ErrInf,R}>\n\t\t\t when let <_40> =\n\t\t\t\t call 'erlang':'=:='\n\t\t\t\t\t(RestartType, 'transient')\n\t\t\t\tin let <_41> =\n\t\t\t\t\tcall 'erlang':'=:='\n\t\t\t\t\t (ErrInf, 'error')\n\t\t\t\t in let <_42> =\n\t\t\t\t\t call 'erlang':'and'\n\t\t\t\t\t\t(_40, _41)\n\t\t\t\t\tin let <_43> =\n\t\t\t\t\t\tcall %% Line 978\n\t\t\t\t\t\t 'erlang':%% Line 978\n\t\t\t\t\t\t\t '=:='\n\t\t\t\t\t\t (%% Line 978\n\t\t\t\t\t\t RestartType, %% Line 978\n\t\t\t\t\t\t\t\t 'transient')\n\t\t\t\t\t in let <_44> =\n\t\t\t\t\t\t call %% Line 978\n\t\t\t\t\t\t\t 'erlang':%% Line 978\n\t\t\t\t\t\t\t\t '=:='\n\t\t\t\t\t\t\t(%% Line 978\n\t\t\t\t\t\t\t ErrInf, %% Line 978\n\t\t\t\t\t\t\t\t 'info')\n\t\t\t\t\t\tin let <_45> =\n\t\t\t\t\t\t\tcall %% Line 978\n\t\t\t\t\t\t\t 'erlang':%% Line 978\n\t\t\t\t\t\t\t\t 'and'\n\t\t\t\t\t\t\t (_43, _44)\n\t\t\t\t\t\t in call 'erlang':'or'\n\t\t\t\t\t\t\t (_42, _45) ->\n\t\t\t do %% Line 979\n\t\t\t\t apply 'notify_cntrl_started'/4\n\t\t\t\t (_2, 'undefined', _0, {'error',R})\n\t\t\t\t do %% Line 980\n\t\t\t\t case ErrInf of\n\t\t\t\t\t%% Line 981\n\t\t\t\t\t<'error'> when 'true' ->\n\t\t\t\t\t %% Line 982\n\t\t\t\t\t apply 'info_exited'/3\n\t\t\t\t\t\t(_2, R, RestartType)\n\t\t\t\t\t%% Line 983\n\t\t\t\t\t<'info'> when 'true' ->\n\t\t\t\t\t 'ok'\n\t\t\t\t\t( <_46> when 'true' ->\n\t\t\t\t\t primop 'match_fail'\n\t\t\t\t\t\t ({'case_clause',_46})\n\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t end\n\t\t\t\t %% Line 986\n\t\t\t\t case R of\n\t\t\t\t\t%% Line 987\n\t\t\t\t\t<{{'EXIT','normal'},_X_Call}> when 'true' ->\n\t\t\t\t\t let <_rec97> =\n\t\t\t\t\t\tcall %% Line 988\n\t\t\t\t\t\t 'lists':%% Line 988\n\t\t\t\t\t\t\t 'keydelete'\n\t\t\t\t\t\t (_2, %% Line 988\n\t\t\t\t\t\t\t 1, %% Line 988\n\t\t\t\t\t\t\t Starting)\n\t\t\t\t\t in let <_49> =\n\t\t\t\t\t\t call %% Line 989\n\t\t\t\t\t\t\t 'erlang':%% Line 989\n\t\t\t\t\t\t\t\t 'setelement'\n\t\t\t\t\t\t\t(%% Line 989\n\t\t\t\t\t\t\t 8, _0, %% Line 989\n\t\t\t\t\t\t\t\tStart_reqN)\n\t\t\t\t\t\tin let <_51> =\n\t\t\t\t\t\t\tcall %% Line 988\n\t\t\t\t\t\t\t 'erlang':%% Line 988\n\t\t\t\t\t\t\t\t 'setelement'\n\t\t\t\t\t\t\t (%% Line 988\n\t\t\t\t\t\t\t 3, _49, %% Line 988\n\t\t\t\t\t\t\t\t _rec97)\n\t\t\t\t\t\t in %% Line 988\n\t\t\t\t\t\t\t{'noreply',_51}\n\t\t\t\t\t%% Line 990\n\t\t\t\t\t<_125> when 'true' ->\n\t\t\t\t\t let = {%% Line 991\n\t\t\t\t\t\t 'application_start_failure',_2,%% Line 991\n\t\t\t\t\t\t\t\t\t\tR}\n\t\t\t\t\t in let <_53> =\n\t\t\t\t\t\t apply %% Line 992\n\t\t\t\t\t\t\t 'to_string'/1\n\t\t\t\t\t\t\t(%% Line 992\n\t\t\t\t\t\t\t Reason)\n\t\t\t\t\t\tin %% Line 992\n\t\t\t\t\t\t {'stop',_53,_0}\n\t\t\t\t end\n\t\t\t %% Line 994\n\t\t\t when 'true' ->\n\t\t\t do %% Line 995\n\t\t\t\t apply 'notify_cntrl_started'/4\n\t\t\t\t (_2, 'undefined', _0, Error)\n\t\t\t\t do %% Line 996\n\t\t\t\t apply 'info_exited'/3\n\t\t\t\t\t (_2, R, RestartType)\n\t\t\t\t let = {%% Line 997\n\t\t\t\t\t 'application_start_failure',_2,%% Line 997\n\t\t\t\t\t\t\t\t\t R}\n\t\t\t\t in let <_56> =\n\t\t\t\t\t apply %% Line 998\n\t\t\t\t\t\t 'to_string'/1\n\t\t\t\t\t\t (%% Line 998\n\t\t\t\t\t\t Reason)\n\t\t\t\t\t in %% Line 998\n\t\t\t\t\t {'stop',_56,_0}\n\t\t\t %% Line 999\n\t\t\t <{'info',R}> when 'true' ->\n\t\t\t do %% Line 1000\n\t\t\t\t apply 'notify_cntrl_started'/4\n\t\t\t\t (_2, 'undefined', _0, {'error',R})\n\t\t\t\t let = {%% Line 1001\n\t\t\t\t 'application_start_failure',_2,%% Line 1001\n\t\t\t\t\t\t\t\t R}\n\t\t\t\t in let <_58> =\n\t\t\t\t\t apply %% Line 1002\n\t\t\t\t\t\t'to_string'/1\n\t\t\t\t\t (%% Line 1002\n\t\t\t\t\t Reason)\n\t\t\t\t in %% Line 1002\n\t\t\t\t\t {'stop',_58,_0}\n\t\t\t ( <_59> when 'true' ->\n\t\t\t\tprimop 'match_fail'\n\t\t\t\t ({'case_clause',_59})\n\t\t\t -| ['compiler_generated'] )\n\t\t\tend\n\t\t ( <_5> when 'true' ->\n\t\t\t primop 'match_fail'\n\t\t\t ({'badmatch',_5})\n\t\t -| ['compiler_generated'] )\n\t\t end\n\t ( <_3> when 'true' ->\n\t\tprimop 'match_fail'\n\t\t ({'badmatch',_3})\n\t -| ['compiler_generated'] )\n\tend\n'handle_info'/2 =\n %% Line 1008\n fun (_1,_0) ->\n\tcase <_1,_0> of\n\t <{'ac_load_application_reply',AppName,Res},S> when 'true' ->\n\t %% Line 1009\n\t ( case S of\n\t\t ( <( {'state',_rec99,_122,_123,_124,_125,_126,_127,_128}\n\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\tcase apply 'keysearchdelete'/3\n\t\t\t\t (AppName, 1, _rec99) of\n\t\t\t %% Line 1010\n\t\t\t <{'value',{_X_AppName,From},Loading}> when 'true' ->\n\t\t\t do %% Line 1011\n\t\t\t\t call 'gen_server':'reply'\n\t\t\t\t (From, Res)\n\t\t\t\t %% Line 1012\n\t\t\t\t case Res of\n\t\t\t\t %% Line 1013\n\t\t\t\t <'ok'> when 'true' ->\n\t\t\t\t\tlet <_6> =\n\t\t\t\t\t call %% Line 1014\n\t\t\t\t\t\t 'erlang':%% Line 1014\n\t\t\t\t\t\t\t 'setelement'\n\t\t\t\t\t\t(%% Line 1014\n\t\t\t\t\t\t 2, %% Line 1014\n\t\t\t\t\t\t S, %% Line 1014\n\t\t\t\t\t\t Loading)\n\t\t\t\t\tin %% Line 1014\n\t\t\t\t\t {'noreply',_6}\n\t\t\t\t %% Line 1015\n\t\t\t\t <{'error',_X_R}> when 'true' ->\n\t\t\t\t\tlet =\n\t\t\t\t\t apply %% Line 1016\n\t\t\t\t\t\t 'unload'/2\n\t\t\t\t\t\t(%% Line 1016\n\t\t\t\t\t\t AppName, %% Line 1016\n\t\t\t\t\t\t\t S)\n\t\t\t\t\tin %% Line 1017\n\t\t\t\t\t case NewS of\n\t\t\t\t\t <{'state',_139,_140,_141,_142,_143,_144,_145,_146}> when 'true' ->\n\t\t\t\t\t\t let <_10> =\n\t\t\t\t\t\t call 'erlang':'setelement'\n\t\t\t\t\t\t\t (2, NewS, Loading)\n\t\t\t\t\t\t in {'noreply',_10}\n\t\t\t\t\t ( <_147> when 'true' ->\n\t\t\t\t\t\t ( call ( 'erlang'\n\t\t\t\t\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t\t\t (( {'badrecord','state'}\n\t\t\t\t\t\t\t -| ['compiler_generated'] ))\n\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t\t-| ['compiler_generated'] )\n\t\t\t\t\t end\n\t\t\t\t ( <_11> when 'true' ->\n\t\t\t\t\t primop 'match_fail'\n\t\t\t\t\t ({'case_clause',_11})\n\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t end\n\t\t\t %% Line 1019\n\t\t\t <'false'> when 'true' ->\n\t\t\t %% Line 1020\n\t\t\t {'noreply',S}\n\t\t\t ( <_12> when 'true' ->\n\t\t\t\tprimop 'match_fail'\n\t\t\t\t ({'case_clause',_12})\n\t\t\t -| ['compiler_generated'] )\n\t\t\tend\n\t\t -| ['compiler_generated'] )\n\t\t ( <_129> when 'true' ->\n\t\t\t( call ( 'erlang'\n\t\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t (( {'badrecord','state'}\n\t\t\t\t -| ['compiler_generated'] ))\n\t\t\t -| ['compiler_generated'] )\n\t\t -| ['compiler_generated'] )\n\t\tend\n\t\t-| ['compiler_generated'] )\n\t %% Line 1023\n\t <{'ac_start_application_reply',AppName,Res},S> when 'true' ->\n\t %% Line 1024\n\t ( case S of\n\t\t ( <( {'state',_148,_149,_150,_151,_152,_153,_rec102,_154}\n\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\t%% Line 1025\n\t\t\tcase call 'lists':'keyfind'\n\t\t\t\t (AppName, 1, _149) of\n\t\t\t %% Line 1026\n\t\t\t <{_X_AppName,RestartType,Type,From}> when 'true' ->\n\t\t\t %% Line 1027\n\t\t\t case Res of\n\t\t\t\t%% Line 1028\n\t\t\t\t<'start_it'> when 'true' ->\n\t\t\t\t %% Line 1029\n\t\t\t\t case apply 'get_loaded'/1\n\t\t\t\t\t (AppName) of\n\t\t\t\t <{'true',Appl}> when 'true' ->\n\t\t\t\t\t do %% Line 1030\n\t\t\t\t\t apply 'spawn_starter'/4\n\t\t\t\t\t\t (From, Appl, S, Type)\n\t\t\t\t\t %% Line 1031\n\t\t\t\t\t {'noreply',S}\n\t\t\t\t ( <_19> when 'true' ->\n\t\t\t\t\t primop 'match_fail'\n\t\t\t\t\t\t({'badmatch',_19})\n\t\t\t\t\t-| ['compiler_generated'] )\n\t\t\t\t end\n\t\t\t\t%% Line 1032\n\t\t\t\t<{'started',Node}> when 'true' ->\n\t\t\t\t %% Line 1033\n\t\t\t\t apply 'handle_application_started'/3\n\t\t\t\t\t(AppName, %% Line 1034\n\t\t\t\t\t\t {'ok',{'distributed',Node}}, %% Line 1035\n\t\t\t\t\t\t\t\t\t S)\n\t\t\t\t%% Line 1036\n\t\t\t\t<'not_started'> when 'true' ->\n\t\t\t\t let =\n\t\t\t\t\tapply %% Line 1039\n\t\t\t\t\t 'reply_to_requester'/3\n\t\t\t\t\t (%% Line 1039\n\t\t\t\t\t AppName, _rec102, %% Line 1039\n\t\t\t\t\t\t\t 'ok')\n\t\t\t\t in let <_rec105> =\n\t\t\t\t\t call %% Line 1041\n\t\t\t\t\t\t 'lists':%% Line 1041\n\t\t\t\t\t\t\t 'keydelete'\n\t\t\t\t\t\t(%% Line 1041\n\t\t\t\t\t\t AppName, %% Line 1041\n\t\t\t\t\t\t\t 1, _149)\n\t\t\t\t\tin let <_rec106> =\n\t\t\t\t\t\t[%% Line 1042\n\t\t\t\t\t\t {AppName,RestartType}|_153]\n\t\t\t\t\t in let <_27> =\n\t\t\t\t\t\t call %% Line 1043\n\t\t\t\t\t\t\t 'erlang':%% Line 1043\n\t\t\t\t\t\t\t\t 'setelement'\n\t\t\t\t\t\t\t(%% Line 1043\n\t\t\t\t\t\t\t 8, %% Line 1041\n\t\t\t\t\t\t\t S, %% Line 1043\n\t\t\t\t\t\t\t Start_reqN)\n\t\t\t\t\t\tin let <_28> =\n\t\t\t\t\t\t\tcall %% Line 1042\n\t\t\t\t\t\t\t 'erlang':%% Line 1042\n\t\t\t\t\t\t\t\t 'setelement'\n\t\t\t\t\t\t\t (%% Line 1042\n\t\t\t\t\t\t\t 7, _27, %% Line 1042\n\t\t\t\t\t\t\t\t _rec106)\n\t\t\t\t\t\t in let <_30> =\n\t\t\t\t\t\t\t call %% Line 1041\n\t\t\t\t\t\t\t\t 'erlang':%% Line 1041\n\t\t\t\t\t\t\t\t\t 'setelement'\n\t\t\t\t\t\t\t\t(%% Line 1041\n\t\t\t\t\t\t\t\t 3, _28, %% Line 1041\n\t\t\t\t\t\t\t\t\t _rec105)\n\t\t\t\t\t\t\tin %% Line 1040\n\t\t\t\t\t\t\t {'noreply',_30}\n\t\t\t\t%% Line 1044\n\t\t\t\t when 'true' ->\n\t\t\t\t %% Line 1045\n\t\t\t\t case apply 'get_loaded'/1\n\t\t\t\t\t (AppName) of\n\t\t\t\t <{'true',Appl}> when 'true' ->\n\t\t\t\t\t do %% Line 1046\n\t\t\t\t\t apply 'spawn_starter'/4\n\t\t\t\t\t\t (From, Appl, S, Takeover)\n\t\t\t\t\t let =\n\t\t\t\t\t\t call %% Line 1047\n\t\t\t\t\t\t 'lists':%% Line 1047\n\t\t\t\t\t\t\t 'keydelete'\n\t\t\t\t\t\t (%% Line 1047\n\t\t\t\t\t\t AppName, %% Line 1047\n\t\t\t\t\t\t\t\t1, _149)\n\t\t\t\t\t in let =\n\t\t\t\t\t\t [%% Line 1048\n\t\t\t\t\t\t {AppName,RestartType,Takeover,From}|%% Line 1048\n\t\t\t\t\t\t\t\t\t\t\t NewStarting1]\n\t\t\t\t\t\t in let <_36> =\n\t\t\t\t\t\t\t call %% Line 1049\n\t\t\t\t\t\t\t 'erlang':%% Line 1049\n\t\t\t\t\t\t\t\t\t'setelement'\n\t\t\t\t\t\t\t (%% Line 1049\n\t\t\t\t\t\t\t 3, %% Line 1049\n\t\t\t\t\t\t\t\t S, %% Line 1049\n\t\t\t\t\t\t\t\t NewStarting)\n\t\t\t\t\t\t in %% Line 1049\n\t\t\t\t\t\t\t {'noreply',_36}\n\t\t\t\t ( <_31> when 'true' ->\n\t\t\t\t\t primop 'match_fail'\n\t\t\t\t\t\t({'badmatch',_31})\n\t\t\t\t\t-| ['compiler_generated'] )\n\t\t\t\t end\n\t\t\t\t%% Line 1050\n\t\t\t\t\n\t\t\t\t when call 'erlang':'=:='\n\t\t\t\t\t (RestartType,\n\t\t\t\t\t 'permanent') ->\n\t\t\t\t let =\n\t\t\t\t\tapply %% Line 1051\n\t\t\t\t\t 'reply_to_requester'/3\n\t\t\t\t\t (%% Line 1051\n\t\t\t\t\t AppName, _rec102, %% Line 1051\n\t\t\t\t\t\t\t Error)\n\t\t\t\t in let <_41> =\n\t\t\t\t\t apply %% Line 1052\n\t\t\t\t\t\t 'to_string'/1\n\t\t\t\t\t\t(%% Line 1052\n\t\t\t\t\t\t Reason)\n\t\t\t\t\tin let <_40> =\n\t\t\t\t\t\tcall %% Line 1052\n\t\t\t\t\t\t 'erlang':%% Line 1052\n\t\t\t\t\t\t\t 'setelement'\n\t\t\t\t\t\t (%% Line 1052\n\t\t\t\t\t\t 8, %% Line 1052\n\t\t\t\t\t\t\tS, %% Line 1052\n\t\t\t\t\t\t\t Start_reqN)\n\t\t\t\t\t in %% Line 1052\n\t\t\t\t\t\t{'stop',_41,_40}\n\t\t\t\t%% Line 1053\n\t\t\t\t when 'true' ->\n\t\t\t\t let =\n\t\t\t\t\tapply %% Line 1054\n\t\t\t\t\t 'reply_to_requester'/3\n\t\t\t\t\t (%% Line 1054\n\t\t\t\t\t AppName, _rec102, %% Line 1054\n\t\t\t\t\t\t\t Error)\n\t\t\t\t in let <_rec110> =\n\t\t\t\t\t call %% Line 1056\n\t\t\t\t\t\t 'lists':%% Line 1056\n\t\t\t\t\t\t\t 'keydelete'\n\t\t\t\t\t\t(%% Line 1056\n\t\t\t\t\t\t AppName, %% Line 1056\n\t\t\t\t\t\t\t 1, _149)\n\t\t\t\t\tin let <_45> =\n\t\t\t\t\t\tcall %% Line 1057\n\t\t\t\t\t\t 'erlang':%% Line 1057\n\t\t\t\t\t\t\t 'setelement'\n\t\t\t\t\t\t (%% Line 1057\n\t\t\t\t\t\t 8, %% Line 1055\n\t\t\t\t\t\t\tS, %% Line 1057\n\t\t\t\t\t\t\t Start_reqN)\n\t\t\t\t\t in let <_47> =\n\t\t\t\t\t\t call %% Line 1055\n\t\t\t\t\t\t\t 'erlang':%% Line 1055\n\t\t\t\t\t\t\t\t 'setelement'\n\t\t\t\t\t\t\t(%% Line 1055\n\t\t\t\t\t\t\t 3, _45, %% Line 1055\n\t\t\t\t\t\t\t\t _rec110)\n\t\t\t\t\t\tin %% Line 1055\n\t\t\t\t\t\t {'noreply',_47}\n\t\t\t\t( <_48> when 'true' ->\n\t\t\t\t primop 'match_fail'\n\t\t\t\t\t ({'case_clause',_48})\n\t\t\t\t -| ['compiler_generated'] )\n\t\t\t end\n\t\t\t %% Line 1059\n\t\t\t <'false'> when 'true' ->\n\t\t\t %% Line 1060\n\t\t\t {'noreply',S}\n\t\t\t ( <_49> when 'true' ->\n\t\t\t\tprimop 'match_fail'\n\t\t\t\t ({'case_clause',_49})\n\t\t\t -| ['compiler_generated'] )\n\t\t\tend\n\t\t -| ['compiler_generated'] )\n\t\t ( <_155> when 'true' ->\n\t\t\t( call ( 'erlang'\n\t\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t (( {'badrecord','state'}\n\t\t\t\t -| ['compiler_generated'] ))\n\t\t\t -| ['compiler_generated'] )\n\t\t -| ['compiler_generated'] )\n\t\tend\n\t\t-| ['compiler_generated'] )\n\t %% Line 1063\n\t <{'ac_change_application_req',AppName,Msg},S> when 'true' ->\n\t %% Line 1064\n\t ( case S of\n\t\t ( <( {'state',_208,_209,_210,_rec112,_211,_212,_213,_214}\n\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\tlet <_60> =\n\t\t\t call %% Line 1067\n\t\t\t\t 'lists':%% Line 1067\n\t\t\t\t\t 'keyfind'\n\t\t\t\t(%% Line 1067\n\t\t\t\t AppName, %% Line 1067\n\t\t\t\t\t 1, _rec112)\n\t\t\tin let <_59> =\n\t\t\t\tcall %% Line 1067\n\t\t\t\t 'lists':%% Line 1067\n\t\t\t\t\t 'keyfind'\n\t\t\t\t (%% Line 1067\n\t\t\t\t AppName, %% Line 1067\n\t\t\t\t\t 1, _212)\n\t\t\t in %% Line 1067\n\t\t\t\tcase <_60,_59> of\n\t\t\t\t %% Line 1068\n\t\t\t\t <( {_232,Id}\n\t\t\t\t -| ['compiler_generated'] ),( {_X_AppName2,Type}\n\t\t\t\t\t\t\t\t -| ['compiler_generated'] )>\n\t\t\t\t when call 'erlang':'=:='\n\t\t\t\t\t (_232,\n\t\t\t\t\t AppName) ->\n\t\t\t\t %% Line 1069\n\t\t\t\t case Msg of\n\t\t\t\t\t%% Line 1070\n\t\t\t\t\t<{'started',Node}> when 'true' ->\n\t\t\t\t\t do %% Line 1071\n\t\t\t\t\t\tapply 'stop_appl'/3\n\t\t\t\t\t\t (AppName, Id, Type)\n\t\t\t\t\t\tlet <_61> =\n\t\t\t\t\t\t call %% Line 1073\n\t\t\t\t\t\t\t 'lists':%% Line 1073\n\t\t\t\t\t\t\t\t 'keydelete'\n\t\t\t\t\t\t\t(%% Line 1073\n\t\t\t\t\t\t\t AppName, %% Line 1073\n\t\t\t\t\t\t\t\t 1, _rec112)\n\t\t\t\t\t\tin let =\n\t\t\t\t\t\t\t[%% Line 1072\n\t\t\t\t\t\t\t {AppName,{'distributed',Node}}|_61]\n\t\t\t\t\t\t in let <_65> =\n\t\t\t\t\t\t\t call %% Line 1074\n\t\t\t\t\t\t\t\t 'erlang':%% Line 1074\n\t\t\t\t\t\t\t\t\t 'setelement'\n\t\t\t\t\t\t\t\t(%% Line 1074\n\t\t\t\t\t\t\t\t 5, %% Line 1074\n\t\t\t\t\t\t\t\t S, %% Line 1074\n\t\t\t\t\t\t\t\t NRunning)\n\t\t\t\t\t\t\tin %% Line 1074\n\t\t\t\t\t\t\t {'noreply',_65}\n\t\t\t\t\t%% Line 1075\n\t\t\t\t\t<{'takeover',_X_Node,_X_RT}>\n\t\t\t\t\t when call 'erlang':'is_pid'\n\t\t\t\t\t\t (Id) ->\n\t\t\t\t\t do %% Line 1076\n\t\t\t\t\t\tapply 'notify_cntrl_started'/4\n\t\t\t\t\t\t (AppName, Id, S, 'ok')\n\t\t\t\t\t\t%% Line 1077\n\t\t\t\t\t\t{'noreply',S}\n\t\t\t\t\t%% Line 1078\n\t\t\t\t\t<{'takeover',Node,RT}> when 'true' ->\n\t\t\t\t\t let =\n\t\t\t\t\t\tapply %% Line 1079\n\t\t\t\t\t\t 'do_start'/5\n\t\t\t\t\t\t (%% Line 1079\n\t\t\t\t\t\t AppName, %% Line 1079\n\t\t\t\t\t\t\t RT, %% Line 1079\n\t\t\t\t\t\t\t\t {'takeover',Node}, %% Line 1079\n\t\t\t\t\t\t\t\t\t\t 'undefined', %% Line 1079\n\t\t\t\t\t\t\t\t\t\t\t\t S)\n\t\t\t\t\t in %% Line 1080\n\t\t\t\t\t\t{'noreply',NewS}\n\t\t\t\t\t%% Line 1081\n\t\t\t\t\t<{'failover',_X_Node,_X_RT}>\n\t\t\t\t\t when call 'erlang':'is_pid'\n\t\t\t\t\t\t (Id) ->\n\t\t\t\t\t do %% Line 1082\n\t\t\t\t\t\tapply 'notify_cntrl_started'/4\n\t\t\t\t\t\t (AppName, Id, S, 'ok')\n\t\t\t\t\t\t%% Line 1083\n\t\t\t\t\t\t{'noreply',S}\n\t\t\t\t\t%% Line 1084\n\t\t\t\t\t<{'failover',Node,RT}> when 'true' ->\n\t\t\t\t\t %% Line 1085\n\t\t\t\t\t case call 'application':'get_key'\n\t\t\t\t\t\t (AppName, 'start_phases') of\n\t\t\t\t\t %% Line 1086\n\t\t\t\t\t <{'ok','undefined'}> when 'true' ->\n\t\t\t\t\t\t let =\n\t\t\t\t\t\t apply %% Line 1090\n\t\t\t\t\t\t\t 'do_start'/5\n\t\t\t\t\t\t\t (%% Line 1090\n\t\t\t\t\t\t\t AppName, %% Line 1090\n\t\t\t\t\t\t\t\t RT, %% Line 1090\n\t\t\t\t\t\t\t\t\t'normal', %% Line 1090\n\t\t\t\t\t\t\t\t\t\t 'undefined', %% Line 1090\n\t\t\t\t\t\t\t\t\t\t\t S)\n\t\t\t\t\t\t in %% Line 1091\n\t\t\t\t\t\t {'noreply',NewS}\n\t\t\t\t\t %% Line 1092\n\t\t\t\t\t <{'ok',_X_StartPhases}> when 'true' ->\n\t\t\t\t\t\t let =\n\t\t\t\t\t\t apply %% Line 1093\n\t\t\t\t\t\t\t 'do_start'/5\n\t\t\t\t\t\t\t (%% Line 1093\n\t\t\t\t\t\t\t AppName, %% Line 1093\n\t\t\t\t\t\t\t\t RT, %% Line 1093\n\t\t\t\t\t\t\t\t\t{'failover',Node}, %% Line 1093\n\t\t\t\t\t\t\t\t\t\t\t 'undefined', %% Line 1093\n\t\t\t\t\t\t\t\t\t\t\t\t\tS)\n\t\t\t\t\t\t in %% Line 1094\n\t\t\t\t\t\t {'noreply',NewS}\n\t\t\t\t\t ( <_69> when 'true' ->\n\t\t\t\t\t\t primop 'match_fail'\n\t\t\t\t\t\t\t({'case_clause',_69})\n\t\t\t\t\t\t-| ['compiler_generated'] )\n\t\t\t\t\t end\n\t\t\t\t\t%% Line 1096\n\t\t\t\t\t<'stop_it'> when 'true' ->\n\t\t\t\t\t do %% Line 1097\n\t\t\t\t\t\tapply 'stop_appl'/3\n\t\t\t\t\t\t (AppName, Id, Type)\n\t\t\t\t\t\tdo %% Line 1098\n\t\t\t\t\t\t apply 'cntrl'/3\n\t\t\t\t\t\t\t(AppName, S, {'ac_application_not_run',AppName})\n\t\t\t\t\t\t let =\n\t\t\t\t\t\t\tcall %% Line 1099\n\t\t\t\t\t\t\t 'lists':%% Line 1099\n\t\t\t\t\t\t\t\t 'keyreplace'\n\t\t\t\t\t\t\t (%% Line 1099\n\t\t\t\t\t\t\t AppName, %% Line 1099\n\t\t\t\t\t\t\t\t 1, _rec112, %% Line 1100\n\t\t\t\t\t\t\t\t\t\t {AppName,{'distributed',[]}})\n\t\t\t\t\t\t in let <_73> =\n\t\t\t\t\t\t\t call %% Line 1101\n\t\t\t\t\t\t\t\t 'erlang':%% Line 1101\n\t\t\t\t\t\t\t\t\t 'setelement'\n\t\t\t\t\t\t\t\t(%% Line 1101\n\t\t\t\t\t\t\t\t 5, %% Line 1101\n\t\t\t\t\t\t\t\t S, %% Line 1101\n\t\t\t\t\t\t\t\t NRunning)\n\t\t\t\t\t\t\tin %% Line 1101\n\t\t\t\t\t\t\t {'noreply',_73}\n\t\t\t\t\t%% Line 1103\n\t\t\t\t\t<'start_it'>\n\t\t\t\t\t when call 'erlang':'is_pid'\n\t\t\t\t\t\t (Id) ->\n\t\t\t\t\t do %% Line 1104\n\t\t\t\t\t\tapply 'notify_cntrl_started'/4\n\t\t\t\t\t\t (AppName, Id, S, 'ok')\n\t\t\t\t\t\t%% Line 1105\n\t\t\t\t\t\t{'noreply',S}\n\t\t\t\t\t%% Line 1106\n\t\t\t\t\t<'start_it'> when 'true' ->\n\t\t\t\t\t let =\n\t\t\t\t\t\tapply %% Line 1107\n\t\t\t\t\t\t 'do_start'/5\n\t\t\t\t\t\t (%% Line 1107\n\t\t\t\t\t\t AppName, %% Line 1107\n\t\t\t\t\t\t\t 'undefined', %% Line 1107\n\t\t\t\t\t\t\t\t\t 'normal', %% Line 1107\n\t\t\t\t\t\t\t\t\t\t 'undefined', %% Line 1107\n\t\t\t\t\t\t\t\t\t\t\t\t S)\n\t\t\t\t\t in %% Line 1108\n\t\t\t\t\t\t{'noreply',NewS}\n\t\t\t\t\t%% Line 1109\n\t\t\t\t\t<'not_running'> when 'true' ->\n\t\t\t\t\t let =\n\t\t\t\t\t\tcall %% Line 1110\n\t\t\t\t\t\t 'lists':%% Line 1110\n\t\t\t\t\t\t\t 'keydelete'\n\t\t\t\t\t\t (%% Line 1110\n\t\t\t\t\t\t AppName, %% Line 1110\n\t\t\t\t\t\t\t 1, _rec112)\n\t\t\t\t\t in let <_78> =\n\t\t\t\t\t\t call %% Line 1111\n\t\t\t\t\t\t\t 'erlang':%% Line 1111\n\t\t\t\t\t\t\t\t 'setelement'\n\t\t\t\t\t\t\t(%% Line 1111\n\t\t\t\t\t\t\t 5, %% Line 1111\n\t\t\t\t\t\t\t S, %% Line 1111\n\t\t\t\t\t\t\t NRunning)\n\t\t\t\t\t\tin %% Line 1111\n\t\t\t\t\t\t {'noreply',_78}\n\t\t\t\t\t%% Line 1112\n\t\t\t\t\t<_260> when 'true' ->\n\t\t\t\t\t %% Line 1113\n\t\t\t\t\t {'noreply',S}\n\t\t\t\t end\n\t\t\t\t %% Line 1115\n\t\t\t\t <( _340\n\t\t\t\t -| ['compiler_generated'] ),( _341\n\t\t\t\t\t\t\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\t\t let =\n\t\t\t\t\t apply %% Line 1116\n\t\t\t\t\t\t'get_loaded'/1\n\t\t\t\t\t (%% Line 1116\n\t\t\t\t\t AppName)\n\t\t\t\t in let =\n\t\t\t\t\t call %% Line 1117\n\t\t\t\t\t\t 'lists':%% Line 1117\n\t\t\t\t\t\t\t 'keysearch'\n\t\t\t\t\t\t (%% Line 1117\n\t\t\t\t\t\t AppName, %% Line 1117\n\t\t\t\t\t\t\t 1, _209)\n\t\t\t\t\t in let =\n\t\t\t\t\t\t call %% Line 1118\n\t\t\t\t\t\t 'lists':%% Line 1118\n\t\t\t\t\t\t\t 'keysearch'\n\t\t\t\t\t\t (%% Line 1118\n\t\t\t\t\t\t AppName, %% Line 1118\n\t\t\t\t\t\t\t\t1, _212)\n\t\t\t\t\t in let =\n\t\t\t\t\t\t call %% Line 1119\n\t\t\t\t\t\t\t 'lists':%% Line 1119\n\t\t\t\t\t\t\t\t 'keysearch'\n\t\t\t\t\t\t\t (%% Line 1119\n\t\t\t\t\t\t\t AppName, %% Line 1119\n\t\t\t\t\t\t\t\t 1, _rec112)\n\t\t\t\t\t\t in %% Line 1121\n\t\t\t\t\t\t case Msg of\n\t\t\t\t\t\t\t%% Line 1122\n\t\t\t\t\t\t\t<'start_it'> when 'true' ->\n\t\t\t\t\t\t\t %% Line 1123\n\t\t\t\t\t\t\t case of\n\t\t\t\t\t\t\t %% Line 1125\n\t\t\t\t\t\t\t <_262,_263,_264,( {( 'value'\n\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] ),_X_Tuple}\n\t\t\t\t\t\t\t\t\t\t-| ['compiler_generated'] )> when 'true' ->\n\t\t\t\t\t\t\t\t %% Line 1126\n\t\t\t\t\t\t\t\t {'noreply',S}\n\t\t\t\t\t\t\t %% Line 1128\n\t\t\t\t\t\t\t <( 'false'\n\t\t\t\t\t\t\t\t -| ['compiler_generated'] ),_265,_266,_267> when 'true' ->\n\t\t\t\t\t\t\t\t %% Line 1129\n\t\t\t\t\t\t\t\t {'noreply',S}\n\t\t\t\t\t\t\t %% Line 1131\n\t\t\t\t\t\t\t <( {( 'true'\n\t\t\t\t\t\t\t\t -| ['compiler_generated'] ),_X_Appl}\n\t\t\t\t\t\t\t\t -| ['compiler_generated'] ),( 'false'\n\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] ),( 'false'\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] ),( 'false'\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\t\t\t\t\t\t %% Line 1132\n\t\t\t\t\t\t\t\t {'noreply',S}\n\t\t\t\t\t\t\t %% Line 1134\n\t\t\t\t\t\t\t <( {( 'true'\n\t\t\t\t\t\t\t\t -| ['compiler_generated'] ),_X_Appl}\n\t\t\t\t\t\t\t\t -| ['compiler_generated'] ),( {( 'value'\n\t\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] ),Tuple}\n\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] ),( 'false'\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] ),( 'false'\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\t\t\t\t\t\t %% Line 1135\n\t\t\t\t\t\t\t\t case Tuple of\n\t\t\t\t\t\t\t\t <{_X_AppName,_X_RStype,_X_Type,From}> when 'true' ->\n\t\t\t\t\t\t\t\t\tlet =\n\t\t\t\t\t\t\t\t\t apply %% Line 1136\n\t\t\t\t\t\t\t\t\t\t 'do_start'/5\n\t\t\t\t\t\t\t\t\t\t(%% Line 1136\n\t\t\t\t\t\t\t\t\t\t AppName, %% Line 1136\n\t\t\t\t\t\t\t\t\t\t\t 'undefined', %% Line 1136\n\t\t\t\t\t\t\t\t\t\t\t\t 'normal', %% Line 1136\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t From, %% Line 1136\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t S)\n\t\t\t\t\t\t\t\t\tin %% Line 1137\n\t\t\t\t\t\t\t\t\t {'noreply',NewS}\n\t\t\t\t\t\t\t\t ( <_84> when 'true' ->\n\t\t\t\t\t\t\t\t\t primop 'match_fail'\n\t\t\t\t\t\t\t\t\t ({'badmatch',_84})\n\t\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t\t\t\t end\n\t\t\t\t\t\t\t %% Line 1139\n\t\t\t\t\t\t\t <( {( 'true'\n\t\t\t\t\t\t\t\t -| ['compiler_generated'] ),_X_Appl}\n\t\t\t\t\t\t\t\t -| ['compiler_generated'] ),_268,( {( 'value'\n\t\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] ),( {_269,_X_RestartType}\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] )}\n\t\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] ),( 'false'\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] )>\n\t\t\t\t\t\t\t\t when call 'erlang':'=:='\n\t\t\t\t\t\t\t\t\t(_269,\n\t\t\t\t\t\t\t\t\t AppName) ->\n\t\t\t\t\t\t\t\t let =\n\t\t\t\t\t\t\t\t apply %% Line 1140\n\t\t\t\t\t\t\t\t\t 'do_start'/5\n\t\t\t\t\t\t\t\t\t (%% Line 1140\n\t\t\t\t\t\t\t\t\t AppName, %% Line 1140\n\t\t\t\t\t\t\t\t\t\t 'undefined', %% Line 1140\n\t\t\t\t\t\t\t\t\t\t\t\t 'normal', %% Line 1140\n\t\t\t\t\t\t\t\t\t\t\t\t\t 'undefined', %% Line 1140\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\tS)\n\t\t\t\t\t\t\t\t in let <_rec118> =\n\t\t\t\t\t\t\t\t\t call %% Line 1141\n\t\t\t\t\t\t\t\t\t 'lists':%% Line 1141\n\t\t\t\t\t\t\t\t\t\t 'keydelete'\n\t\t\t\t\t\t\t\t\t (%% Line 1141\n\t\t\t\t\t\t\t\t\t AppName, %% Line 1141\n\t\t\t\t\t\t\t\t\t\t\t1, _212)\n\t\t\t\t\t\t\t\t in %% Line 1141\n\t\t\t\t\t\t\t\t\t case NewS of\n\t\t\t\t\t\t\t\t\t <{'state',_270,_271,_272,_273,_274,_275,_276,_277}> when 'true' ->\n\t\t\t\t\t\t\t\t\t\tlet <_90> =\n\t\t\t\t\t\t\t\t\t\t call 'erlang':'setelement'\n\t\t\t\t\t\t\t\t\t\t\t(7, NewS, _rec118)\n\t\t\t\t\t\t\t\t\t\tin %% Line 1142\n\t\t\t\t\t\t\t\t\t\t {'noreply',_90}\n\t\t\t\t\t\t\t\t\t ( <_278> when 'true' ->\n\t\t\t\t\t\t\t\t\t\t ( call ( 'erlang'\n\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t\t\t\t\t\t\t(( {'badrecord','state'}\n\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] ))\n\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t\t\t\t\t end\n\t\t\t\t\t\t\t ( <( _344\n\t\t\t\t\t\t\t\t -| ['compiler_generated'] ),( _345\n\t\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] ),( _346\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] ),( _347\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\t\t\t\t\t\t let <_92> =\n\t\t\t\t\t\t\t\t\t{( _344\n\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] ),( _345\n\t\t\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] ),( _346\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] ),( _347\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] )}\n\t\t\t\t\t\t\t\t in primop 'match_fail'\n\t\t\t\t\t\t\t\t\t ({'case_clause',_92})\n\t\t\t\t\t\t\t\t-| ['compiler_generated'] )\n\t\t\t\t\t\t\t end\n\t\t\t\t\t\t\t%% Line 1144\n\t\t\t\t\t\t\t<{'started',Node}> when 'true' ->\n\t\t\t\t\t\t\t let <_93> =\n\t\t\t\t\t\t\t\tcall %% Line 1146\n\t\t\t\t\t\t\t\t 'lists':%% Line 1146\n\t\t\t\t\t\t\t\t\t 'keydelete'\n\t\t\t\t\t\t\t\t (%% Line 1146\n\t\t\t\t\t\t\t\t AppName, %% Line 1146\n\t\t\t\t\t\t\t\t\t 1, _rec112)\n\t\t\t\t\t\t\t in let =\n\t\t\t\t\t\t\t\t [%% Line 1145\n\t\t\t\t\t\t\t\t {AppName,{'distributed',Node}}|_93]\n\t\t\t\t\t\t\t\tin let <_97> =\n\t\t\t\t\t\t\t\t\tcall %% Line 1147\n\t\t\t\t\t\t\t\t\t 'erlang':%% Line 1147\n\t\t\t\t\t\t\t\t\t\t 'setelement'\n\t\t\t\t\t\t\t\t\t (%% Line 1147\n\t\t\t\t\t\t\t\t\t 5, %% Line 1147\n\t\t\t\t\t\t\t\t\t\tS, %% Line 1147\n\t\t\t\t\t\t\t\t\t\t NRunning)\n\t\t\t\t\t\t\t\t in %% Line 1147\n\t\t\t\t\t\t\t\t\t{'noreply',_97}\n\t\t\t\t\t\t\t%% Line 1148\n\t\t\t\t\t\t\t<_288> when 'true' ->\n\t\t\t\t\t\t\t %% Line 1149\n\t\t\t\t\t\t\t {'noreply',S}\n\t\t\t\t\t\t end\n\t\t\t\tend\n\t\t -| ['compiler_generated'] )\n\t\t ( <_215> when 'true' ->\n\t\t\t( call ( 'erlang'\n\t\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t (( {'badrecord','state'}\n\t\t\t\t -| ['compiler_generated'] ))\n\t\t\t -| ['compiler_generated'] )\n\t\t -| ['compiler_generated'] )\n\t\tend\n\t\t-| ['compiler_generated'] )\n\t %% Line 1157\n\t <{'EXIT',Pid,Reason},S> when 'true' ->\n\t do %% Line 1158\n\t\t call 'ets':'match_delete'\n\t\t ('ac_tab', {{'application_master','_'},Pid})\n\t\t %% Line 1159\n\t\t ( case S of\n\t\t ( <( {'state',_289,_290,_291,_rec121,_292,_293,_294,_295}\n\t\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\t let =\n\t\t\t\tcall 'lists':'keydelete'\n\t\t\t\t (Pid, 2, _rec121)\n\t\t\t in let <_105> =\n\t\t\t\t call %% Line 1160\n\t\t\t\t\t 'erlang':%% Line 1160\n\t\t\t\t\t\t 'setelement'\n\t\t\t\t\t(%% Line 1160\n\t\t\t\t\t 5, %% Line 1160\n\t\t\t\t\t S, %% Line 1160\n\t\t\t\t\t NRunning)\n\t\t\t\tin %% Line 1161\n\t\t\t\t case call 'lists':'keyfind'\n\t\t\t\t\t (Pid, 2, _rec121) of\n\t\t\t\t %% Line 1162\n\t\t\t\t <{AppName,_X_AmPid}> when 'true' ->\n\t\t\t\t\t do %% Line 1163\n\t\t\t\t\t apply 'cntrl'/3\n\t\t\t\t\t\t (AppName, S, {'ac_application_stopped',AppName})\n\t\t\t\t\t %% Line 1164\n\t\t\t\t\t case call 'lists':'keyfind'\n\t\t\t\t\t\t (AppName, 1, _293) of\n\t\t\t\t\t\t%% Line 1165\n\t\t\t\t\t\t<{_X_AppName,'temporary'}> when 'true' ->\n\t\t\t\t\t\t do %% Line 1166\n\t\t\t\t\t\t\tapply 'info_exited'/3\n\t\t\t\t\t\t\t (AppName, Reason, 'temporary')\n\t\t\t\t\t\t\t%% Line 1167\n\t\t\t\t\t\t\t{'noreply',_105}\n\t\t\t\t\t\t%% Line 1168\n\t\t\t\t\t\t<{_X_AppName,'transient'}>\n\t\t\t\t\t\t when call 'erlang':'=:='\n\t\t\t\t\t\t\t (Reason,\n\t\t\t\t\t\t\t 'normal') ->\n\t\t\t\t\t\t do %% Line 1169\n\t\t\t\t\t\t\tapply 'info_exited'/3\n\t\t\t\t\t\t\t (AppName, Reason, 'transient')\n\t\t\t\t\t\t\t%% Line 1170\n\t\t\t\t\t\t\t{'noreply',_105}\n\t\t\t\t\t\t%% Line 1171\n\t\t\t\t\t\t<{_X_AppName,Type}> when 'true' ->\n\t\t\t\t\t\t do %% Line 1172\n\t\t\t\t\t\t\tapply 'info_exited'/3\n\t\t\t\t\t\t\t (AppName, Reason, Type)\n\t\t\t\t\t\t\tlet <_111> =\n\t\t\t\t\t\t\t apply %% Line 1173\n\t\t\t\t\t\t\t\t 'to_string'/1\n\t\t\t\t\t\t\t\t(%% Line 1173\n\t\t\t\t\t\t\t\t {'application_terminated',AppName,Reason})\n\t\t\t\t\t\t\tin %% Line 1173\n\t\t\t\t\t\t\t {'stop',_111,_105}\n\t\t\t\t\t\t( <_112> when 'true' ->\n\t\t\t\t\t\t primop 'match_fail'\n\t\t\t\t\t\t\t ({'case_clause',_112})\n\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t end\n\t\t\t\t %% Line 1175\n\t\t\t\t <'false'> when 'true' ->\n\t\t\t\t\t let <_rec125> =\n\t\t\t\t\t apply %% Line 1176\n\t\t\t\t\t\t 'del_cntrl'/2\n\t\t\t\t\t\t (_292, %% Line 1176\n\t\t\t\t\t\t\t Pid)\n\t\t\t\t\t in let <_118> =\n\t\t\t\t\t\t call %% Line 1176\n\t\t\t\t\t\t 'erlang':%% Line 1176\n\t\t\t\t\t\t\t\t'setelement'\n\t\t\t\t\t\t (%% Line 1176\n\t\t\t\t\t\t 6, %% Line 1176\n\t\t\t\t\t\t\t S, %% Line 1176\n\t\t\t\t\t\t\t _rec125)\n\t\t\t\t\t in %% Line 1176\n\t\t\t\t\t\t {'noreply',_118}\n\t\t\t\t ( <_119> when 'true' ->\n\t\t\t\t\t primop 'match_fail'\n\t\t\t\t\t\t({'case_clause',_119})\n\t\t\t\t\t-| ['compiler_generated'] )\n\t\t\t\t end\n\t\t\t-| ['compiler_generated'] )\n\t\t ( <_296> when 'true' ->\n\t\t\t ( call ( 'erlang'\n\t\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t (( {'badrecord','state'}\n\t\t\t\t -| ['compiler_generated'] ))\n\t\t\t -| ['compiler_generated'] )\n\t\t\t-| ['compiler_generated'] )\n\t\t end\n\t\t -| ['compiler_generated'] )\n\t %% Line 1179\n\t <_339,S> when 'true' ->\n\t %% Line 1180\n\t {'noreply',S}\n\tend\n'terminate'/2 =\n %% Line 1184\n fun (_1,_0) ->\n\tdo %% Line 1185\n\t case call 'application':'get_env'\n\t\t ('kernel', 'shutdown_func') of\n\t %% Line 1186\n\t <{'ok',{M,F}}> when 'true' ->\n\t\t try\n\t\t %% Line 1187\n\t\t call M:F\n\t\t\t (_1)\n\t\t of <_catch_value> ->\n\t\t _catch_value\n\t\t catch ->\n\t\t 'ok'\n\t %% Line 1188\n\t <_15> when 'true' ->\n\t\t 'ok'\n\t end\n\t let <_4> =\n\t\tcase %% Line 1192\n\t\t call 'application':'get_env'\n\t\t\t ('kernel', 'shutdown_timeout') of\n\t\t %% Line 1193\n\t\t <'undefined'> when 'true' ->\n\t\t 'infinity'\n\t\t %% Line 1194\n\t\t <{'ok',T}> when 'true' ->\n\t\t T\n\t\t ( <_3> when 'true' ->\n\t\t\t%% Line 1192\n\t\t\tprimop 'match_fail'\n\t\t\t ({'case_clause',_3})\n\t\t -| ['compiler_generated'] )\n\t\tend\n\t in let <_11> =\n\t\t fun (_9) ->\n\t\t\t%% Line 1196\n\t\t\tcase _9 of\n\t\t\t <{_X_AppName,Id}>\n\t\t\t when call 'erlang':'is_pid'\n\t\t\t\t (Id) ->\n\t\t\t let =\n\t\t\t\t call %% Line 1197\n\t\t\t\t 'erlang':%% Line 1197\n\t\t\t\t\t\t'monitor'\n\t\t\t\t (%% Line 1197\n\t\t\t\t 'process', %% Line 1197\n\t\t\t\t\t\t Id)\n\t\t\t in do %% Line 1198\n\t\t\t\t call 'erlang':'unlink'\n\t\t\t\t\t (Id)\n\t\t\t\t do %% Line 1199\n\t\t\t\t\t call 'erlang':'exit'\n\t\t\t\t\t (Id, 'shutdown')\n\t\t\t\t\t %% Line 1200\n\t\t\t\t\t receive\n\t\t\t\t\t %% Line 1202\n\t\t\t\t\t <{'EXIT',_16,_17}>\n\t\t\t\t\t\twhen call 'erlang':'=:='\n\t\t\t\t\t\t (_16,\n\t\t\t\t\t\t Id) ->\n\t\t\t\t\t\t'ok'\n\t\t\t\t\t after %% Line 1203\n\t\t\t\t\t\t0 ->\n\t\t\t\t\t %% Line 1204\n\t\t\t\t\t receive\n\t\t\t\t\t %% Line 1205\n\t\t\t\t\t <{'DOWN',_18,'process',_19,_20}>\n\t\t\t\t\t\t when let <_21> =\n\t\t\t\t\t\t\tcall 'erlang':'=:='\n\t\t\t\t\t\t\t (_18, Ref)\n\t\t\t\t\t\t in let <_22> =\n\t\t\t\t\t\t\t call 'erlang':'=:='\n\t\t\t\t\t\t\t\t(_19, Id)\n\t\t\t\t\t\t\tin call 'erlang':'and'\n\t\t\t\t\t\t\t\t(_21, _22) ->\n\t\t\t\t\t\t 'ok'\n\t\t\t\t\t after _4 ->\n\t\t\t\t\t do %% Line 1207\n\t\t\t\t\t\t call 'erlang':'exit'\n\t\t\t\t\t\t (Id, 'kill')\n\t\t\t\t\t\t %% Line 1208\n\t\t\t\t\t\t receive\n\t\t\t\t\t\t %% Line 1209\n\t\t\t\t\t\t <{'DOWN',_23,'process',_24,_25}>\n\t\t\t\t\t\t\twhen let <_26> =\n\t\t\t\t\t\t\t call 'erlang':'=:='\n\t\t\t\t\t\t\t\t (_23, Ref)\n\t\t\t\t\t\t\t in let <_27> =\n\t\t\t\t\t\t\t\t call 'erlang':'=:='\n\t\t\t\t\t\t\t\t (_24, Id)\n\t\t\t\t\t\t\t in call 'erlang':'and'\n\t\t\t\t\t\t\t\t (_26, _27) ->\n\t\t\t\t\t\t\t'ok'\n\t\t\t\t\t\t after 'infinity' ->\n\t\t\t\t\t\t 'true'\n\t\t\t %% Line 1213\n\t\t\t <_28> when 'true' ->\n\t\t\t 'ok'\n\t\t\tend\n\t\tin %% Line 1215\n\t\t ( case _0 of\n\t\t\t( <( {'state',_29,_30,_31,_rec128,_32,_33,_34,_35}\n\t\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\t do call 'lists':'foreach'\n\t\t\t\t (_11, _rec128)\n\t\t\t\t %% Line 1216\n\t\t\t\t case call 'ets':'delete'\n\t\t\t\t\t ('ac_tab') of\n\t\t\t\t <'true'> when 'true' ->\n\t\t\t\t\t%% Line 1217\n\t\t\t\t\t'ok'\n\t\t\t\t ( <_12> when 'true' ->\n\t\t\t\t\t primop 'match_fail'\n\t\t\t\t\t ({'badmatch',_12})\n\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t end\n\t\t\t -| ['compiler_generated'] )\n\t\t\t( <_36> when 'true' ->\n\t\t\t ( call ( 'erlang'\n\t\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t (( {'badrecord','state'}\n\t\t\t\t -| ['compiler_generated'] ))\n\t\t\t\t-| ['compiler_generated'] )\n\t\t\t -| ['compiler_generated'] )\n\t\t end\n\t\t -| ['compiler_generated'] )\n'code_change'/3 =\n %% Line 1221\n fun (_2,_1,_0) ->\n\t%% Line 1222\n\t{'ok',_1}\n'cntrl'/3 =\n %% Line 1228\n fun (_2,_1,_0) ->\n\tcase <_2,_1,_0> of\n\t when 'true' ->\n\t %% Line 1229\n\t case call 'lists':'keyfind'\n\t\t (AppName, 1, Control) of\n\t\t%% Line 1230\n\t\t<{_X_AppName,Pid}> when 'true' ->\n\t\t do %% Line 1231\n\t\t\tcall 'erlang':'!'\n\t\t\t (Pid, Msg)\n\t\t\t%% Line 1232\n\t\t\t'true'\n\t\t%% Line 1233\n\t\t<'false'> when 'true' ->\n\t\t %% Line 1234\n\t\t 'false'\n\t\t( <_3> when 'true' ->\n\t\t primop 'match_fail'\n\t\t\t ({'case_clause',_3})\n\t\t -| ['compiler_generated'] )\n\t end\n\t ( <_6,_5,_4> when 'true' ->\n\t\t( primop 'match_fail'\n\t\t ({'function_clause',_6,_5,_4})\n\t\t -| [{'function_name',{'cntrl',3}}] )\n\t -| ['compiler_generated'] )\n\tend\n'notify_cntrl_started'/4 =\n %% Line 1237\n fun (_3,_2,_1,_0) ->\n\tcase <_3,_2,_1,_0> of\n\t <_X_AppName,{'distributed',_X_Node},_X_S,_X_Res> when 'true' ->\n\t %% Line 1238\n\t 'ok'\n\t %% Line 1239\n\t when 'true' ->\n\t %% Line 1240\n\t apply 'cntrl'/3\n\t\t (AppName, S, {'ac_application_run',AppName,Res})\n\tend\n'del_cntrl'/2 =\n %% Line 1242\n fun (_1,_0) ->\n\tcase <_1,_0> of\n\t <[{_5,Pid}|T],_6>\n\t when call 'erlang':'=:='\n\t\t (_6,\n\t\t Pid) ->\n\t %% Line 1243\n\t apply 'del_cntrl'/2\n\t\t (T, Pid)\n\t %% Line 1244\n\t <[H|T],Pid> when 'true' ->\n\t let <_2> =\n\t\t apply %% Line 1245\n\t\t\t'del_cntrl'/2\n\t\t (%% Line 1245\n\t\t T, %% Line 1245\n\t\t\t Pid)\n\t in %% Line 1245\n\t\t [H|_2]\n\t %% Line 1246\n\t <[],_X_Pid> when 'true' ->\n\t %% Line 1247\n\t []\n\t ( <_4,_3> when 'true' ->\n\t\t( primop 'match_fail'\n\t\t ({'function_clause',_4,_3})\n\t\t -| [{'function_name',{'del_cntrl',2}}] )\n\t -| ['compiler_generated'] )\n\tend\n'get_loaded'/1 =\n %% Line 1249\n fun (_0) ->\n\tlet =\n\t apply %% Line 1250\n\t\t 'get_appl_name'/1\n\t\t(_0)\n\tin %% Line 1251\n\t case call 'ets':'lookup'\n\t\t ('ac_tab', {'loaded',AppName}) of\n\t %% Line 1252\n\t <[{_X_Key,Appl}|[]]> when 'true' ->\n\t\t {'true',Appl}\n\t %% Line 1253\n\t <_4> when 'true' ->\n\t\t 'false'\n\t end\n'do_load_application'/2 =\n %% Line 1256\n fun (_1,_0) ->\n\t%% Line 1257\n\tcase apply 'get_loaded'/1\n\t\t (_1) of\n\t %% Line 1258\n\t <{'true',_6}> when 'true' ->\n\t %% Line 1259\n\t call 'erlang':'throw'\n\t\t ({'error',{'already_loaded',_1}})\n\t %% Line 1260\n\t <'false'> when 'true' ->\n\t %% Line 1261\n\t case apply 'make_appl'/1\n\t\t (_1) of\n\t\t%% Line 1262\n\t\t<{'ok',Appl}> when 'true' ->\n\t\t apply 'load'/2\n\t\t\t(_0, Appl)\n\t\t%% Line 1263\n\t\t when 'true' ->\n\t\t Error\n\t end\n\t ( <_3> when 'true' ->\n\t\tprimop 'match_fail'\n\t\t ({'case_clause',_3})\n\t -| ['compiler_generated'] )\n\tend\n'load'/2 =\n %% Line 1269\n fun (_1,_0) ->\n\tcase <_1,_0> of\n\t when 'true' ->\n\t %% Line 1270\n\t ( case ApplData of\n\t\t ( <( {'appl_data',_rec129,_20,_21,_22,_23,_24,_25,_26}\n\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\tlet =\n\t\t\t apply %% Line 1271\n\t\t\t\t 'get_env_i'/2\n\t\t\t\t(_rec129, %% Line 1271\n\t\t\t\t\t S)\n\t\t\tin let =\n\t\t\t\tapply %% Line 1272\n\t\t\t\t 'merge_app_env'/2\n\t\t\t\t (%% Line 1272\n\t\t\t\t ApplEnv, %% Line 1272\n\t\t\t\t\t ConfEnv)\n\t\t\t in let =\n\t\t\t\t apply %% Line 1273\n\t\t\t\t\t 'get_cmd_env'/1\n\t\t\t\t\t(_rec129)\n\t\t\t\tin let =\n\t\t\t\t\tapply %% Line 1274\n\t\t\t\t\t 'merge_app_env'/2\n\t\t\t\t\t (%% Line 1274\n\t\t\t\t\t NewEnv, %% Line 1274\n\t\t\t\t\t\t CmdLineEnv)\n\t\t\t\t in do %% Line 1275\n\t\t\t\t\t apply 'add_env'/2\n\t\t\t\t\t\t(_rec129, NewEnv2)\n\t\t\t\t\t let =\n\t\t\t\t\t\t{%% Line 1276\n\t\t\t\t\t\t 'appl',_rec129,%% Line 1277\n\t\t\t\t\t\t\t\tApplData,%% Line 1276\n\t\t\t\t\t\t\t\t\t Descr,%% Line 1276\n\t\t\t\t\t\t\t\t\t Id,%% Line 1276\n\t\t\t\t\t\t\t\t\t\t Vsn,'undefined',%% Line 1277\n\t\t\t\t\t\t\t\t\t\t\t\t IncApps,%% Line 1277\n\t\t\t\t\t\t\t\t\t\t\t\t\t Apps}\n\t\t\t\t\t in do %% Line 1278\n\t\t\t\t\t\t call 'ets':'insert'\n\t\t\t\t\t\t\t('ac_tab', {{'loaded',_rec129},Appl})\n\t\t\t\t\t\t let <_16> =\n\t\t\t\t\t\t\tfun (_13,_12) ->\n\t\t\t\t\t\t\t %% Line 1281\n\t\t\t\t\t\t\t case apply 'get_loaded'/1\n\t\t\t\t\t\t\t\t (_13) of\n\t\t\t\t\t\t\t %% Line 1282\n\t\t\t\t\t\t\t <{'true',_28}> when 'true' ->\n\t\t\t\t\t\t\t\t _12\n\t\t\t\t\t\t\t %% Line 1283\n\t\t\t\t\t\t\t <'false'> when 'true' ->\n\t\t\t\t\t\t\t\t %% Line 1284\n\t\t\t\t\t\t\t\t case apply 'do_load_application'/2\n\t\t\t\t\t\t\t\t\t (_13, _12) of\n\t\t\t\t\t\t\t\t %% Line 1285\n\t\t\t\t\t\t\t\t <{'ok',S2}> when 'true' ->\n\t\t\t\t\t\t\t\t\tS2\n\t\t\t\t\t\t\t\t %% Line 1286\n\t\t\t\t\t\t\t\t when 'true' ->\n\t\t\t\t\t\t\t\t\tcall 'erlang':'throw'\n\t\t\t\t\t\t\t\t\t (Error)\n\t\t\t\t\t\t\t\t end\n\t\t\t\t\t\t\t ( <_11> when 'true' ->\n\t\t\t\t\t\t\t\t primop 'match_fail'\n\t\t\t\t\t\t\t\t\t({'case_clause',_11})\n\t\t\t\t\t\t\t\t-| ['compiler_generated'] )\n\t\t\t\t\t\t\t end\n\t\t\t\t\t\t in let =\n\t\t\t\t\t\t\t call %% Line 1280\n\t\t\t\t\t\t\t\t 'lists':%% Line 1280\n\t\t\t\t\t\t\t\t\t 'foldl'\n\t\t\t\t\t\t\t\t(_16, %% Line 1289\n\t\t\t\t\t\t\t\t S, %% Line 1289\n\t\t\t\t\t\t\t\t\t IncApps)\n\t\t\t\t\t\t\tin %% Line 1290\n\t\t\t\t\t\t\t {'ok',NewS}\n\t\t -| ['compiler_generated'] )\n\t\t ( <_27> when 'true' ->\n\t\t\t( call ( 'erlang'\n\t\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t (( {'badrecord','appl_data'}\n\t\t\t\t -| ['compiler_generated'] ))\n\t\t\t -| ['compiler_generated'] )\n\t\t -| ['compiler_generated'] )\n\t\tend\n\t\t-| ['compiler_generated'] )\n\t ( <_19,_18> when 'true' ->\n\t\t( primop 'match_fail'\n\t\t ({'function_clause',_19,_18})\n\t\t -| [{'function_name',{'load',2}}] )\n\t -| ['compiler_generated'] )\n\tend\n'unload'/2 =\n %% Line 1292\n fun (_1,_0) ->\n\t%% Line 1293\n\tcase apply 'get_key'/2\n\t\t (_1, 'included_applications') of\n\t <{'ok',IncApps}> when 'true' ->\n\t do %% Line 1294\n\t\t apply 'del_env'/1\n\t\t (_1)\n\t\t do %% Line 1295\n\t\t call 'ets':'delete'\n\t\t\t ('ac_tab', {'loaded',_1})\n\t\t let <_8> =\n\t\t\t fun (_5,_4) ->\n\t\t\t %% Line 1297\n\t\t\t case apply 'get_loaded'/1\n\t\t\t\t (_5) of\n\t\t\t\t%% Line 1298\n\t\t\t\t<'false'> when 'true' ->\n\t\t\t\t _4\n\t\t\t\t%% Line 1299\n\t\t\t\t<{'true',_11}> when 'true' ->\n\t\t\t\t apply 'unload'/2\n\t\t\t\t\t(_5, _4)\n\t\t\t\t( <_3> when 'true' ->\n\t\t\t\t primop 'match_fail'\n\t\t\t\t\t ({'case_clause',_3})\n\t\t\t\t -| ['compiler_generated'] )\n\t\t\t end\n\t\t in %% Line 1296\n\t\t\t call 'lists':'foldl'\n\t\t\t (_8, _0, %% Line 1301\n\t\t\t\t IncApps)\n\t ( <_2> when 'true' ->\n\t\tprimop 'match_fail'\n\t\t ({'badmatch',_2})\n\t -| ['compiler_generated'] )\n\tend\n'check_start_cond'/4 =\n %% Line 1303\n fun (_3,_2,_1,_0) ->\n\tdo %% Line 1304\n\t apply 'validRestartType'/1\n\t\t(_2)\n\t %% Line 1305\n\t case apply 'get_loaded'/1\n\t\t (_3) of\n\t %% Line 1306\n\t <{'true',Appl}> when 'true' ->\n\t\t %% Line 1309\n\t\t case call 'lists':'keymember'\n\t\t\t (_3, 1, _0) of\n\t\t %% Line 1310\n\t\t <'true'> when 'true' ->\n\t\t\t%% Line 1311\n\t\t\t{'error',{'already_started',_3}}\n\t\t %% Line 1312\n\t\t <'false'> when 'true' ->\n\t\t\tlet <_9> =\n\t\t\t fun (_7) ->\n\t\t\t\t%% Line 1315\n\t\t\t\tcase call 'lists':'keymember'\n\t\t\t\t\t (_7, 1, _1) of\n\t\t\t\t %% Line 1316\n\t\t\t\t <'true'> when 'true' ->\n\t\t\t\t 'ok'\n\t\t\t\t %% Line 1317\n\t\t\t\t <'false'> when 'true' ->\n\t\t\t\t %% Line 1318\n\t\t\t\t call 'erlang':'throw'\n\t\t\t\t\t ({'error',{'not_started',_7}})\n\t\t\t\t ( <_6> when 'true' ->\n\t\t\t\t\tprimop 'match_fail'\n\t\t\t\t\t ({'case_clause',_6})\n\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\tend\n\t\t\tin %% Line 1320\n\t\t\t ( case Appl of\n\t\t\t\t( <( {'appl',_16,_17,_18,_19,_20,_21,_22,_rec130}\n\t\t\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\t\t do call 'lists':'foreach'\n\t\t\t\t\t (_9, _rec130)\n\t\t\t\t\t %% Line 1321\n\t\t\t\t\t {'ok',Appl}\n\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t( <_23> when 'true' ->\n\t\t\t\t ( call ( 'erlang'\n\t\t\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t (( {'badrecord','appl'}\n\t\t\t\t\t -| ['compiler_generated'] ))\n\t\t\t\t\t-| ['compiler_generated'] )\n\t\t\t\t -| ['compiler_generated'] )\n\t\t\t end\n\t\t\t -| ['compiler_generated'] )\n\t\t ( <_10> when 'true' ->\n\t\t\t primop 'match_fail'\n\t\t\t ({'case_clause',_10})\n\t\t -| ['compiler_generated'] )\n\t\t end\n\t %% Line 1323\n\t <'false'> when 'true' ->\n\t\t %% Line 1324\n\t\t {'error',{'not_loaded',_3}}\n\t ( <_11> when 'true' ->\n\t\t primop 'match_fail'\n\t\t\t({'case_clause',_11})\n\t\t-| ['compiler_generated'] )\n\t end\n'do_start'/5 =\n %% Line 1327\n fun (_4,_3,_2,_1,_0) ->\n\t%% Line 1328\n\t( case _0 of\n\t ( <( {'state',_34,_35,_36,_37,_38,_rec131,_39,_40}\n\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t let <_8> =\n\t\t case call 'lists':'keyfind'\n\t\t\t (_4, 1, _rec131) of\n\t\t\t%% Line 1329\n\t\t\t<{_X_AppName2,OldRT}> when 'true' ->\n\t\t\t %% Line 1330\n\t\t\t apply 'get_restart_type'/2\n\t\t\t\t(_3, OldRT)\n\t\t\t%% Line 1331\n\t\t\t<'false'> when 'true' ->\n\t\t\t _3\n\t\t\t( <_7> when 'true' ->\n\t\t\t primop 'match_fail'\n\t\t\t\t ({'case_clause',_7})\n\t\t\t -| ['compiler_generated'] )\n\t\t end\n\t\t in %% Line 1336\n\t\t case call 'lists':'keymember'\n\t\t\t (_4, 1, _39) of\n\t\t\t%% Line 1337\n\t\t\t<'false'> when 'true' ->\n\t\t\t %% Line 1338\n\t\t\t case apply 'get_loaded'/1\n\t\t\t\t (_4) of\n\t\t\t <{'true',Appl}> when 'true' ->\n\t\t\t\t do %% Line 1340\n\t\t\t\t apply 'spawn_starter'/4\n\t\t\t\t\t ('undefined', Appl, _0, _2)\n\t\t\t\t let <_22> =\n\t\t\t\t\t case %% Line 1341\n\t\t\t\t\t call 'lists':'keymember'\n\t\t\t\t\t\t (_4, 1, _35) of\n\t\t\t\t\t %% Line 1342\n\t\t\t\t\t <'false'> when 'true' ->\n\t\t\t\t\t\t%% Line 1344\n\t\t\t\t\t\t[{_4,_8,_2,_1}|_35]\n\t\t\t\t\t %% Line 1346\n\t\t\t\t\t <'true'> when 'true' ->\n\t\t\t\t\t\t_35\n\t\t\t\t\t ( <_21> when 'true' ->\n\t\t\t\t\t\t %% Line 1341\n\t\t\t\t\t\t primop 'match_fail'\n\t\t\t\t\t\t ({'case_clause',_21})\n\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t end\n\t\t\t\t in let <_rec137> =\n\t\t\t\t\t [%% Line 1350\n\t\t\t\t\t {_4,_1}|_39]\n\t\t\t\t\t in let <_26> =\n\t\t\t\t\t\t call %% Line 1350\n\t\t\t\t\t\t 'erlang':%% Line 1350\n\t\t\t\t\t\t\t\t'setelement'\n\t\t\t\t\t\t (%% Line 1350\n\t\t\t\t\t\t 8, _0, %% Line 1350\n\t\t\t\t\t\t\t _rec137)\n\t\t\t\t\t in %% Line 1349\n\t\t\t\t\t\t call 'erlang':'setelement'\n\t\t\t\t\t\t (3, _26, _22)\n\t\t\t ( <_12> when 'true' ->\n\t\t\t\t primop 'match_fail'\n\t\t\t\t\t({'badmatch',_12})\n\t\t\t\t-| ['compiler_generated'] )\n\t\t\t end\n\t\t\t%% Line 1351\n\t\t\t<'true'> when 'true' ->\n\t\t\t _0\n\t\t\t( <_28> when 'true' ->\n\t\t\t primop 'match_fail'\n\t\t\t\t ({'case_clause',_28})\n\t\t\t -| ['compiler_generated'] )\n\t\t end\n\t -| ['compiler_generated'] )\n\t ( <_41> when 'true' ->\n\t\t ( call ( 'erlang'\n\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t(( {'badrecord','state'}\n\t\t\t -| ['compiler_generated'] ))\n\t\t -| ['compiler_generated'] )\n\t -| ['compiler_generated'] )\n\t end\n\t -| ['compiler_generated'] )\n'spawn_starter'/4 =\n %% Line 1355\n fun (_3,_2,_1,_0) ->\n\t%% Line 1356\n\tcall 'erlang':'spawn_link'\n\t ('application_controller', 'init_starter', [_3|[_2|[_1|[_0|[]]]]])\n'init_starter'/4 =\n %% Line 1358\n fun (_3,_2,_1,_0) ->\n\tdo %% Line 1359\n\t call 'erlang':'process_flag'\n\t\t('trap_exit', 'true')\n\t %% Line 1360\n\t ( case _2 of\n\t\t( <( {'appl',_rec139,_12,_13,_14,_15,_16,_17,_18}\n\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t let <_7> =\n\t\t\t catch\n\t\t\t %% Line 1362\n\t\t\t apply 'start_appl'/3\n\t\t\t\t (_2, _1, _0)\n\t\t in %% Line 1361\n\t\t\t call 'gen_server':'cast'\n\t\t\t ('application_controller', {'application_started',_rec139,_7})\n\t\t -| ['compiler_generated'] )\n\t\t( <_19> when 'true' ->\n\t\t ( call ( 'erlang'\n\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t (( {'badrecord','appl'}\n\t\t\t -| ['compiler_generated'] ))\n\t\t\t-| ['compiler_generated'] )\n\t\t -| ['compiler_generated'] )\n\t end\n\t -| ['compiler_generated'] )\n'reply'/2 =\n %% Line 1364\n fun (_1,_0) ->\n\tcase <_1,_0> of\n\t <'undefined',_X_Reply> when 'true' ->\n\t %% Line 1365\n\t 'ok'\n\t %% Line 1366\n\t when 'true' ->\n\t call 'gen_server':'reply'\n\t\t (From, Reply)\n\tend\n'start_appl'/3 =\n %% Line 1368\n fun (_2,_1,_0) ->\n\t%% Line 1369\n\t( case _2 of\n\t ( <( {'appl',_22,_rec140,_23,_24,_25,_26,_27,_28}\n\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t %% Line 1370\n\t\t ( case _rec140 of\n\t\t ( <( {'appl_data',_30,_31,_32,_rec141,_33,_34,_35,_36}\n\t\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\t case _rec141 of\n\t\t\t %% Line 1371\n\t\t\t <[]> when 'true' ->\n\t\t\t\t %% Line 1372\n\t\t\t\t {'ok','undefined'}\n\t\t\t %% Line 1373\n\t\t\t <_38> when 'true' ->\n\t\t\t\t %% Line 1375\n\t\t\t\t ( case _1 of\n\t\t\t\t ( <( {'state',_39,_40,_41,_rec142,_42,_43,_44,_45}\n\t\t\t\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\t\t\t let <_16> =\n\t\t\t\t\t\tfun (_14) ->\n\t\t\t\t\t\t %% Line 1378\n\t\t\t\t\t\t case call 'lists':'keymember'\n\t\t\t\t\t\t\t (_14, 1, _rec142) of\n\t\t\t\t\t\t %% Line 1379\n\t\t\t\t\t\t <'true'> when 'true' ->\n\t\t\t\t\t\t\t %% Line 1380\n\t\t\t\t\t\t\t 'ok'\n\t\t\t\t\t\t %% Line 1381\n\t\t\t\t\t\t <'false'> when 'true' ->\n\t\t\t\t\t\t\t %% Line 1382\n\t\t\t\t\t\t\t call 'erlang':'throw'\n\t\t\t\t\t\t\t ({'info',{'not_running',_14}})\n\t\t\t\t\t\t ( <_13> when 'true' ->\n\t\t\t\t\t\t\t primop 'match_fail'\n\t\t\t\t\t\t\t\t({'case_clause',_13})\n\t\t\t\t\t\t\t-| ['compiler_generated'] )\n\t\t\t\t\t\t end\n\t\t\t\t\t in do %% Line 1376\n\t\t\t\t\t\t call 'lists':'foreach'\n\t\t\t\t\t\t\t(_16, _28)\n\t\t\t\t\t\t %% Line 1385\n\t\t\t\t\t\t case call 'application_master':'start_link'\n\t\t\t\t\t\t\t (_rec140, _0) of\n\t\t\t\t\t\t %% Line 1386\n\t\t\t\t\t\t when 'true' ->\n\t\t\t\t\t\t\t %% Line 1387\n\t\t\t\t\t\t\t Ok\n\t\t\t\t\t\t %% Line 1388\n\t\t\t\t\t\t when 'true' ->\n\t\t\t\t\t\t\t %% Line 1389\n\t\t\t\t\t\t\t call 'erlang':'throw'\n\t\t\t\t\t\t\t (Error)\n\t\t\t\t\t\t ( <_17> when 'true' ->\n\t\t\t\t\t\t\t primop 'match_fail'\n\t\t\t\t\t\t\t\t({'case_clause',_17})\n\t\t\t\t\t\t\t-| ['compiler_generated'] )\n\t\t\t\t\t\t end\n\t\t\t\t\t-| ['compiler_generated'] )\n\t\t\t\t ( <_46> when 'true' ->\n\t\t\t\t\t ( call ( 'erlang'\n\t\t\t\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t\t (( {'badrecord','state'}\n\t\t\t\t\t\t -| ['compiler_generated'] ))\n\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t-| ['compiler_generated'] )\n\t\t\t\t end\n\t\t\t\t -| ['compiler_generated'] )\n\t\t\t end\n\t\t\t-| ['compiler_generated'] )\n\t\t ( <_37> when 'true' ->\n\t\t\t ( call ( 'erlang'\n\t\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t (( {'badrecord','appl_data'}\n\t\t\t\t -| ['compiler_generated'] ))\n\t\t\t -| ['compiler_generated'] )\n\t\t\t-| ['compiler_generated'] )\n\t\t end\n\t\t -| ['compiler_generated'] )\n\t -| ['compiler_generated'] )\n\t ( <_29> when 'true' ->\n\t\t ( call ( 'erlang'\n\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t(( {'badrecord','appl'}\n\t\t\t -| ['compiler_generated'] ))\n\t\t -| ['compiler_generated'] )\n\t -| ['compiler_generated'] )\n\t end\n\t -| ['compiler_generated'] )\n'stop_appl'/3 =\n %% Line 1397\n fun (_2,_1,_0) ->\n\tcase <_2,_1,_0> of\n\t \n\t when call 'erlang':'is_pid'\n\t\t (Id) ->\n\t do %% Line 1398\n\t\t call 'erlang':'unlink'\n\t\t (Id)\n\t\t do %% Line 1399\n\t\t call 'application_master':'stop'\n\t\t\t (Id)\n\t\t do %% Line 1400\n\t\t\t apply 'info_exited'/3\n\t\t\t (AppName, 'stopped', Type)\n\t\t\t %% Line 1401\n\t\t\t call 'ets':'delete'\n\t\t\t ('ac_tab', {'application_master',AppName})\n\t %% Line 1402\n\t when 'true' ->\n\t %% Line 1404\n\t apply 'info_exited'/3\n\t\t (AppName, 'stopped', Type)\n\t %% Line 1405\n\t <_X_AppName,_X_Id,_X_Type> when 'true' ->\n\t %% Line 1407\n\t 'ok'\n\tend\n'keysearchdelete'/3 =\n %% Line 1409\n fun (_2,_1,_0) ->\n\t%% Line 1410\n\tapply 'ksd'/4\n\t (_2, _1, _0, [])\n'ksd'/4 =\n %% Line 1412\n fun (_3,_2,_1,_0) ->\n\tcase <_3,_2,_1,_0> of\n\t \n\t when try\n\t\t let <_4> =\n\t\t\tcall 'erlang':'element'\n\t\t\t (Pos, H)\n\t\t in call 'erlang':'=:='\n\t\t\t (_4, Key)\n\t\tof ->\n\t\t Try\n\t\tcatch ->\n\t\t 'false' ->\n\t let <_5> =\n\t\t call %% Line 1413\n\t\t 'erlang':%% Line 1413\n\t\t\t\t'++'\n\t\t (%% Line 1413\n\t\t Rest, %% Line 1413\n\t\t\t T)\n\t in %% Line 1413\n\t\t {'value',H,_5}\n\t %% Line 1414\n\t when 'true' ->\n\t %% Line 1415\n\t apply 'ksd'/4\n\t\t (Key, Pos, T, [H|Rest])\n\t %% Line 1416\n\t <_X_Key,_X_Pos,[],_X_Rest> when 'true' ->\n\t %% Line 1417\n\t 'false'\n\t ( <_9,_8,_7,_6> when 'true' ->\n\t\t( primop 'match_fail'\n\t\t ({'function_clause',_9,_8,_7,_6})\n\t\t -| [{'function_name',{'ksd',4}}] )\n\t -| ['compiler_generated'] )\n\tend\n'keyreplaceadd'/4 =\n %% Line 1419\n fun (_3,_2,_1,_0) ->\n\t%% Line 1421\n\tcase call 'lists':'keymember'\n\t\t (_3, _2, _1) of\n\t %% Line 1422\n\t <'true'> when 'true' ->\n\t call 'lists':'keyreplace'\n\t\t (_3, _2, _1, _0)\n\t %% Line 1423\n\t <'false'> when 'true' ->\n\t [_0|_1]\n\t ( <_4> when 'true' ->\n\t\tprimop 'match_fail'\n\t\t ({'case_clause',_4})\n\t -| ['compiler_generated'] )\n\tend\n'validRestartType'/1 =\n %% Line 1426\n fun (_0) ->\n\tcase _0 of\n\t <'permanent'> when 'true' ->\n\t 'true'\n\t %% Line 1427\n\t <'temporary'> when 'true' ->\n\t 'true'\n\t %% Line 1428\n\t <'transient'> when 'true' ->\n\t 'true'\n\t %% Line 1429\n\t when 'true' ->\n\t %% Line 1430\n\t call 'erlang':'throw'\n\t\t ({'error',{'invalid_restart_type',RestartType}})\n\tend\n'nd'/1 =\n %% Line 1432\n fun (_0) ->\n\tcase _0 of\n\t <{'distributed',Node}> when 'true' ->\n\t Node\n\t %% Line 1433\n\t <_2> when 'true' ->\n\t call 'erlang':'node'\n\t\t ()\n\tend\n'get_restart_type'/2 =\n %% Line 1435\n fun (_1,_0) ->\n\tcase <_1,_0> of\n\t <'undefined',OldRT> when 'true' ->\n\t %% Line 1436\n\t OldRT\n\t %% Line 1437\n\t when 'true' ->\n\t %% Line 1438\n\t RT\n\tend\n'get_appl_name'/1 =\n %% Line 1440\n fun (_0) ->\n\tcase _0 of\n\t \n\t when call 'erlang':'is_atom'\n\t\t (_0) ->\n\t Name\n\t %% Line 1441\n\t <{'application',Name,_2}>\n\t when call 'erlang':'is_atom'\n\t\t (Name) ->\n\t Name\n\t %% Line 1442\n\t when 'true' ->\n\t call 'erlang':'throw'\n\t\t ({'error',{'bad_application',Appl}})\n\tend\n'make_appl'/1 =\n %% Line 1444\n fun (_0) ->\n\tcase _0 of\n\t \n\t when call 'erlang':'is_atom'\n\t\t (_0) ->\n\t let <_1> =\n\t\t call %% Line 1445\n\t\t 'erlang':%% Line 1445\n\t\t\t\t'atom_to_list'\n\t\t (%% Line 1445\n\t\t Name)\n\t in let =\n\t\t call %% Line 1445\n\t\t\t 'erlang':%% Line 1445\n\t\t\t\t '++'\n\t\t\t (_1, %% Line 1445\n\t\t\t [46|[97|[112|[112]]]])\n\t\t in %% Line 1446\n\t\t case call 'code':'where_is_file'\n\t\t\t (FName) of\n\t\t\t%% Line 1447\n\t\t\t<'non_existing'> when 'true' ->\n\t\t\t let <_3> =\n\t\t\t\tcall %% Line 1448\n\t\t\t\t 'file':%% Line 1448\n\t\t\t\t\t 'format_error'\n\t\t\t\t (%% Line 1448\n\t\t\t\t 'enoent')\n\t\t\t in %% Line 1448\n\t\t\t\t{'error',{_3,FName}}\n\t\t\t%% Line 1449\n\t\t\t when 'true' ->\n\t\t\t %% Line 1450\n\t\t\t case apply 'prim_consult'/1\n\t\t\t\t (FullName) of\n\t\t\t %% Line 1451\n\t\t\t <{'ok',[Application|[]]}> when 'true' ->\n\t\t\t\t let <_4> =\n\t\t\t\t apply %% Line 1452\n\t\t\t\t\t 'make_appl_i'/1\n\t\t\t\t\t (%% Line 1452\n\t\t\t\t\t Application)\n\t\t\t\t in %% Line 1452\n\t\t\t\t {'ok',_4}\n\t\t\t %% Line 1453\n\t\t\t <{'error',Reason}> when 'true' ->\n\t\t\t\t let <_5> =\n\t\t\t\t call %% Line 1454\n\t\t\t\t\t 'file':%% Line 1454\n\t\t\t\t\t\t 'format_error'\n\t\t\t\t\t (%% Line 1454\n\t\t\t\t\t Reason)\n\t\t\t\t in %% Line 1454\n\t\t\t\t {'error',{_5,FName}}\n\t\t\t %% Line 1455\n\t\t\t <'error'> when 'true' ->\n\t\t\t\t %% Line 1456\n\t\t\t\t {'error',[98|[97|[100|[32|[101|[110|[99|[111|[100|[105|[110|[103]]]]]]]]]]]]}\n\t\t\t ( <_6> when 'true' ->\n\t\t\t\t primop 'match_fail'\n\t\t\t\t\t({'case_clause',_6})\n\t\t\t\t-| ['compiler_generated'] )\n\t\t\t end\n\t\t end\n\t %% Line 1459\n\t when 'true' ->\n\t let <_8> =\n\t\t apply %% Line 1460\n\t\t\t'make_appl_i'/1\n\t\t (%% Line 1460\n\t\t Application)\n\t in %% Line 1460\n\t\t {'ok',_8}\n\tend\n'prim_consult'/1 =\n %% Line 1462\n fun (_0) ->\n\t%% Line 1463\n\tcase call 'erl_prim_loader':'get_file'\n\t\t (_0) of\n\t %% Line 1464\n\t <{'ok',Bin,_5}> when 'true' ->\n\t %% Line 1465\n\t case apply 'file_binary_to_list'/1\n\t\t (Bin) of\n\t\t%% Line 1466\n\t\t<{'ok',String}> when 'true' ->\n\t\t %% Line 1467\n\t\t case call 'erl_scan':'string'\n\t\t\t (String) of\n\t\t %% Line 1468\n\t\t <{'ok',Tokens,_X_EndLine}> when 'true' ->\n\t\t\t %% Line 1469\n\t\t\t apply 'prim_parse'/2\n\t\t\t (Tokens, [])\n\t\t %% Line 1470\n\t\t <{'error',Reason,_X_EndLine}> when 'true' ->\n\t\t\t %% Line 1471\n\t\t\t {'error',Reason}\n\t\t ( <_1> when 'true' ->\n\t\t\t primop 'match_fail'\n\t\t\t\t({'case_clause',_1})\n\t\t\t-| ['compiler_generated'] )\n\t\t end\n\t\t%% Line 1473\n\t\t<'error'> when 'true' ->\n\t\t %% Line 1474\n\t\t 'error'\n\t\t( <_2> when 'true' ->\n\t\t primop 'match_fail'\n\t\t\t ({'case_clause',_2})\n\t\t -| ['compiler_generated'] )\n\t end\n\t %% Line 1476\n\t <'error'> when 'true' ->\n\t %% Line 1477\n\t {'error','enoent'}\n\t ( <_3> when 'true' ->\n\t\tprimop 'match_fail'\n\t\t ({'case_clause',_3})\n\t -| ['compiler_generated'] )\n\tend\n'prim_parse'/2 =\n %% Line 1480\n fun (_1,_0) ->\n\tlet <_5> =\n\t fun (_3) ->\n\t\tlet <_2> =\n\t\t call %% Line 1481\n\t\t\t 'erlang':%% Line 1481\n\t\t\t\t 'element'\n\t\t\t(%% Line 1481\n\t\t\t 1, %% Line 1481\n\t\t\t _3)\n\t\tin %% Line 1481\n\t\t call 'erlang':'=/='\n\t\t\t(_2, 'dot')\n\tin %% Line 1481\n\t case call 'lists':'splitwith'\n\t\t (_5, _1) of\n\t %% Line 1482\n\t <{[],[]}> when 'true' ->\n\t\t let <_6> =\n\t\t call %% Line 1483\n\t\t\t 'lists':%% Line 1483\n\t\t\t\t 'reverse'\n\t\t\t (_0)\n\t\t in %% Line 1483\n\t\t {'ok',_6}\n\t %% Line 1484\n\t <{Tokens2,[Dot = {'dot',_14}|Rest]}> when 'true' ->\n\t\t let <_7> =\n\t\t call %% Line 1485\n\t\t\t 'erlang':%% Line 1485\n\t\t\t\t '++'\n\t\t\t (%% Line 1485\n\t\t\t Tokens2, %% Line 1485\n\t\t\t\t [Dot|[]])\n\t\t in %% Line 1485\n\t\t case call 'erl_parse':'parse_term'\n\t\t\t (_7) of\n\t\t\t%% Line 1486\n\t\t\t<{'ok',Term}> when 'true' ->\n\t\t\t %% Line 1487\n\t\t\t apply 'prim_parse'/2\n\t\t\t\t(Rest, [Term|_0])\n\t\t\t%% Line 1488\n\t\t\t when 'true' ->\n\t\t\t %% Line 1489\n\t\t\t Error\n\t\t\t( <_8> when 'true' ->\n\t\t\t primop 'match_fail'\n\t\t\t\t ({'case_clause',_8})\n\t\t\t -| ['compiler_generated'] )\n\t\t end\n\t %% Line 1491\n\t <{Tokens2,[]}> when 'true' ->\n\t\t %% Line 1492\n\t\t case call 'erl_parse':'parse_term'\n\t\t\t (Tokens2) of\n\t\t %% Line 1493\n\t\t <{'ok',Term}> when 'true' ->\n\t\t\tlet <_9> =\n\t\t\t call %% Line 1494\n\t\t\t\t 'lists':%% Line 1494\n\t\t\t\t\t 'reverse'\n\t\t\t\t(%% Line 1494\n\t\t\t\t [Term|_0])\n\t\t\tin %% Line 1494\n\t\t\t {'ok',_9}\n\t\t %% Line 1495\n\t\t when 'true' ->\n\t\t\t%% Line 1496\n\t\t\tError\n\t\t ( <_10> when 'true' ->\n\t\t\t primop 'match_fail'\n\t\t\t ({'case_clause',_10})\n\t\t -| ['compiler_generated'] )\n\t\t end\n\t ( <_11> when 'true' ->\n\t\t primop 'match_fail'\n\t\t\t({'case_clause',_11})\n\t\t-| ['compiler_generated'] )\n\t end\n'make_appl_i'/1 =\n %% Line 1500\n fun (_0) ->\n\tcase _0 of\n\t <{'application',Name,Opts}>\n\t when let <_1> =\n\t\t call 'erlang':'is_atom'\n\t\t\t(Name)\n\t\tin let <_2> =\n\t\t\tcall 'erlang':'is_list'\n\t\t\t (Opts)\n\t\t in call 'erlang':'and'\n\t\t\t (_1, _2) ->\n\t let =\n\t\t apply %% Line 1501\n\t\t\t'get_opt'/3\n\t\t (%% Line 1501\n\t\t 'description', %% Line 1501\n\t\t\t\t Opts, %% Line 1501\n\t\t\t\t\t [])\n\t in let =\n\t\t apply %% Line 1502\n\t\t\t 'get_opt'/3\n\t\t\t (%% Line 1502\n\t\t\t 'id', %% Line 1502\n\t\t\t\t Opts, %% Line 1502\n\t\t\t\t [])\n\t\t in let =\n\t\t\t apply %% Line 1503\n\t\t\t\t'get_opt'/3\n\t\t\t (%% Line 1503\n\t\t\t 'vsn', %% Line 1503\n\t\t\t\t Opts, %% Line 1503\n\t\t\t\t\t [])\n\t\t in let =\n\t\t\t apply %% Line 1504\n\t\t\t\t 'get_opt'/3\n\t\t\t\t (%% Line 1504\n\t\t\t\t 'modules', %% Line 1504\n\t\t\t\t\t Opts, %% Line 1504\n\t\t\t\t\t\t [])\n\t\t\t in let =\n\t\t\t\t apply %% Line 1505\n\t\t\t\t\t'get_opt'/3\n\t\t\t\t (%% Line 1505\n\t\t\t\t 'registered', %% Line 1505\n\t\t\t\t\t\t Opts, %% Line 1505\n\t\t\t\t\t\t\t [])\n\t\t\t in let =\n\t\t\t\t apply %% Line 1506\n\t\t\t\t\t 'get_opt'/3\n\t\t\t\t\t (%% Line 1506\n\t\t\t\t\t 'applications', %% Line 1506\n\t\t\t\t\t\t\t Opts, %% Line 1506\n\t\t\t\t\t\t\t\t [])\n\t\t\t\t in let <_10> =\n\t\t\t\t\t case %% Line 1508\n\t\t\t\t\t apply 'get_opt'/3\n\t\t\t\t\t\t ('mod', Opts, []) of\n\t\t\t\t\t %% Line 1509\n\t\t\t\t\t \n\t\t\t\t\t\twhen call 'erlang':'is_atom'\n\t\t\t\t\t\t (M) ->\n\t\t\t\t\t\tMA\n\t\t\t\t\t %% Line 1510\n\t\t\t\t\t <[]> when 'true' ->\n\t\t\t\t\t\t[]\n\t\t\t\t\t %% Line 1511\n\t\t\t\t\t when 'true' ->\n\t\t\t\t\t\tcall 'erlang':'throw'\n\t\t\t\t\t\t ({'error',{'badstartspec',Other}})\n\t\t\t\t\t end\n\t\t\t\t in let =\n\t\t\t\t\t apply %% Line 1513\n\t\t\t\t\t\t 'get_opt'/3\n\t\t\t\t\t\t (%% Line 1513\n\t\t\t\t\t\t 'start_phases', %% Line 1513\n\t\t\t\t\t\t\t\t Opts, %% Line 1513\n\t\t\t\t\t\t\t\t\t 'undefined')\n\t\t\t\t\t in let =\n\t\t\t\t\t\t apply %% Line 1514\n\t\t\t\t\t\t\t'get_opt'/3\n\t\t\t\t\t\t (%% Line 1514\n\t\t\t\t\t\t 'env', %% Line 1514\n\t\t\t\t\t\t\t Opts, %% Line 1514\n\t\t\t\t\t\t\t\t [])\n\t\t\t\t\t in let =\n\t\t\t\t\t\t apply %% Line 1515\n\t\t\t\t\t\t\t 'get_opt'/3\n\t\t\t\t\t\t\t (%% Line 1515\n\t\t\t\t\t\t\t 'maxP', %% Line 1515\n\t\t\t\t\t\t\t\t Opts, %% Line 1515\n\t\t\t\t\t\t\t\t\t 'infinity')\n\t\t\t\t\t\t in let =\n\t\t\t\t\t\t\t apply %% Line 1516\n\t\t\t\t\t\t\t\t'get_opt'/3\n\t\t\t\t\t\t\t (%% Line 1516\n\t\t\t\t\t\t\t 'maxT', %% Line 1516\n\t\t\t\t\t\t\t\t Opts, %% Line 1516\n\t\t\t\t\t\t\t\t\t 'infinity')\n\t\t\t\t\t\t in let =\n\t\t\t\t\t\t\t apply %% Line 1517\n\t\t\t\t\t\t\t\t 'get_opt'/3\n\t\t\t\t\t\t\t\t (%% Line 1517\n\t\t\t\t\t\t\t\t 'included_applications', %% Line 1517\n\t\t\t\t\t\t\t\t\t\t\t Opts, %% Line 1517\n\t\t\t\t\t\t\t\t\t\t\t\t [])\n\t\t\t\t\t\t\t in %% Line 1518\n\t\t\t\t\t\t\t {{'appl_data',Name,Regs,Phases,_10,%% Line 1519\n\t\t\t\t\t\t\t\t\t\t\t\t Mods,%% Line 1519\n\t\t\t\t\t\t\t\t\t\t\t\t IncApps,%% Line 1519\n\t\t\t\t\t\t\t\t\t\t\t\t\t MaxP,%% Line 1519\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t MaxT},%% Line 1520\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t Env,%% Line 1520\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t IncApps,%% Line 1520\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t Descr,%% Line 1520\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t Id,%% Line 1520\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t Vsn,%% Line 1520\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t Apps}\n\t %% Line 1521\n\t <{'application',Name,Opts}>\n\t when call 'erlang':'is_list'\n\t\t (Opts) ->\n\t %% Line 1522\n\t call 'erlang':'throw'\n\t\t ({'error',{'invalid_name',Name}})\n\t %% Line 1523\n\t <{'application',_X_Name,Opts}> when 'true' ->\n\t %% Line 1524\n\t call 'erlang':'throw'\n\t\t ({'error',{'invalid_options',Opts}})\n\t %% Line 1525\n\t when 'true' ->\n\t call 'erlang':'throw'\n\t\t ({'error',{'bad_application',Appl}})\n\tend\n'do_change_apps'/3 =\n %% Line 1536\n fun (_2,_1,_0) ->\n\t%% Line 1543\n\tcase apply 'check_conf_sys'/1\n\t\t (_1) of\n\t <{'ok',SysConfig,Errors}> when 'true' ->\n\t let <_7> =\n\t\t fun (_5) ->\n\t\t %% Line 1547\n\t\t case _5 of\n\t\t\t<{'error',{SysFName,Line,Str}}> when 'true' ->\n\t\t\t %% Line 1548\n\t\t\t case call 'logger':'allow'\n\t\t\t\t ('error', 'application_controller') of\n\t\t\t <'true'> when 'true' ->\n\t\t\t\t call 'logger':'macro_log'\n\t\t\t\t (~{'file'=>[97|[112|[112|[108|[105|[99|[97|[116|[105|[111|[110|[95|[99|[111|[110|[116|[114|[111|[108|[108|[101|[114|[46|[101|[114|[108]]]]]]]]]]]]]]]]]]]]]]]]]],'line'=>1548,'mfa'=>{'application_controller','do_change_apps',3}}~, 'error', [126|[116|[112|[58|[32|[126|[119|[58|[32|[126|[116|[115|[126|[110]]]]]]]]]]]]]], [SysFName|[Line|[Str|[]]]], ~{'error_logger'=>~{'tag'=>'error'}~}~)\n\t\t\t %% Line 1549\n\t\t\t <'false'> when 'true' ->\n\t\t\t\t 'ok'\n\t\t\t ( <_4> when 'true' ->\n\t\t\t\t primop 'match_fail'\n\t\t\t\t\t({'case_clause',_4})\n\t\t\t\t-| ['compiler_generated'] )\n\t\t\t end\n\t\t\t( <_6> when 'true' ->\n\t\t\t ( primop 'match_fail'\n\t\t\t\t ({'function_clause',_6})\n\t\t\t\t-| [{'function_name',{'-do_change_apps/3-fun-0-',1}}] )\n\t\t\t -| ['compiler_generated'] )\n\t\t end\n\t in do %% Line 1547\n\t\t call 'lists':'foreach'\n\t\t\t (_7, %% Line 1551\n\t\t\t Errors)\n\t\t let <_15> =\n\t\t\t fun (_13) ->\n\t\t\t %% Line 1554\n\t\t\t ( case _13 of\n\t\t\t\t ( <( {'appl',_rec144,_20,_21,_22,_23,_24,_25,_26}\n\t\t\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\t\t\t%% Line 1555\n\t\t\t\t\tcase apply 'is_loaded_app'/2\n\t\t\t\t\t\t (_rec144, _2) of\n\t\t\t\t\t %% Line 1556\n\t\t\t\t\t <{'true',Application}> when 'true' ->\n\t\t\t\t\t let <_11> =\n\t\t\t\t\t\t apply %% Line 1557\n\t\t\t\t\t\t\t'make_appl'/1\n\t\t\t\t\t\t (%% Line 1557\n\t\t\t\t\t\t Application)\n\t\t\t\t\t in %% Line 1557\n\t\t\t\t\t\t apply 'do_change_appl'/3\n\t\t\t\t\t\t (_11, _13, %% Line 1558\n\t\t\t\t\t\t\t\t SysConfig)\n\t\t\t\t\t %% Line 1561\n\t\t\t\t\t <'false'> when 'true' ->\n\t\t\t\t\t _13\n\t\t\t\t\t ( <_12> when 'true' ->\n\t\t\t\t\t\tprimop 'match_fail'\n\t\t\t\t\t\t ({'case_clause',_12})\n\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\tend\n\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t ( <_27> when 'true' ->\n\t\t\t\t\t( call ( 'erlang'\n\t\t\t\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t (( {'badrecord','appl'}\n\t\t\t\t\t\t -| ['compiler_generated'] ))\n\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\tend\n\t\t\t\t-| ['compiler_generated'] )\n\t\t in let <_16> =\n\t\t\t call %% Line 1553\n\t\t\t\t 'lists':%% Line 1553\n\t\t\t\t\t 'map'\n\t\t\t\t (_15, _0)\n\t\t\t in %% Line 1553\n\t\t\t {_16,%% Line 1565\n\t\t\t\t SysConfig}\n\t ( <_3> when 'true' ->\n\t\tprimop 'match_fail'\n\t\t ({'badmatch',_3})\n\t -| ['compiler_generated'] )\n\tend\n'is_loaded_app'/2 =\n %% Line 1567\n fun (_1,_0) ->\n\tcase <_1,_0> of\n\t \n\t when call 'erlang':'=:='\n\t\t (_4,\n\t\t AppName) ->\n\t %% Line 1568\n\t {'true',{'application',AppName,App}}\n\t %% Line 1569\n\t when 'true' ->\n\t apply 'is_loaded_app'/2\n\t\t (AppName, T)\n\t %% Line 1570\n\t <_X_AppName,[]> when 'true' ->\n\t 'false'\n\t ( <_3,_2> when 'true' ->\n\t\t( primop 'match_fail'\n\t\t ({'function_clause',_3,_2})\n\t\t -| [{'function_name',{'is_loaded_app',2}}] )\n\t -| ['compiler_generated'] )\n\tend\n'do_change_appl'/3 =\n %% Line 1572\n fun (_2,_1,_0) ->\n\tcase <_2,_1,_0> of\n\t <{'ok',{ApplData,Env,IncApps,Descr,Id,Vsn,Apps}},%% Line 1573\n\t\t\t\t\t\t\t OldAppl,%% Line 1573\n\t\t\t\t\t\t\t\t Config> when 'true' ->\n\t %% Line 1574\n\t ( case OldAppl of\n\t\t ( <( {'appl',_rec145,_15,_16,_17,_18,_19,_20,_21}\n\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\tlet =\n\t\t\t apply %% Line 1577\n\t\t\t\t 'get_opt'/3\n\t\t\t\t(_rec145, %% Line 1577\n\t\t\t\t\t Config, %% Line 1577\n\t\t\t\t\t\t [])\n\t\t\tin let =\n\t\t\t\tapply %% Line 1578\n\t\t\t\t 'merge_app_env'/2\n\t\t\t\t (%% Line 1578\n\t\t\t\t Env, %% Line 1578\n\t\t\t\t\t ConfEnv)\n\t\t\t in let =\n\t\t\t\t apply %% Line 1581\n\t\t\t\t\t 'get_cmd_env'/1\n\t\t\t\t\t(_rec145)\n\t\t\t\tin let =\n\t\t\t\t\tapply %% Line 1582\n\t\t\t\t\t 'merge_app_env'/2\n\t\t\t\t\t (%% Line 1582\n\t\t\t\t\t NewEnv1, %% Line 1582\n\t\t\t\t\t\t CmdLineEnv)\n\t\t\t\t in do %% Line 1585\n\t\t\t\t\t apply 'del_env'/1\n\t\t\t\t\t\t(_rec145)\n\t\t\t\t\t do %% Line 1586\n\t\t\t\t\t\tapply 'add_env'/2\n\t\t\t\t\t\t (_rec145, NewEnv2)\n\t\t\t\t\t\t%% Line 1593\n\t\t\t\t\t\t{'appl',_rec145,ApplData,Descr,Id,Vsn,_19,IncApps,Apps}\n\t\t -| ['compiler_generated'] )\n\t\t ( <_22> when 'true' ->\n\t\t\t( call ( 'erlang'\n\t\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t (( {'badrecord','appl'}\n\t\t\t\t -| ['compiler_generated'] ))\n\t\t\t -| ['compiler_generated'] )\n\t\t -| ['compiler_generated'] )\n\t\tend\n\t\t-| ['compiler_generated'] )\n\t %% Line 1594\n\t when 'true' ->\n\t %% Line 1595\n\t call 'erlang':'throw'\n\t\t (Error)\n\t ( <_14,_13,_12> when 'true' ->\n\t\t( primop 'match_fail'\n\t\t ({'function_clause',_14,_13,_12})\n\t\t -| [{'function_name',{'do_change_appl',3}}] )\n\t -| ['compiler_generated'] )\n\tend\n'get_opt'/3 =\n %% Line 1597\n fun (_2,_1,_0) ->\n\t%% Line 1598\n\tcase call 'lists':'keyfind'\n\t\t (_2, 1, _1) of\n\t %% Line 1599\n\t <{_X_Key,Val}> when 'true' ->\n\t Val\n\t %% Line 1600\n\t <_7> when 'true' ->\n\t _0\n\tend\n'get_cmd_env'/1 =\n %% Line 1603\n fun (_0) ->\n\t%% Line 1604\n\tcase call 'init':'get_argument'\n\t\t (_0) of\n\t %% Line 1605\n\t <{'ok',Args}> when 'true' ->\n\t let <_6> =\n\t\t fun (_3,_2) ->\n\t\t let <_1> =\n\t\t\t apply %% Line 1606\n\t\t\t\t'conv'/1\n\t\t\t (_3)\n\t\t in %% Line 1606\n\t\t\t call 'erlang':'++'\n\t\t\t (_1, _2)\n\t in %% Line 1606\n\t\t call 'lists':'foldl'\n\t\t (_6, [], Args)\n\t %% Line 1607\n\t <_9> when 'true' ->\n\t []\n\tend\n'conv'/1 =\n %% Line 1610\n fun (_0) ->\n\tcase _0 of\n\t <[Key|[Val|T]]> when 'true' ->\n\t let <_2> =\n\t\t apply %% Line 1611\n\t\t\t'make_term'/1\n\t\t (%% Line 1611\n\t\t Key)\n\t in let <_1> =\n\t\t apply %% Line 1611\n\t\t\t 'make_term'/1\n\t\t\t (%% Line 1611\n\t\t\t Val)\n\t\t in let <_3> =\n\t\t\t apply %% Line 1611\n\t\t\t\t'conv'/1\n\t\t\t (%% Line 1611\n\t\t\t T)\n\t\t in %% Line 1611\n\t\t\t [{_2,_1}|_3]\n\t %% Line 1612\n\t <_5> when 'true' ->\n\t []\n\tend\n'make_term'/1 =\n %% Line 1614\n fun (_0) ->\n\t%% Line 1615\n\tcase call 'erl_scan':'string'\n\t\t (_0) of\n\t %% Line 1616\n\t <{'ok',Tokens,_6}> when 'true' ->\n\t let <_1> =\n\t\t call %% Line 1617\n\t\t 'erl_anno':%% Line 1617\n\t\t\t\t 'new'\n\t\t (%% Line 1617\n\t\t 1)\n\t in let <_2> =\n\t\t call %% Line 1617\n\t\t\t 'erlang':%% Line 1617\n\t\t\t\t '++'\n\t\t\t (%% Line 1617\n\t\t\t Tokens, %% Line 1617\n\t\t\t\t [{'dot',_1}|[]])\n\t\t in %% Line 1617\n\t\t case call 'erl_parse':'parse_term'\n\t\t\t (_2) of\n\t\t\t%% Line 1618\n\t\t\t<{'ok',Term}> when 'true' ->\n\t\t\t %% Line 1619\n\t\t\t Term\n\t\t\t%% Line 1620\n\t\t\t<{'error',{_7,M,Reason}}> when 'true' ->\n\t\t\t %% Line 1621\n\t\t\t apply 'handle_make_term_error'/3\n\t\t\t\t(M, Reason, _0)\n\t\t\t( <_3> when 'true' ->\n\t\t\t primop 'match_fail'\n\t\t\t\t ({'case_clause',_3})\n\t\t\t -| ['compiler_generated'] )\n\t\t end\n\t %% Line 1623\n\t <{'error',{_8,M,Reason},_9}> when 'true' ->\n\t %% Line 1624\n\t apply 'handle_make_term_error'/3\n\t\t (M, Reason, _0)\n\t ( <_4> when 'true' ->\n\t\tprimop 'match_fail'\n\t\t ({'case_clause',_4})\n\t -| ['compiler_generated'] )\n\tend\n'handle_make_term_error'/3 =\n %% Line 1627\n fun (_2,_1,_0) ->\n\tdo %% Line 1628\n\t case call 'logger':'allow'\n\t\t ('error', 'application_controller') of\n\t <'true'> when 'true' ->\n\t\t let <_3> =\n\t\t call _2:%% Line 1629\n\t\t\t 'format_error'\n\t\t\t (_1)\n\t\t in call 'logger':'macro_log'\n\t\t\t (~{'file'=>[97|[112|[112|[108|[105|[99|[97|[116|[105|[111|[110|[95|[99|[111|[110|[116|[114|[111|[108|[108|[101|[114|[46|[101|[114|[108]]]]]]]]]]]]]]]]]]]]]]]]]],'line'=>1628,'mfa'=>{'application_controller','handle_make_term_error',3}}~, 'error', [97|[112|[112|[108|[105|[99|[97|[116|[105|[111|[110|[95|[99|[111|[110|[116|[114|[111|[108|[108|[101|[114|[58|[32|[126|[116|[115|[58|[32|[126|[116|[115|[126|[110]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]], %% Line 1629\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t [_3|[_0|[]]], ~{'error_logger'=>~{'tag'=>'error'}~}~)\n\t %% Line 1630\n\t <'false'> when 'true' ->\n\t\t 'ok'\n\t ( <_4> when 'true' ->\n\t\t primop 'match_fail'\n\t\t\t({'case_clause',_4})\n\t\t-| ['compiler_generated'] )\n\t end\n\t %% Line 1631\n\t call 'erlang':'throw'\n\t\t({'error',{'bad_environment_value',_0}})\n'get_env_i'/2 =\n %% Line 1633\n fun (_1,_0) ->\n\tcase <_1,_0> of\n\t \n\t when call 'erlang':'is_list'\n\t\t (ConfData) ->\n\t %% Line 1634\n\t case call 'lists':'keyfind'\n\t\t (Name, 1, ConfData) of\n\t\t%% Line 1635\n\t\t<{_X_Name,Env}> when 'true' ->\n\t\t Env\n\t\t%% Line 1636\n\t\t<_12> when 'true' ->\n\t\t []\n\t end\n\t %% Line 1638\n\t <_X_Name,_13> when 'true' ->\n\t []\n\tend\n'merge_env'/2 =\n %% Line 1641\n fun (_1,_0) ->\n\t%% Line 1642\n\tapply 'merge_env'/3\n\t (_1, _0, [])\n'merge_env'/3 =\n %% Line 1644\n fun (_2,_1,_0) ->\n\tcase <_2,_1,_0> of\n\t <[_@r0 = {App,AppEnv1}|T],Env2,Res> when 'true' ->\n\t %% Line 1645\n\t case apply 'get_env_key'/2\n\t\t (App, Env2) of\n\t\t%% Line 1646\n\t\t<{'value',AppEnv2,RestEnv2}> when 'true' ->\n\t\t let =\n\t\t\tapply %% Line 1647\n\t\t\t 'merge_app_env'/2\n\t\t\t (%% Line 1647\n\t\t\t AppEnv1, %% Line 1647\n\t\t\t\t AppEnv2)\n\t\t in %% Line 1648\n\t\t\tapply 'merge_env'/3\n\t\t\t (T, RestEnv2, [{App,NewAppEnv}|Res])\n\t\t%% Line 1649\n\t\t<_8> when 'true' ->\n\t\t %% Line 1650\n\t\t apply 'merge_env'/3\n\t\t\t(T, Env2, [_@r0|Res])\n\t end\n\t %% Line 1652\n\t <[],Env2,Res> when 'true' ->\n\t %% Line 1653\n\t call 'erlang':'++'\n\t\t (Env2, Res)\n\t ( <_7,_6,_5> when 'true' ->\n\t\t( primop 'match_fail'\n\t\t ({'function_clause',_7,_6,_5})\n\t\t -| [{'function_name',{'merge_env',3}}] )\n\t -| ['compiler_generated'] )\n\tend\n'change_app_env'/3 =\n %% Line 1657\n fun (_2,_1,_0) ->\n\t%% Line 1658\n\tcase apply 'get_env_key'/2\n\t\t (_1, _2) of\n\t %% Line 1659\n\t <{'value',AppEnv,RestEnv}> when 'true' ->\n\t let <_3> =\n\t\t apply _0\n\t\t (%% Line 1660\n\t\t AppEnv)\n\t in %% Line 1660\n\t\t [{_1,_3}|RestEnv]\n\t %% Line 1661\n\t <_9> when 'true' ->\n\t let <_4> =\n\t\t apply _0\n\t\t (%% Line 1662\n\t\t [])\n\t in %% Line 1662\n\t\t [{_1,_4}|_2]\n\tend\n'merge_app_env'/2 =\n %% Line 1666\n fun (_1,_0) ->\n\t%% Line 1667\n\tapply 'merge_app_env'/3\n\t (_1, _0, [])\n'merge_app_env'/3 =\n %% Line 1669\n fun (_2,_1,_0) ->\n\tcase <_2,_1,_0> of\n\t <[_@r0 = {Key,Val}|T],Env2,Res> when 'true' ->\n\t %% Line 1670\n\t case apply 'get_env_key'/2\n\t\t (Key, Env2) of\n\t\t%% Line 1671\n\t\t<{'value',NewVal,RestEnv}> when 'true' ->\n\t\t %% Line 1672\n\t\t apply 'merge_app_env'/3\n\t\t\t(T, RestEnv, [{Key,NewVal}|Res])\n\t\t%% Line 1673\n\t\t<_7> when 'true' ->\n\t\t %% Line 1674\n\t\t apply 'merge_app_env'/3\n\t\t\t(T, Env2, [_@r0|Res])\n\t end\n\t %% Line 1676\n\t <[],Env2,Res> when 'true' ->\n\t %% Line 1677\n\t call 'erlang':'++'\n\t\t (Env2, Res)\n\t ( <_6,_5,_4> when 'true' ->\n\t\t( primop 'match_fail'\n\t\t ({'function_clause',_6,_5,_4})\n\t\t -| [{'function_name',{'merge_app_env',3}}] )\n\t -| ['compiler_generated'] )\n\tend\n'get_env_key'/2 =\n %% Line 1679\n fun (_1,_0) ->\n\tapply 'get_env_key'/3\n\t (_0, _1, [])\n'get_env_key'/3 =\n %% Line 1680\n fun (_2,_1,_0) ->\n\tcase <_2,_1,_0> of\n\t <[{Key,Val}|T],_7,Res>\n\t when call 'erlang':'=:='\n\t\t (_7,\n\t\t Key) ->\n\t let <_3> =\n\t\t call %% Line 1681\n\t\t 'erlang':%% Line 1681\n\t\t\t\t'++'\n\t\t (%% Line 1681\n\t\t T, %% Line 1681\n\t\t\t Res)\n\t in %% Line 1681\n\t\t {'value',Val,_3}\n\t %% Line 1682\n\t <[H|T],Key,Res> when 'true' ->\n\t %% Line 1683\n\t apply 'get_env_key'/3\n\t\t (T, Key, [H|Res])\n\t %% Line 1684\n\t <[],_X_Key,Res> when 'true' ->\n\t Res\n\t ( <_6,_5,_4> when 'true' ->\n\t\t( primop 'match_fail'\n\t\t ({'function_clause',_6,_5,_4})\n\t\t -| [{'function_name',{'get_env_key',3}}] )\n\t -| ['compiler_generated'] )\n\tend\n'add_env'/2 =\n %% Line 1686\n fun (_1,_0) ->\n\tlet <_4> =\n\t fun (_2) ->\n\t\t%% Line 1687\n\t\tcase _2 of\n\t\t <{Key,Value}> when 'true' ->\n\t\t %% Line 1688\n\t\t call 'ets':'insert'\n\t\t\t ('ac_tab', {{'env',_1,Key},Value})\n\t\t ( <_3> when 'true' ->\n\t\t\t( primop 'match_fail'\n\t\t\t ({'function_clause',_3})\n\t\t\t -| [{'function_name',{'-add_env/2-fun-0-',1}}] )\n\t\t -| ['compiler_generated'] )\n\t\tend\n\tin %% Line 1687\n\t call 'lists':'foreach'\n\t\t(_4, _0)\n'del_env'/1 =\n %% Line 1692\n fun (_0) ->\n\t%% Line 1693\n\tcall 'ets':'match_delete'\n\t ('ac_tab', {{'env',_0,'_'},'_'})\n'check_user'/0 =\n %% Line 1695\n fun () ->\n\t%% Line 1696\n\tcase call 'erlang':'whereis'\n\t\t ('user') of\n\t %% Line 1697\n\t \n\t when call 'erlang':'is_pid'\n\t\t (User) ->\n\t let <_0> =\n\t\t call 'erlang':'self'\n\t\t ()\n\t in call 'erlang':'group_leader'\n\t\t (User, _0)\n\t %% Line 1698\n\t <_2> when 'true' ->\n\t 'ok'\n\tend\n'do_prep_config_change'/1 =\n %% Line 1705\n fun (_0) ->\n\t%% Line 1706\n\tapply 'do_prep_config_change'/2\n\t (_0, [])\n'do_prep_config_change'/2 =\n %% Line 1708\n fun (_1,_0) ->\n\tcase <_1,_0> of\n\t <[],EnvBefore> when 'true' ->\n\t %% Line 1709\n\t EnvBefore\n\t %% Line 1710\n\t <[{App,_X_Id}|Apps],EnvBefore> when 'true' ->\n\t let =\n\t\t call %% Line 1711\n\t\t 'application':%% Line 1711\n\t\t\t\t 'get_all_env'\n\t\t (%% Line 1711\n\t\t App)\n\t in %% Line 1712\n\t\t apply 'do_prep_config_change'/2\n\t\t (Apps, [{App,Env}|EnvBefore])\n\t ( <_4,_3> when 'true' ->\n\t\t( primop 'match_fail'\n\t\t ({'function_clause',_4,_3})\n\t\t -| [{'function_name',{'do_prep_config_change',2}}] )\n\t -| ['compiler_generated'] )\n\tend\n'do_config_change'/2 =\n %% Line 1719\n fun (_1,_0) ->\n\t%% Line 1720\n\tapply 'do_config_change'/3\n\t (_1, _0, [])\n'do_config_change'/3 =\n %% Line 1722\n fun (_2,_1,_0) ->\n\tcase <_2,_1,_0> of\n\t <[],_X_EnvBefore,[]> when 'true' ->\n\t %% Line 1723\n\t 'ok'\n\t %% Line 1724\n\t <[],_X_EnvBefore,Errors> when 'true' ->\n\t %% Line 1725\n\t {'error',Errors}\n\t %% Line 1726\n\t <[{App,_X_Id}|Apps],EnvBefore,Errors> when 'true' ->\n\t let <_3> =\n\t\t call %% Line 1727\n\t\t 'application':%% Line 1727\n\t\t\t\t 'get_all_env'\n\t\t (%% Line 1727\n\t\t App)\n\t in let =\n\t\t call %% Line 1727\n\t\t\t 'lists':%% Line 1727\n\t\t\t\t 'sort'\n\t\t\t (_3)\n\t\t in let <_6> =\n\t\t\t case %% Line 1728\n\t\t\t call 'lists':'keyfind'\n\t\t\t\t (App, 1, EnvBefore) of\n\t\t\t %% Line 1729\n\t\t\t <'false'> when 'true' ->\n\t\t\t\t%% Line 1730\n\t\t\t\t[]\n\t\t\t %% Line 1731\n\t\t\t <{_19,AppEnvBeforeT}>\n\t\t\t\twhen call 'erlang':'=:='\n\t\t\t\t (_19,\n\t\t\t\t App) ->\n\t\t\t\t%% Line 1732\n\t\t\t\tcall 'lists':'sort'\n\t\t\t\t (AppEnvBeforeT)\n\t\t\t ( <_5> when 'true' ->\n\t\t\t\t %% Line 1728\n\t\t\t\t primop 'match_fail'\n\t\t\t\t ({'case_clause',_5})\n\t\t\t -| ['compiler_generated'] )\n\t\t\t end\n\t\t in let <_13> =\n\t\t\t case %% Line 1735\n\t\t\t\t AppEnvNow of\n\t\t\t\t%% Line 1736\n\t\t\t\t<_20>\n\t\t\t\t when call 'erlang':'=:='\n\t\t\t\t\t (AppEnvNow,\n\t\t\t\t\t _6) ->\n\t\t\t\t %% Line 1737\n\t\t\t\t 'ok'\n\t\t\t\t%% Line 1738\n\t\t\t\t<_21> when 'true' ->\n\t\t\t\t %% Line 1739\n\t\t\t\t case apply 'do_config_diff'/2\n\t\t\t\t\t (AppEnvNow, _6) of\n\t\t\t\t %% Line 1740\n\t\t\t\t <{[],[],[]}> when 'true' ->\n\t\t\t\t\t %% Line 1741\n\t\t\t\t\t 'ok'\n\t\t\t\t %% Line 1742\n\t\t\t\t <{Changed,New,Removed}> when 'true' ->\n\t\t\t\t\t %% Line 1743\n\t\t\t\t\t case call 'application':'get_key'\n\t\t\t\t\t\t (App, 'mod') of\n\t\t\t\t\t %% Line 1744\n\t\t\t\t\t <{'ok',{Mod,_X_Para}}> when 'true' ->\n\t\t\t\t\t\tlet <_8> =\n\t\t\t\t\t\t catch\n\t\t\t\t\t\t\t%% Line 1745\n\t\t\t\t\t\t\tcall Mod:'config_change'\n\t\t\t\t\t\t\t (Changed, New, %% Line 1746\n\t\t\t\t\t\t\t\t\t Removed)\n\t\t\t\t\t\tin %% Line 1745\n\t\t\t\t\t\t case _8 of\n\t\t\t\t\t\t %% Line 1747\n\t\t\t\t\t\t <'ok'> when 'true' ->\n\t\t\t\t\t\t\t %% Line 1748\n\t\t\t\t\t\t\t 'ok'\n\t\t\t\t\t\t %% Line 1751\n\t\t\t\t\t\t <{'EXIT',{'undef',_22}}> when 'true' ->\n\t\t\t\t\t\t\t %% Line 1752\n\t\t\t\t\t\t\t 'ok'\n\t\t\t\t\t\t %% Line 1753\n\t\t\t\t\t\t when 'true' ->\n\t\t\t\t\t\t\t %% Line 1754\n\t\t\t\t\t\t\t Error\n\t\t\t\t\t\t %% Line 1755\n\t\t\t\t\t\t when 'true' ->\n\t\t\t\t\t\t\t %% Line 1756\n\t\t\t\t\t\t\t {'error',Else}\n\t\t\t\t\t\t end\n\t\t\t\t\t %% Line 1758\n\t\t\t\t\t <{'ok',[]}> when 'true' ->\n\t\t\t\t\t\t%% Line 1759\n\t\t\t\t\t\t{'error',{'module_not_defined',App}}\n\t\t\t\t\t %% Line 1760\n\t\t\t\t\t <'undefined'> when 'true' ->\n\t\t\t\t\t\t%% Line 1761\n\t\t\t\t\t\t{'error',{'application_not_found',App}}\n\t\t\t\t\t ( <_10> when 'true' ->\n\t\t\t\t\t\t primop 'match_fail'\n\t\t\t\t\t\t ({'case_clause',_10})\n\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t end\n\t\t\t\t ( <_11> when 'true' ->\n\t\t\t\t\t primop 'match_fail'\n\t\t\t\t\t\t({'case_clause',_11})\n\t\t\t\t\t-| ['compiler_generated'] )\n\t\t\t\t end\n\t\t\t end\n\t\t\t in %% Line 1766\n\t\t\t case _13 of\n\t\t\t\t%% Line 1767\n\t\t\t\t<'ok'> when 'true' ->\n\t\t\t\t %% Line 1768\n\t\t\t\t apply 'do_config_change'/3\n\t\t\t\t\t(Apps, EnvBefore, Errors)\n\t\t\t\t%% Line 1769\n\t\t\t\t<{'error',NewError}> when 'true' ->\n\t\t\t\t %% Line 1770\n\t\t\t\t apply 'do_config_change'/3\n\t\t\t\t\t(Apps, EnvBefore, [NewError|Errors])\n\t\t\t\t( <_15> when 'true' ->\n\t\t\t\t primop 'match_fail'\n\t\t\t\t\t ({'case_clause',_15})\n\t\t\t\t -| ['compiler_generated'] )\n\t\t\t end\n\t ( <_18,_17,_16> when 'true' ->\n\t\t( primop 'match_fail'\n\t\t ({'function_clause',_18,_17,_16})\n\t\t -| [{'function_name',{'do_config_change',3}}] )\n\t -| ['compiler_generated'] )\n\tend\n'do_config_diff'/2 =\n %% Line 1777\n fun (_1,_0) ->\n\t%% Line 1778\n\tapply 'do_config_diff'/3\n\t (_1, _0, {[],[]})\n'do_config_diff'/3 =\n %% Line 1780\n fun (_2,_1,_0) ->\n\tcase <_2,_1,_0> of\n\t <[],AppEnvBefore,{Changed,New}> when 'true' ->\n\t let <_7> =\n\t\t fun (_4,_3) ->\n\t\t %% Line 1781\n\t\t case <_4,_3> of\n\t\t\t<{Env,_X_Value},Acc> when 'true' ->\n\t\t\t [Env|Acc]\n\t\t\t( <_6,_5> when 'true' ->\n\t\t\t ( primop 'match_fail'\n\t\t\t\t ({'function_clause',_6,_5})\n\t\t\t\t-| [{'function_name',{'-do_config_diff/3-fun-0-',2}}] )\n\t\t\t -| ['compiler_generated'] )\n\t\t end\n\t in let =\n\t\t call %% Line 1781\n\t\t\t 'lists':%% Line 1781\n\t\t\t\t 'foldl'\n\t\t\t (_7, %% Line 1781\n\t\t\t [], %% Line 1781\n\t\t\t\t AppEnvBefore)\n\t\t in %% Line 1782\n\t\t {Changed,New,Removed}\n\t %% Line 1783\n\t when 'true' ->\n\t let <_9> =\n\t\t call %% Line 1784\n\t\t 'erlang':%% Line 1784\n\t\t\t\t'++'\n\t\t (%% Line 1784\n\t\t AppEnvNow, %% Line 1784\n\t\t\t\t New)\n\t in %% Line 1784\n\t\t {Changed,_9,[]}\n\t %% Line 1785\n\t <[_@r1 = {Env,Value}|AppEnvNow],AppEnvBefore,_@r0 = {Changed,New}> when 'true' ->\n\t %% Line 1786\n\t case call 'lists':'keyfind'\n\t\t (Env, 1, AppEnvBefore) of\n\t\t%% Line 1787\n\t\t<{_16,_17}>\n\t\t when let <_18> =\n\t\t\t call 'erlang':'=:='\n\t\t\t (_16, Env)\n\t\t in let <_19> =\n\t\t\t call 'erlang':'=:='\n\t\t\t\t (_17, Value)\n\t\t\t in call 'erlang':'and'\n\t\t\t\t (_18, _19) ->\n\t\t let <_10> =\n\t\t\tcall %% Line 1788\n\t\t\t 'lists':%% Line 1788\n\t\t\t\t 'keydelete'\n\t\t\t (%% Line 1788\n\t\t\t Env, %% Line 1788\n\t\t\t\t 1, %% Line 1788\n\t\t\t\t AppEnvBefore)\n\t\t in %% Line 1788\n\t\t\tapply 'do_config_diff'/3\n\t\t\t (AppEnvNow, _10, _@r0)\n\t\t%% Line 1789\n\t\t<{_20,_X_OtherValue}>\n\t\t when call 'erlang':'=:='\n\t\t\t (_20,\n\t\t\t Env) ->\n\t\t let <_11> =\n\t\t\tcall %% Line 1790\n\t\t\t 'lists':%% Line 1790\n\t\t\t\t 'keydelete'\n\t\t\t (%% Line 1790\n\t\t\t Env, %% Line 1790\n\t\t\t\t 1, %% Line 1790\n\t\t\t\t AppEnvBefore)\n\t\t in %% Line 1790\n\t\t\tapply 'do_config_diff'/3\n\t\t\t (AppEnvNow, _11, %% Line 1791\n\t\t\t\t\t {[_@r1|Changed],New})\n\t\t%% Line 1792\n\t\t<'false'> when 'true' ->\n\t\t %% Line 1793\n\t\t apply 'do_config_diff'/3\n\t\t\t(AppEnvNow, AppEnvBefore, {Changed,[_@r1|New]})\n\t\t( <_12> when 'true' ->\n\t\t primop 'match_fail'\n\t\t\t ({'case_clause',_12})\n\t\t -| ['compiler_generated'] )\n\t end\n\t ( <_15,_14,_13> when 'true' ->\n\t\t( primop 'match_fail'\n\t\t ({'function_clause',_15,_14,_13})\n\t\t -| [{'function_name',{'do_config_diff',3}}] )\n\t -| ['compiler_generated'] )\n\tend\n'check_conf'/0 =\n %% Line 1800\n fun () ->\n\t%% Line 1801\n\tcase call 'init':'get_argument'\n\t\t ('config') of\n\t %% Line 1802\n\t <{'ok',Files}> when 'true' ->\n\t let <_12> =\n\t\t fun (_9,_8) ->\n\t\t %% Line 1804\n\t\t case <_9,_8> of\n\t\t\t<[File|[]],Env> when 'true' ->\n\t\t\t let =\n\t\t\t\tcall %% Line 1805\n\t\t\t\t 'filename':%% Line 1805\n\t\t\t\t\t\t'basename'\n\t\t\t\t (%% Line 1805\n\t\t\t\t File, %% Line 1805\n\t\t\t\t\t [46|[99|[111|[110|[102|[105|[103]]]]]]])\n\t\t\t in let <_2> =\n\t\t\t\t call %% Line 1806\n\t\t\t\t\t 'filename':%% Line 1806\n\t\t\t\t\t\t 'dirname'\n\t\t\t\t\t(%% Line 1806\n\t\t\t\t\t File)\n\t\t\t\tin let <_1> =\n\t\t\t\t\tcall %% Line 1807\n\t\t\t\t\t 'erlang':%% Line 1807\n\t\t\t\t\t\t '++'\n\t\t\t\t\t (%% Line 1807\n\t\t\t\t\t BFName, %% Line 1807\n\t\t\t\t\t\t [46|[99|[111|[110|[102|[105|[103]]]]]]])\n\t\t\t\t in let =\n\t\t\t\t\t call %% Line 1806\n\t\t\t\t\t\t 'filename':%% Line 1806\n\t\t\t\t\t\t\t 'join'\n\t\t\t\t\t\t(_2, _1)\n\t\t\t\t\tin %% Line 1808\n\t\t\t\t\t case apply 'load_file'/1\n\t\t\t\t\t\t (FName) of\n\t\t\t\t\t %% Line 1809\n\t\t\t\t\t <{'ok',NewEnv}> when 'true' ->\n\t\t\t\t\t\t %% Line 1815\n\t\t\t\t\t\t case <> of\n\t\t\t\t\t\t %% Line 1816\n\t\t\t\t\t\t <>\n\t\t\t\t\t\t\twhen call 'erlang':'=:='\n\t\t\t\t\t\t\t (BFName,\n\t\t\t\t\t\t\t [115|[121|[115]]]) ->\n\t\t\t\t\t\t\tlet =\n\t\t\t\t\t\t\t call %% Line 1817\n\t\t\t\t\t\t\t\t 'filename':%% Line 1817\n\t\t\t\t\t\t\t\t\t 'dirname'\n\t\t\t\t\t\t\t\t(%% Line 1817\n\t\t\t\t\t\t\t\t FName)\n\t\t\t\t\t\t\tin %% Line 1818\n\t\t\t\t\t\t\t case %% Line 1819\n\t\t\t\t\t\t\t\t apply 'check_conf_sys'/4\n\t\t\t\t\t\t\t\t (NewEnv, [], [], DName) of\n\t\t\t\t\t\t\t <{'ok',SysEnv,Errors}> when 'true' ->\n\t\t\t\t\t\t\t\t %% Line 1824\n\t\t\t\t\t\t\t\t case Errors of\n\t\t\t\t\t\t\t\t %% Line 1825\n\t\t\t\t\t\t\t\t <[]> when 'true' ->\n\t\t\t\t\t\t\t\t\t%% Line 1826\n\t\t\t\t\t\t\t\t\tapply 'merge_env'/2\n\t\t\t\t\t\t\t\t\t (Env, SysEnv)\n\t\t\t\t\t\t\t\t %% Line 1827\n\t\t\t\t\t\t\t\t <[_@r0 = {'error',{SysFName,Line,Str}}|_15]> when 'true' ->\n\t\t\t\t\t\t\t\t\t%% Line 1828\n\t\t\t\t\t\t\t\t\tcall 'erlang':'throw'\n\t\t\t\t\t\t\t\t\t (_@r0)\n\t\t\t\t\t\t\t\t ( <_6> when 'true' ->\n\t\t\t\t\t\t\t\t\t primop 'match_fail'\n\t\t\t\t\t\t\t\t\t ({'case_clause',_6})\n\t\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t\t\t\t end\n\t\t\t\t\t\t\t ( <_5> when 'true' ->\n\t\t\t\t\t\t\t\t primop 'match_fail'\n\t\t\t\t\t\t\t\t\t({'badmatch',_5})\n\t\t\t\t\t\t\t\t-| ['compiler_generated'] )\n\t\t\t\t\t\t\t end\n\t\t\t\t\t\t %% Line 1830\n\t\t\t\t\t\t <> when 'true' ->\n\t\t\t\t\t\t\t%% Line 1831\n\t\t\t\t\t\t\tapply 'merge_env'/2\n\t\t\t\t\t\t\t (Env, NewEnv)\n\t\t\t\t\t\t end\n\t\t\t\t\t %% Line 1833\n\t\t\t\t\t <{'error',{Line,_X_Mod,Str}}> when 'true' ->\n\t\t\t\t\t\t %% Line 1834\n\t\t\t\t\t\t call 'erlang':'throw'\n\t\t\t\t\t\t ({'error',{FName,Line,Str}})\n\t\t\t\t\t ( <_7> when 'true' ->\n\t\t\t\t\t\t primop 'match_fail'\n\t\t\t\t\t\t\t({'case_clause',_7})\n\t\t\t\t\t\t-| ['compiler_generated'] )\n\t\t\t\t\t end\n\t\t\t( <_11,_10> when 'true' ->\n\t\t\t ( primop 'match_fail'\n\t\t\t\t ({'function_clause',_11,_10})\n\t\t\t\t-| [{'function_name',{'-check_conf/0-fun-0-',2}}] )\n\t\t\t -| ['compiler_generated'] )\n\t\t end\n\t in let <_13> =\n\t\t call %% Line 1803\n\t\t\t 'lists':%% Line 1803\n\t\t\t\t 'foldl'\n\t\t\t (_12, %% Line 1836\n\t\t\t\t[], %% Line 1836\n\t\t\t\t Files)\n\t\t in %% Line 1803\n\t\t {'ok',_13}\n\t %% Line 1837\n\t <_16> when 'true' ->\n\t {'ok',[]}\n\tend\n'check_conf_sys'/1 =\n %% Line 1840\n fun (_0) ->\n\t%% Line 1841\n\tapply 'check_conf_sys'/4\n\t (_0, [], [], [])\n'check_conf_sys'/4 =\n %% Line 1843\n fun (_3,_2,_1,_0) ->\n\tcase <_3,_2,_1,_0> of\n\t <[File|T],SysEnv,Errors,DName>\n\t when let <_4> =\n\t\t call 'erlang':'is_list'\n\t\t\t(File)\n\t\tin let <_5> =\n\t\t\tcall 'erlang':'is_list'\n\t\t\t (DName)\n\t\t in call 'erlang':'and'\n\t\t\t (_4, _5) ->\n\t let =\n\t\t call %% Line 1844\n\t\t 'filename':%% Line 1844\n\t\t\t\t 'basename'\n\t\t (%% Line 1844\n\t\t File, %% Line 1844\n\t\t\t [46|[99|[111|[110|[102|[105|[103]]]]]]])\n\t in let <_8> =\n\t\t call %% Line 1845\n\t\t\t 'filename':%% Line 1845\n\t\t\t\t 'dirname'\n\t\t\t (%% Line 1845\n\t\t\t File)\n\t\t in let <_7> =\n\t\t\t call %% Line 1845\n\t\t\t 'erlang':%% Line 1845\n\t\t\t\t\t'++'\n\t\t\t (%% Line 1845\n\t\t\t BFName, %% Line 1845\n\t\t\t\t [46|[99|[111|[110|[102|[105|[103]]]]]]])\n\t\t in let =\n\t\t\t call %% Line 1845\n\t\t\t\t 'filename':%% Line 1845\n\t\t\t\t\t 'join'\n\t\t\t\t (_8, _7)\n\t\t\t in let <_13> =\n\t\t\t\t case %% Line 1846\n\t\t\t\t call 'filename':'pathtype'\n\t\t\t\t\t (FName) of\n\t\t\t\t %% Line 1847\n\t\t\t\t <'relative'>\n\t\t\t\t\twhen call 'erlang':'=/='\n\t\t\t\t\t (DName,\n\t\t\t\t\t []) ->\n\t\t\t\t\tlet =\n\t\t\t\t\t call %% Line 1850\n\t\t\t\t\t\t 'filename':%% Line 1850\n\t\t\t\t\t\t\t 'join'\n\t\t\t\t\t\t(%% Line 1850\n\t\t\t\t\t\t DName, %% Line 1850\n\t\t\t\t\t\t\tFName)\n\t\t\t\t\tin %% Line 1851\n\t\t\t\t\t case call 'erl_prim_loader':'read_file_info'\n\t\t\t\t\t\t (RName) of\n\t\t\t\t\t %% Line 1852\n\t\t\t\t\t <{'ok',_23}> when 'true' ->\n\t\t\t\t\t\t RName\n\t\t\t\t\t %% Line 1853\n\t\t\t\t\t <'error'> when 'true' ->\n\t\t\t\t\t\t FName\n\t\t\t\t\t ( <_11> when 'true' ->\n\t\t\t\t\t\t primop 'match_fail'\n\t\t\t\t\t\t\t({'case_clause',_11})\n\t\t\t\t\t\t-| ['compiler_generated'] )\n\t\t\t\t\t end\n\t\t\t\t %% Line 1855\n\t\t\t\t <_24> when 'true' ->\n\t\t\t\t\tFName\n\t\t\t\t end\n\t\t\t in %% Line 1857\n\t\t\t\t case apply 'load_file'/1\n\t\t\t\t\t (_13) of\n\t\t\t\t %% Line 1858\n\t\t\t\t <{'ok',NewEnv}> when 'true' ->\n\t\t\t\t\tlet <_15> =\n\t\t\t\t\t apply %% Line 1859\n\t\t\t\t\t\t 'merge_env'/2\n\t\t\t\t\t\t(%% Line 1859\n\t\t\t\t\t\t SysEnv, %% Line 1859\n\t\t\t\t\t\t\t NewEnv)\n\t\t\t\t\tin %% Line 1859\n\t\t\t\t\t apply 'check_conf_sys'/4\n\t\t\t\t\t\t(T, _15, Errors, DName)\n\t\t\t\t %% Line 1860\n\t\t\t\t <{'error',{Line,_X_Mod,Str}}> when 'true' ->\n\t\t\t\t\t%% Line 1861\n\t\t\t\t\tapply 'check_conf_sys'/4\n\t\t\t\t\t (T, SysEnv, [{'error',{_13,Line,Str}}|Errors], DName)\n\t\t\t\t ( <_16> when 'true' ->\n\t\t\t\t\t primop 'match_fail'\n\t\t\t\t\t ({'case_clause',_16})\n\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t end\n\t %% Line 1863\n\t <[Tuple|T],SysEnv,Errors,DName> when 'true' ->\n\t let <_17> =\n\t\t apply %% Line 1864\n\t\t\t'merge_env'/2\n\t\t (%% Line 1864\n\t\t SysEnv, %% Line 1864\n\t\t\t [Tuple|[]])\n\t in %% Line 1864\n\t\t apply 'check_conf_sys'/4\n\t\t (T, _17, Errors, DName)\n\t %% Line 1865\n\t <[],SysEnv,Errors,_25> when 'true' ->\n\t let <_18> =\n\t\t call %% Line 1866\n\t\t 'lists':%% Line 1866\n\t\t\t 'reverse'\n\t\t (%% Line 1866\n\t\t Errors)\n\t in %% Line 1866\n\t\t {'ok',SysEnv,_18}\n\t ( <_22,_21,_20,_19> when 'true' ->\n\t\t( primop 'match_fail'\n\t\t ({'function_clause',_22,_21,_20,_19})\n\t\t -| [{'function_name',{'check_conf_sys',4}}] )\n\t -| ['compiler_generated'] )\n\tend\n'load_file'/1 =\n %% Line 1868\n fun (_0) ->\n\t%% Line 1870\n\tcase call 'erl_prim_loader':'get_file'\n\t\t (_0) of\n\t %% Line 1871\n\t <{'ok',Bin,_X_FileName}> when 'true' ->\n\t %% Line 1874\n\t case apply 'file_binary_to_list'/1\n\t\t (Bin) of\n\t\t%% Line 1875\n\t\t<{'ok',String}> when 'true' ->\n\t\t let <_1> =\n\t\t\tcall %% Line 1876\n\t\t\t 'erlang':%% Line 1876\n\t\t\t\t '++'\n\t\t\t (%% Line 1876\n\t\t\t String, %% Line 1876\n\t\t\t\t [32])\n\t\t in %% Line 1876\n\t\t\tapply 'scan_file'/1\n\t\t\t (_1)\n\t\t%% Line 1877\n\t\t<'error'> when 'true' ->\n\t\t %% Line 1878\n\t\t {'error',{'none','scan_file',[98|[97|[100|[32|[101|[110|[99|[111|[100|[105|[110|[103]]]]]]]]]]]]}}\n\t\t( <_2> when 'true' ->\n\t\t primop 'match_fail'\n\t\t\t ({'case_clause',_2})\n\t\t -| ['compiler_generated'] )\n\t end\n\t %% Line 1880\n\t <'error'> when 'true' ->\n\t %% Line 1881\n\t {'error',{'none','open_file',[99|[111|[110|[102|[105|[103|[117|[114|[97|[116|[105|[111|[110|[32|[102|[105|[108|[101|[32|[110|[111|[116|[32|[102|[111|[117|[110|[100]]]]]]]]]]]]]]]]]]]]]]]]]]]]}}\n\t ( <_3> when 'true' ->\n\t\tprimop 'match_fail'\n\t\t ({'case_clause',_3})\n\t -| ['compiler_generated'] )\n\tend\n'scan_file'/1 =\n %% Line 1884\n fun (_0) ->\n\t%% Line 1885\n\tcase call 'erl_scan':'tokens'\n\t\t ([], _0, 1) of\n\t %% Line 1886\n\t <{'done',{'ok',Tokens,_6},Left}> when 'true' ->\n\t %% Line 1887\n\t case call 'erl_parse':'parse_term'\n\t\t (Tokens) of\n\t\t%% Line 1888\n\t\t\n\t\t when call 'erlang':'is_list'\n\t\t\t (L) ->\n\t\t %% Line 1889\n\t\t case apply 'only_ws'/1\n\t\t\t (Left) of\n\t\t %% Line 1890\n\t\t <'true'> when 'true' ->\n\t\t\t %% Line 1891\n\t\t\t Res\n\t\t %% Line 1892\n\t\t <'false'> when 'true' ->\n\t\t\t %% Line 1894\n\t\t\t apply 'config_error'/0\n\t\t\t ()\n\t\t ( <_1> when 'true' ->\n\t\t\t primop 'match_fail'\n\t\t\t\t({'case_clause',_1})\n\t\t\t-| ['compiler_generated'] )\n\t\t end\n\t\t%% Line 1896\n\t\t<{'ok',_7}> when 'true' ->\n\t\t %% Line 1898\n\t\t apply 'config_error'/0\n\t\t\t()\n\t\t%% Line 1899\n\t\t when 'true' ->\n\t\t %% Line 1900\n\t\t Error\n\t end\n\t %% Line 1902\n\t <{'done',Result,_8}> when 'true' ->\n\t let <_3> =\n\t\t call %% Line 1903\n\t\t 'erlang':%% Line 1903\n\t\t\t\t'tuple_to_list'\n\t\t (%% Line 1903\n\t\t Result)\n\t in %% Line 1903\n\t\t {'error',{'none','parse_file',_3}}\n\t %% Line 1904\n\t <{'more',_9}> when 'true' ->\n\t %% Line 1905\n\t {'error',{'none','load_file',[110|[111|[32|[101|[110|[100|[105|[110|[103|[32|[60|[100|[111|[116|[62|[32|[102|[111|[117|[110|[100]]]]]]]]]]]]]]]]]]]]]}}\n\t ( <_4> when 'true' ->\n\t\tprimop 'match_fail'\n\t\t ({'case_clause',_4})\n\t -| ['compiler_generated'] )\n\tend\n'only_ws'/1 =\n %% Line 1908\n fun (_0) ->\n\tcase _0 of\n\t <[C|Cs]>\n\t when call 'erlang':'=<'\n\t\t (C,\n\t\t 32) ->\n\t apply 'only_ws'/1\n\t\t (Cs)\n\t %% Line 1909\n\t <[37|Cs]> when 'true' ->\n\t let <_1> =\n\t\t apply 'strip_comment'/1\n\t\t (Cs)\n\t in apply 'only_ws'/1\n\t\t (_1)\n\t %% Line 1910\n\t <[_3|_4]> when 'true' ->\n\t 'false'\n\t %% Line 1911\n\t <[]> when 'true' ->\n\t 'true'\n\t ( <_2> when 'true' ->\n\t\t( primop 'match_fail'\n\t\t ({'function_clause',_2})\n\t\t -| [{'function_name',{'only_ws',1}}] )\n\t -| ['compiler_generated'] )\n\tend\n'strip_comment'/1 =\n %% Line 1913\n fun (_0) ->\n\tcase _0 of\n\t <[10|Cs]> when 'true' ->\n\t Cs\n\t %% Line 1914\n\t <[_2|Cs]> when 'true' ->\n\t apply 'strip_comment'/1\n\t\t (Cs)\n\t %% Line 1915\n\t <[]> when 'true' ->\n\t []\n\t ( <_1> when 'true' ->\n\t\t( primop 'match_fail'\n\t\t ({'function_clause',_1})\n\t\t -| [{'function_name',{'strip_comment',1}}] )\n\t -| ['compiler_generated'] )\n\tend\n'config_error'/0 =\n %% Line 1917\n fun () ->\n\t%% Line 1918\n\t{'error',{'none','load_file',[99|[111|[110|[102|[105|[103|[117|[114|[97|[116|[105|[111|[110|[32|[102|[105|[108|[101|[32|[109|[117|[115|[116|[32|[99|[111|[110|[116|[97|[105|[110|[32|[79|[78|[69|[32|[108|[105|[115|[116|[32|[101|[110|[100|[101|[100|[32|[98|[121|[32|[60|[100|[111|[116|[62]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]}}\n'info_started'/2 =\n %% Line 1925\n fun (_1,_0) ->\n\t%% Line 1926\n\tcase call 'logger':'allow'\n\t\t ('info', 'application_controller') of\n\t <'true'> when 'true' ->\n\t let <_2> =\n\t\t ~{%% Line 1927\n\t\t 'report'=>[{'application',_1}|%% Line 1928\n\t\t\t\t\t [{'started_at',_0}|[]]]|~{'label'=>{'application_controller','progress'}}~}~\n\t in call 'logger':'macro_log'\n\t\t (~{'file'=>[97|[112|[112|[108|[105|[99|[97|[116|[105|[111|[110|[95|[99|[111|[110|[116|[114|[111|[108|[108|[101|[114|[46|[101|[114|[108]]]]]]]]]]]]]]]]]]]]]]]]]],'line'=>1926,'mfa'=>{'application_controller','info_started',2}}~, 'info', _2, ~{'domain'=>['otp'|['sasl']],'error_logger'=>~{'tag'=>'info_report','type'=>'progress'}~,'logger_formatter'=>~{'title'=>[80|[82|[79|[71|[82|[69|[83|[83|[32|[82|[69|[80|[79|[82|[84]]]]]]]]]]]]]]]}~,'report_cb'=>fun 'logger':'format_otp_report'/1}~)\n\t %% Line 1932\n\t <'false'> when 'true' ->\n\t 'ok'\n\t ( <_5> when 'true' ->\n\t\tprimop 'match_fail'\n\t\t ({'case_clause',_5})\n\t -| ['compiler_generated'] )\n\tend\n'info_exited'/3 =\n %% Line 1934\n fun (_2,_1,_0) ->\n\t%% Line 1935\n\tcase call 'logger':'allow'\n\t\t ('notice', 'application_controller') of\n\t <'true'> when 'true' ->\n\t let <_3> =\n\t\t ~{%% Line 1936\n\t\t 'report'=>[{'application',_2}|%% Line 1937\n\t\t\t\t\t [{'exited',_1}|%% Line 1938\n\t\t\t\t\t\t\t [{'type',_0}|[]]]]|~{'label'=>{'application_controller','exit'}}~}~\n\t in call 'logger':'macro_log'\n\t\t (~{'file'=>[97|[112|[112|[108|[105|[99|[97|[116|[105|[111|[110|[95|[99|[111|[110|[116|[114|[111|[108|[108|[101|[114|[46|[101|[114|[108]]]]]]]]]]]]]]]]]]]]]]]]]],'line'=>1935,'mfa'=>{'application_controller','info_exited',3}}~, 'notice', _3, ~{'domain'=>['otp'],'error_logger'=>~{'tag'=>'info_report','type'=>'std_info'}~,'report_cb'=>fun 'logger':'format_otp_report'/1}~)\n\t %% Line 1941\n\t <'false'> when 'true' ->\n\t 'ok'\n\t ( <_6> when 'true' ->\n\t\tprimop 'match_fail'\n\t\t ({'case_clause',_6})\n\t -| ['compiler_generated'] )\n\tend\n'reply_to_requester'/3 =\n %% Line 1946\n fun (_2,_1,_0) ->\n\tlet <_4> =\n\t case _0 of\n\t %% Line 1948\n\t <{'ok',_X_Id}> when 'true' ->\n\t\t %% Line 1949\n\t\t 'ok'\n\t %% Line 1950\n\t <{'info',Reason}> when 'true' ->\n\t\t %% Line 1951\n\t\t {'error',Reason}\n\t %% Line 1952\n\t when 'true' ->\n\t\t %% Line 1953\n\t\t Error\n\t end\n\tin let <_11> =\n\t\tfun (_8,_7) ->\n\t\t %% Line 1957\n\t\t case _8 of\n\t\t %% Line 1958\n\t\t <{_15,From}>\n\t\t\t when call 'erlang':'=:='\n\t\t\t\t(_15,\n\t\t\t\t _2) ->\n\t\t\t do %% Line 1959\n\t\t\t apply 'reply'/2\n\t\t\t\t (From, _4)\n\t\t\t _7\n\t\t %% Line 1961\n\t\t <_16> when 'true' ->\n\t\t\t %% Line 1962\n\t\t\t [_8|_7]\n\t\t end\n\t in %% Line 1956\n\t\tcall 'lists':'foldl'\n\t\t (_11, %% Line 1965\n\t\t\t [], _1)\n'update_permissions'/2 =\n %% Line 1972\n fun (_1,_0) ->\n\t%% Line 1974\n\tcase call 'ets':'lookup'\n\t\t ('ac_tab', {'env','kernel','permissions'}) of\n\t %% Line 1975\n\t <[]> when 'true' ->\n\t %% Line 1976\n\t call 'ets':'insert'\n\t\t ('ac_tab', {{'env','kernel','permissions'},[{_1,_0}|[]]})\n\t %% Line 1977\n\t <[{_7,Perm}|[]]> when 'true' ->\n\t let =\n\t\t call %% Line 1978\n\t\t 'lists':%% Line 1978\n\t\t\t 'keydelete'\n\t\t (_1, %% Line 1978\n\t\t\t 1, %% Line 1978\n\t\t\t Perm)\n\t in %% Line 1979\n\t\t call 'ets':'insert'\n\t\t ('ac_tab', {{'env','kernel','permissions'},[{_1,_0}|Perm2]})\n\t ( <_4> when 'true' ->\n\t\tprimop 'match_fail'\n\t\t ({'case_clause',_4})\n\t -| ['compiler_generated'] )\n\tend\n'test_change_apps'/2 =\n %% Line 1985\n fun (_1,_0) ->\n\tlet =\n\t apply %% Line 1986\n\t\t 'test_make_apps'/2\n\t\t(_1, %% Line 1986\n\t\t [])\n\tin %% Line 1987\n\t apply 'test_do_change_appl'/3\n\t\t(_1, _0, Res)\n'test_do_change_appl'/3 =\n %% Line 1989\n fun (_2,_1,_0) ->\n\tcase <_2,_1,_0> of\n\t <[],_8,_9> when 'true' ->\n\t %% Line 1990\n\t 'ok'\n\t %% Line 1991\n\t <[A|Apps],[],[R|Res]> when 'true' ->\n\t do %% Line 1992\n\t\t apply 'do_change_appl'/3\n\t\t (R, ( {( 'appl'\n\t\t\t -| ['result_not_wanted'] ),A,( 'undefined'\n\t\t\t\t\t\t\t -| ['result_not_wanted'] ),( 'undefined'\n\t\t\t\t\t\t\t\t\t\t\t -| ['result_not_wanted'] ),( 'undefined'\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t-| ['result_not_wanted'] ),( 'undefined'\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| ['result_not_wanted'] ),( 'undefined'\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| ['result_not_wanted'] ),( 'undefined'\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| ['result_not_wanted'] ),( 'undefined'\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| ['result_not_wanted'] )}\n\t\t\t -| ['result_not_wanted'] ), ( []\n\t\t\t\t\t\t\t -| ['result_not_wanted'] ))\n\t\t %% Line 1993\n\t\t apply 'test_do_change_appl'/3\n\t\t (Apps, [], Res)\n\t %% Line 1994\n\t <[A|Apps],[C|Conf],[R|Res]> when 'true' ->\n\t do %% Line 1995\n\t\t apply 'do_change_appl'/3\n\t\t (R, ( {( 'appl'\n\t\t\t -| ['result_not_wanted'] ),A,( 'undefined'\n\t\t\t\t\t\t\t -| ['result_not_wanted'] ),( 'undefined'\n\t\t\t\t\t\t\t\t\t\t\t -| ['result_not_wanted'] ),( 'undefined'\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t-| ['result_not_wanted'] ),( 'undefined'\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| ['result_not_wanted'] ),( 'undefined'\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| ['result_not_wanted'] ),( 'undefined'\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| ['result_not_wanted'] ),( 'undefined'\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| ['result_not_wanted'] )}\n\t\t\t -| ['result_not_wanted'] ), C)\n\t\t %% Line 1996\n\t\t apply 'test_do_change_appl'/3\n\t\t (Apps, Conf, Res)\n\t ( <_7,_6,_5> when 'true' ->\n\t\t( primop 'match_fail'\n\t\t ({'function_clause',_7,_6,_5})\n\t\t -| [{'function_name',{'test_do_change_appl',3}}] )\n\t -| ['compiler_generated'] )\n\tend\n'test_make_apps'/2 =\n %% Line 1998\n fun (_1,_0) ->\n\tcase <_1,_0> of\n\t <[],Res> when 'true' ->\n\t %% Line 1999\n\t call 'lists':'reverse'\n\t\t (Res)\n\t %% Line 2000\n\t <[A|Apps],Res> when 'true' ->\n\t let <_2> =\n\t\t apply %% Line 2001\n\t\t\t'make_appl'/1\n\t\t (%% Line 2001\n\t\t A)\n\t in %% Line 2001\n\t\t apply 'test_make_apps'/2\n\t\t (Apps, [_2|Res])\n\t ( <_4,_3> when 'true' ->\n\t\t( primop 'match_fail'\n\t\t ({'function_clause',_4,_3})\n\t\t -| [{'function_name',{'test_make_apps',2}}] )\n\t -| ['compiler_generated'] )\n\tend\n'file_binary_to_list'/1 =\n %% Line 2003\n fun (_0) ->\n\tlet <_2> =\n\t case %% Line 2004\n\t\t call 'epp':'read_encoding_from_binary'\n\t\t (_0) of\n\t %% Line 2005\n\t <'none'> when 'true' ->\n\t\t call 'epp':'default_encoding'\n\t\t ()\n\t %% Line 2006\n\t when 'true' ->\n\t\t Encoding\n\t end\n\tin let <_4> =\n\t\tcatch\n\t\t %% Line 2008\n\t\t call 'unicode':'characters_to_list'\n\t\t\t(_0, _2)\n\t in %% Line 2008\n\t\tcase _4 of\n\t\t %% Line 2009\n\t\t \n\t\t when call 'erlang':'is_list'\n\t\t\t (_4) ->\n\t\t %% Line 2010\n\t\t {'ok',String}\n\t\t %% Line 2011\n\t\t <_7> when 'true' ->\n\t\t %% Line 2012\n\t\t 'error'\n\t\tend\n'to_string'/1 =\n %% Line 2023\n fun (_0) ->\n\t%% Line 2024\n\tcase call 'io_lib':'printable_list'\n\t\t (_0) of\n\t %% Line 2025\n\t <'true'> when 'true' ->\n\t _0\n\t %% Line 2027\n\t <'false'> when 'true' ->\n\t let <_1> =\n\t\t call %% Line 2028\n\t\t 'io_lib':%% Line 2028\n\t\t\t\t'format'\n\t\t (%% Line 2028\n\t\t [126|[48|[112]]], %% Line 2028\n\t\t\t\t\t [_0|[]])\n\t in %% Line 2028\n\t\t call 'lists':'flatten'\n\t\t (_1)\n\t ( <_2> when 'true' ->\n\t\tprimop 'match_fail'\n\t\t ({'case_clause',_2})\n\t -| ['compiler_generated'] )\n\tend\n'module_info'/0 =\n fun () ->\n\tcall 'erlang':'get_module_info'\n\t ('application_controller')\n'module_info'/1 =\n fun (_0) ->\n\tcall 'erlang':'get_module_info'\n\t ('application_controller', _0)\nend" }, { "path": "test_data/basic_module.core", "content": "module 'basic_module' ['woo'/1, 'hoo'/2] attributes [\n'file' = {1, 2, 3},\n'file' = {1, 2, 3}]\n\n'start_application'/2 =\n %% what\n fun (_1,_0) ->\n 'woo'\n\n'woo'/1 = fun (_0) -> _0\n\n'woo'/1 = fun (_0) -> _0\n\nend\n" }, { "path": "test_data/basic_module.erl", "content": "-module(basic_module).\n-export([woo/1]).\n\nwoo(A) -> A.\n" }, { "path": "test_data/basic_regress/enum_aggregate.core", "content": "module 'Elixir.Enum' ['aggregate'/3] attributes []\n\n'aggregate'/3 =\n %% Line 2815\n fun (_2,_1,_0) ->\n\tcase <_2,_1,_0> of\n\t <[_X_head@1|_X_tail@1],_X_fun@1,_X__empty@1> when 'true' ->\n\t letrec\n\t\t 'lists^foldl'/2 =\n\t\t fun (Xs,_15) ->\n\t\t\t case Xs of\n\t\t\t <[X|_16]> when 'true' ->\n\t\t\t\t%% Line 2816\n\t\t\t\tapply 'lists^foldl'/2\n\t\t\t\t (_16, apply _X_fun@1\n\t\t\t\t\t (X, _15))\n\t\t\t <[]>\n\t\t\t\twhen call 'erlang':'is_function'\n\t\t\t\t (%% Line 2816\n\t\t\t\t _X_fun@1,\n\t\t\t\t 2) ->\n\t\t\t\t_15\n\t\t\t <_17> when 'true' ->\n\t\t\t\t%% Line 2816\n\t\t\t\t( primop 'match_fail'\n\t\t\t\t ({'function_clause',_X_fun@1,_15,_17})\n\t\t\t\t -| [{'function_name',{'lists^foldl',2}}] )\n\t\t\t end\n\t in %% Line 2816\n\t\t apply 'lists^foldl'/2\n\t\t (_X_tail@1, _X_head@1)\n\t %% Line 2819\n\t <[],_X__fun@1,_X_empty@1> when 'true' ->\n\t %% Line 2820\n\t apply _X_empty@1\n\t\t ()\n\t %% Line 2823\n\t <~{'last':=_X_last@1,'first':=_X_first@1,'__struct__':='Elixir.Range'}~,_X_fun@1,_X__empty@1> when 'true' ->\n\t %% Line 2824\n\t apply _X_fun@1\n\t\t (_X_first@1, _X_last@1)\n\t %% Line 2827\n\t <_X_enumerable@1,_X_fun@1,_X_empty@1> when 'true' ->\n\t let <_X_ref@1> =\n\t\t call 'erlang':%% Line 2828\n\t\t\t\t'make_ref'\n\t\t ()\n\t in let <_8> =\n\t\t fun (_5,_4) ->\n\t\t\t %% Line 2831\n\t\t\t case <_5,_4> of\n\t\t\t %% Line 2832\n\t\t\t <_X_element@1,_X_ref@2>\n\t\t\t\twhen ( call ( 'erlang'\n\t\t\t\t\t -| ['compiler_generated'] ):( '=:='\n\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t(( _X_ref@1\n\t\t\t\t\t -| ['compiler_generated'] ),\n\t\t\t\t\t _X_ref@2)\n\t\t\t\t -| ['compiler_generated'] ) ->\n\t\t\t\t_X_element@1\n\t\t\t %% Line 2833\n\t\t\t <_X_element@2,_X_acc@1> when 'true' ->\n\t\t\t\tapply _X_fun@1\n\t\t\t\t (_X_element@2, _X_acc@1)\n\t\t\t end\n\t\t in %% Line 2835\n\t\t case ( case ( <( _X_enumerable@1\n\t\t\t\t -| ['compiler_generated'] ),( _X_ref@1\n\t\t\t\t\t\t\t\t -| ['compiler_generated'] ),( _8\n\t\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] )>\n\t\t\t\t -| ['compiler_generated'] ) of\n\t\t\t ( <_21,( _X_acc@1\n\t\t\t\t\t-| ['compiler_generated'] ),_22>\n\t\t\t\t when ( call ( 'erlang'\n\t\t\t\t\t\t-| ['compiler_generated'] ):( 'is_list'\n\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t (_21)\n\t\t\t\t\t -| ['compiler_generated'] ) ->\n\t\t\t\t letrec\n\t\t\t\t\t 'lists^foldl'/2 =\n\t\t\t\t\t fun (Xs,_23) ->\n\t\t\t\t\t\t case Xs of\n\t\t\t\t\t\t <[X|_24]> when 'true' ->\n\t\t\t\t\t\t ( apply 'lists^foldl'/2\n\t\t\t\t\t\t\t (_24, ( apply _22\n\t\t\t\t\t\t\t\t\t (X, _23)\n\t\t\t\t\t\t\t\t -| ['compiler_generated'] ))\n\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t\t <[]>\n\t\t\t\t\t\t when call 'erlang':'is_function'\n\t\t\t\t\t\t\t (_22,\n\t\t\t\t\t\t\t 2) ->\n\t\t\t\t\t\t _23\n\t\t\t\t\t\t <_25> when 'true' ->\n\t\t\t\t\t\t ( primop 'match_fail'\n\t\t\t\t\t\t\t ({'function_clause',_22,_23,_25})\n\t\t\t\t\t\t\t -| [{'function_name',{'lists^foldl',2}},'compiler_generated'] )\n\t\t\t\t\t\t end\n\t\t\t\t in ( apply 'lists^foldl'/2\n\t\t\t\t\t (_21, ( _X_acc@1\n\t\t\t\t\t\t -| ['compiler_generated'] ))\n\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t -| ['compiler_generated'] )\n\t\t\t ( <( ~{( ( 'last'\n\t\t\t\t\t -| ['compiler_generated'] ):=( _X_last@1\n\t\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t -| ['compiler_generated'] ),( ( 'first'\n\t\t\t\t\t\t\t\t\t-| ['compiler_generated'] ):=( _X_first@1\n\t\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t\t\t\t -| ['compiler_generated'] ),( ( '__struct__'\n\t\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] ):=( 'Elixir.Range'\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] )}~\n\t\t\t\t -| ['compiler_generated'] ),( _X_acc@1\n\t\t\t\t\t\t\t\t -| ['compiler_generated'] ),_26> when ( 'true'\n\t\t\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] ) ->\n\t\t\t\t ( case <> of\n\t\t\t\t\t ( <>\n\t\t\t\t\t when ( call ( 'erlang'\n\t\t\t\t\t\t\t -| ['compiler_generated'] ):( '=<'\n\t\t\t\t\t\t\t\t\t\t\t-| ['compiler_generated'] )\n\t\t\t\t\t\t (( _X_first@1\n\t\t\t\t\t\t\t -| ['compiler_generated'] ),\n\t\t\t\t\t\t\t( _X_last@1\n\t\t\t\t\t\t\t -| ['compiler_generated'] ))\n\t\t\t\t\t\t -| ['compiler_generated'] ) ->\n\t\t\t\t\t ( apply ( 'reduce_range_inc'/4\n\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t\t (( _X_first@1\n\t\t\t\t\t\t\t-| ['compiler_generated'] ), ( _X_last@1\n\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] ), ( _X_acc@1\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] ), _26)\n\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t ( <> when ( 'true'\n\t\t\t\t\t\t -| ['compiler_generated'] ) ->\n\t\t\t\t\t ( apply ( 'reduce_range_dec'/4\n\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t\t (( _X_first@1\n\t\t\t\t\t\t\t-| ['compiler_generated'] ), ( _X_last@1\n\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] ), ( _X_acc@1\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] ), _26)\n\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t end\n\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t -| ['compiler_generated'] )\n\t\t\t ( <( _27 = ( ~{( ( '__struct__'\n\t\t\t\t\t\t -| ['compiler_generated'] ):=( ( _X__@1\n\t\t\t\t\t\t\t\t\t\t-| ['compiler_generated'] ) = ( _14\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t-| ['compiler_generated'] )\n\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t -| ['compiler_generated'] )}~\n\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t -| ['compiler_generated'] ),( _X_acc@1\n\t\t\t\t\t\t\t\t -| ['compiler_generated'] ),_28>\n\t\t\t\t when ( call ( 'erlang'\n\t\t\t\t\t\t-| ['compiler_generated'] ):( 'is_atom'\n\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t (( _X__@1\n\t\t\t\t\t\t-| ['compiler_generated'] ))\n\t\t\t\t\t -| ['compiler_generated'] ) ->\n\t\t\t\t ( let <_37> =\n\t\t\t\t\t fun (( _5\n\t\t\t\t\t\t -| ['compiler_generated'] ),( _4\n\t\t\t\t\t\t\t\t\t\t-| ['compiler_generated'] )) ->\n\t\t\t\t\t ( let <_3> =\n\t\t\t\t\t\t apply _28\n\t\t\t\t\t\t\t (( _5\n\t\t\t\t\t\t\t -| ['compiler_generated'] ), ( _4\n\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] ))\n\t\t\t\t\t\t in ( {( 'cont'\n\t\t\t\t\t\t\t -| ['compiler_generated'] ),( _3\n\t\t\t\t\t\t\t\t\t\t\t-| ['compiler_generated'] )}\n\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t in ( let <_9> =\n\t\t\t\t\t\t call ( 'Elixir.Enumerable'\n\t\t\t\t\t\t\t-| ['compiler_generated'] ):%% Line 3015\n\t\t\t\t\t\t\t\t\t\t ( 'reduce'\n\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t\t (_27, ( {( 'cont'\n\t\t\t\t\t\t\t\t-| ['compiler_generated'] ),( _X_acc@1\n\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] )}\n\t\t\t\t\t\t\t -| ['compiler_generated'] ), _37)\n\t\t\t\t\t in %% Line 3015\n\t\t\t\t\t\t ( call ( 'erlang'\n\t\t\t\t\t\t\t -| ['compiler_generated'] ):( 'element'\n\t\t\t\t\t\t\t\t\t\t\t-| ['compiler_generated'] )\n\t\t\t\t\t\t (( 2\n\t\t\t\t\t\t\t -| ['compiler_generated'] ), ( _9\n\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] ))\n\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t -| ['compiler_generated'] )\n\t\t\t ( <( _41 = ( ~{}~\n\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t -| ['compiler_generated'] ),( _X_acc@1\n\t\t\t\t\t\t\t\t -| ['compiler_generated'] ),_42> when ( 'true'\n\t\t\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] ) ->\n\t\t\t\t ( let <_10> =\n\t\t\t\t\t fun (( _6\n\t\t\t\t\t\t -| ['compiler_generated'] ),( _5\n\t\t\t\t\t\t\t\t\t\t-| ['compiler_generated'] ),( _4\n\t\t\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] )) ->\n\t\t\t\t\t ( apply _42\n\t\t\t\t\t\t (( {( _6\n\t\t\t\t\t\t\t -| ['compiler_generated'] ),( _5\n\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] )}\n\t\t\t\t\t\t\t-| ['compiler_generated'] ), ( _4\n\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] ))\n\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t in ( call ( 'maps'\n\t\t\t\t\t\t -| ['compiler_generated'] ):( 'fold'\n\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t\t (( _10\n\t\t\t\t\t\t -| ['compiler_generated'] ), ( _X_acc@1\n\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] ), _41)\n\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t -| ['compiler_generated'] )\n\t\t\t ( <_46,( _X_acc@1\n\t\t\t\t\t-| ['compiler_generated'] ),_47> when ( 'true'\n\t\t\t\t\t\t\t\t\t\t-| ['compiler_generated'] ) ->\n\t\t\t\t ( let <_56> =\n\t\t\t\t\t fun (( _5\n\t\t\t\t\t\t -| ['compiler_generated'] ),( _4\n\t\t\t\t\t\t\t\t\t\t-| ['compiler_generated'] )) ->\n\t\t\t\t\t ( let <_3> =\n\t\t\t\t\t\t apply _47\n\t\t\t\t\t\t\t (( _5\n\t\t\t\t\t\t\t -| ['compiler_generated'] ), ( _4\n\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] ))\n\t\t\t\t\t\t in ( {( 'cont'\n\t\t\t\t\t\t\t -| ['compiler_generated'] ),( _3\n\t\t\t\t\t\t\t\t\t\t\t-| ['compiler_generated'] )}\n\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t in ( let <_9> =\n\t\t\t\t\t\t call ( 'Elixir.Enumerable'\n\t\t\t\t\t\t\t-| ['compiler_generated'] ):%% Line 3015\n\t\t\t\t\t\t\t\t\t\t ( 'reduce'\n\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t\t (_46, ( {( 'cont'\n\t\t\t\t\t\t\t\t-| ['compiler_generated'] ),( _X_acc@1\n\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] )}\n\t\t\t\t\t\t\t -| ['compiler_generated'] ), _56)\n\t\t\t\t\t in %% Line 3015\n\t\t\t\t\t\t ( call ( 'erlang'\n\t\t\t\t\t\t\t -| ['compiler_generated'] ):( 'element'\n\t\t\t\t\t\t\t\t\t\t\t-| ['compiler_generated'] )\n\t\t\t\t\t\t (( 2\n\t\t\t\t\t\t\t -| ['compiler_generated'] ), ( _9\n\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] ))\n\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t -| ['compiler_generated'] )\n\t\t\t end\n\t\t\t -| ['compiler_generated'] ) of\n\t\t\t%% Line 2836\n\t\t\t<_13>\n\t\t\t when ( call 'erlang':'=:='\n\t\t\t\t (_13,\n\t\t\t\t ( _X_ref@1\n\t\t\t\t -| ['compiler_generated'] ))\n\t\t\t\t-| ['compiler_generated'] ) ->\n\t\t\t apply _X_empty@1\n\t\t\t\t()\n\t\t\t%% Line 2837\n\t\t\t<_X_result@1> when 'true' ->\n\t\t\t _X_result@1\n\t\t end\n\tend\n\nend\n" }, { "path": "test_data/basic_regress/function_capture_1.core", "content": "module 'test' ['test'/0] attributes []\n\n'test'/0 =\n fun () ->\n fun 'logger':'format_otp_report'/1\n\nend\n" }, { "path": "test_data/basic_regress/line_annotation_fail_1.core", "content": "module 'test' ['test'/3] attributes []\n\n'test'/3 =\n fun (_2,_1,_0) ->\n case <_2,_1,_0> of\n\t <{'ok',{ApplData,Env,IncApps,Descr,Id,Vsn,Apps}},%% Line 1573\n\t\t\t\t\t\t\t OldAppl,%% Line 1573\n\t\t\t\t\t\t\t\t Config> when 'true' ->\n 'false'\n <_w,_t,_f> when 'true' ->\n 'true'\n end\n\nend\n" }, { "path": "test_data/basic_regress/type_construction_fail_1.core", "content": "module 'test' ['test1'/3,'test2'/3,'test3'/3] attributes []\n\n'test3'/3 =\n fun (_2,_1,_0) ->\n ~{'a'=>[]|[]}~\n\n'test2'/3 =\n fun (_2,_1,_0) ->\n ~{%% Line 1927\n 'report'=>[{'application',_1} |%% Line 1928\n [{'started_at',_0}|\n []\n ]\n ]|\n ~{'label'=>{'application_controller','progress'}}~}~\n\n'test1'/3 =\n fun (_2,_1,_0) ->\n ~{%% Line 1927\n 'report'=>[{'application',_1}|%% Line 1928\n [{'started_at',_0}|[]]]|~{'label'=>{'application_controller','progress'}}~}~\n\nend\n" }, { "path": "test_data/compile.core", "content": "module 'compile' ['compile'/3,\n\t\t 'compile_asm'/3,\n\t\t 'compile_beam'/3,\n\t\t 'compile_core'/3,\n\t\t 'env_compiler_options'/0,\n\t\t 'file'/1,\n\t\t 'file'/2,\n\t\t 'format_error'/1,\n\t\t 'forms'/1,\n\t\t 'forms'/2,\n\t\t 'iofile'/1,\n\t\t 'module_info'/0,\n\t\t 'module_info'/1,\n\t\t 'noenv_file'/2,\n\t\t 'noenv_forms'/2,\n\t\t 'noenv_output_generated'/1,\n\t\t 'options'/0,\n\t\t 'output_generated'/1]\n attributes [%% Line 1\n\t\t'file' =\n\t\t %% Line 1\n\t\t [{[115|[114|[99|[47|[99|[111|[109|[112|[105|[108|[101|[46|[101|[114|[108]]]]]]]]]]]]]]],1}],\n\t\t%% Line 34\n\t\t'export_type' =\n\t\t %% Line 34\n\t\t [{'option',0}],\n\t\t%% Line 1\n\t\t'file' =\n\t\t %% Line 1\n\t\t [{[47|[104|[111|[109|[101|[47|[104|[97|[110|[115|[105|[104|[101|[47|[112|[114|[111|[106|[47|[114|[117|[115|[116|[47|[99|[111|[114|[101|[95|[101|[114|[108|[97|[110|[103|[47|[111|[116|[112|[47|[108|[105|[98|[47|[99|[111|[109|[112|[105|[108|[101|[114|[47|[46|[46|[47|[115|[116|[100|[108|[105|[98|[47|[105|[110|[99|[108|[117|[100|[101|[47|[101|[114|[108|[95|[99|[111|[109|[112|[105|[108|[101|[46|[104|[114|[108]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]],1}],\n\t\t%% Line 23\n\t\t'record' =\n\t\t %% Line 23\n\t\t [{'options',[{'typed_record_field',{'record_field',24,{'atom',24,'includes'},{'nil',24}},{'type',24,'list',[{'remote_type',24,[{'atom',24,'file'}|[{'atom',24,'filename'}|[[]]]]}]}}|[{'typed_record_field',{'record_field',26,{'atom',26,'outdir'},{'string',26,[46]}},{'remote_type',26,[{'atom',26,'file'}|[{'atom',26,'filename'}|[[]]]]}}|[{'typed_record_field',{'record_field',28,{'atom',28,'output_type'},{'atom',28,'undefined'}},{'type',28,'atom',[]}}|[{'typed_record_field',{'record_field',29,{'atom',29,'defines'},{'nil',29}},{'type',29,'list',[{'type',29,'union',[{'type',29,'atom',[]}|[{'type',29,'tuple',[{'type',29,'atom',[]}|[{'var',29,'_'}]]}]]}]}}|[{'typed_record_field',{'record_field',33,{'atom',33,'warning'},{'integer',33,1}},{'type',33,'non_neg_integer',[]}}|[{'typed_record_field',{'record_field',36,{'atom',36,'verbose'},{'atom',36,'false'}},{'type',36,'boolean',[]}}|[{'record_field',37,{'atom',37,'optimize'},{'integer',37,999}}|[{'typed_record_field',{'record_field',38,{'atom',38,'specific'},{'nil',38}},{'type',38,'list',[{'var',38,'_'}]}}|[{'typed_record_field',{'record_field',39,{'atom',39,'outfile'},{'string',39,[]}},{'remote_type',39,[{'atom',39,'file'}|[{'atom',39,'filename'}|[[]]]]}}|[{'typed_record_field',{'record_field',41,{'atom',41,'cwd'}},{'remote_type',41,[{'atom',41,'file'}|[{'atom',41,'filename'}|[[]]]]}}]]]]]]]]]]}],\n\t\t%% Line 37\n\t\t'file' =\n\t\t %% Line 37\n\t\t [{[115|[114|[99|[47|[99|[111|[109|[112|[105|[108|[101|[46|[101|[114|[108]]]]]]]]]]]]]]],37}],\n\t\t%% Line 1\n\t\t'file' =\n\t\t %% Line 1\n\t\t [{[115|[114|[99|[47|[99|[111|[114|[101|[95|[112|[97|[114|[115|[101|[46|[104|[114|[108]]]]]]]]]]]]]]]]]],1}],\n\t\t%% Line 32\n\t\t'record' =\n\t\t %% Line 32\n\t\t [{'c_alias',[{'record_field',32,{'atom',32,'anno'},{'nil',32}}|[{'record_field',32,{'atom',32,'var'}}|[{'record_field',33,{'atom',33,'pat'}}]]]}],\n\t\t%% Line 35\n\t\t'record' =\n\t\t %% Line 35\n\t\t [{'c_apply',[{'record_field',35,{'atom',35,'anno'},{'nil',35}}|[{'record_field',35,{'atom',35,'op'}}|[{'record_field',36,{'atom',36,'args'}}]]]}],\n\t\t%% Line 38\n\t\t'record' =\n\t\t %% Line 38\n\t\t [{'c_binary',[{'record_field',38,{'atom',38,'anno'},{'nil',38}}|[{'typed_record_field',{'record_field',38,{'atom',38,'segments'}},{'type',38,'list',[{'remote_type',38,[{'atom',38,'cerl'}|[{'atom',38,'c_bitstr'}|[[]]]]}]}}]]}],\n\t\t%% Line 40\n\t\t'record' =\n\t\t %% Line 40\n\t\t [{'c_bitstr',[{'record_field',40,{'atom',40,'anno'},{'nil',40}}|[{'record_field',40,{'atom',40,'val'}}|[{'record_field',41,{'atom',41,'size'}}|[{'record_field',42,{'atom',42,'unit'}}|[{'record_field',43,{'atom',43,'type'}}|[{'record_field',44,{'atom',44,'flags'}}]]]]]]}],\n\t\t%% Line 46\n\t\t'record' =\n\t\t %% Line 46\n\t\t [{'c_call',[{'record_field',46,{'atom',46,'anno'},{'nil',46}}|[{'record_field',46,{'atom',46,'module'}}|[{'record_field',47,{'atom',47,'name'}}|[{'record_field',48,{'atom',48,'args'}}]]]]}],\n\t\t%% Line 50\n\t\t'record' =\n\t\t %% Line 50\n\t\t [{'c_case',[{'record_field',50,{'atom',50,'anno'},{'nil',50}}|[{'record_field',50,{'atom',50,'arg'}}|[{'record_field',51,{'atom',51,'clauses'}}]]]}],\n\t\t%% Line 53\n\t\t'record' =\n\t\t %% Line 53\n\t\t [{'c_catch',[{'record_field',53,{'atom',53,'anno'},{'nil',53}}|[{'record_field',53,{'atom',53,'body'}}]]}],\n\t\t%% Line 55\n\t\t'record' =\n\t\t %% Line 55\n\t\t [{'c_clause',[{'record_field',55,{'atom',55,'anno'},{'nil',55}}|[{'record_field',55,{'atom',55,'pats'}}|[{'record_field',56,{'atom',56,'guard'}}|[{'record_field',57,{'atom',57,'body'}}]]]]}],\n\t\t%% Line 59\n\t\t'record' =\n\t\t %% Line 59\n\t\t [{'c_cons',[{'record_field',59,{'atom',59,'anno'},{'nil',59}}|[{'record_field',59,{'atom',59,'hd'}}|[{'record_field',60,{'atom',60,'tl'}}]]]}],\n\t\t%% Line 62\n\t\t'record' =\n\t\t %% Line 62\n\t\t [{'c_fun',[{'record_field',62,{'atom',62,'anno'},{'nil',62}}|[{'record_field',62,{'atom',62,'vars'}}|[{'record_field',63,{'atom',63,'body'}}]]]}],\n\t\t%% Line 65\n\t\t'record' =\n\t\t %% Line 65\n\t\t [{'c_let',[{'record_field',65,{'atom',65,'anno'},{'nil',65}}|[{'record_field',65,{'atom',65,'vars'}}|[{'record_field',66,{'atom',66,'arg'}}|[{'record_field',67,{'atom',67,'body'}}]]]]}],\n\t\t%% Line 69\n\t\t'record' =\n\t\t %% Line 69\n\t\t [{'c_letrec',[{'record_field',69,{'atom',69,'anno'},{'nil',69}}|[{'record_field',69,{'atom',69,'defs'}}|[{'record_field',70,{'atom',70,'body'}}]]]}],\n\t\t%% Line 72\n\t\t'record' =\n\t\t %% Line 72\n\t\t [{'c_literal',[{'record_field',72,{'atom',72,'anno'},{'nil',72}}|[{'record_field',72,{'atom',72,'val'}}]]}],\n\t\t%% Line 74\n\t\t'record' =\n\t\t %% Line 74\n\t\t [{'c_map',[{'record_field',74,{'atom',74,'anno'},{'nil',74}}|[{'typed_record_field',{'record_field',75,{'atom',75,'arg'},{'record',75,'c_literal',[{'record_field',75,{'atom',75,'val'},{'map',75,[]}}]}},{'type',75,'union',[{'remote_type',75,[{'atom',75,'cerl'}|[{'atom',75,'c_var'}|[[]]]]}|[{'remote_type',75,[{'atom',75,'cerl'}|[{'atom',75,'c_literal'}|[[]]]]}]]}}|[{'typed_record_field',{'record_field',76,{'atom',76,'es'}},{'type',76,'list',[{'remote_type',76,[{'atom',76,'cerl'}|[{'atom',76,'c_map_pair'}|[[]]]]}]}}|[{'typed_record_field',{'record_field',77,{'atom',77,'is_pat'},{'atom',77,'false'}},{'type',77,'boolean',[]}}]]]]}],\n\t\t%% Line 79\n\t\t'record' =\n\t\t %% Line 79\n\t\t [{'c_map_pair',[{'record_field',79,{'atom',79,'anno'},{'nil',79}}|[{'typed_record_field',{'record_field',80,{'atom',80,'op'}},{'type',80,'union',[{'type',80,'record',[{'atom',80,'c_literal'}|[{'type',80,'field_type',[{'atom',80,'val'}|[{'atom',80,'assoc'}]]}]]}|[{'type',80,'record',[{'atom',80,'c_literal'}|[{'type',80,'field_type',[{'atom',80,'val'}|[{'atom',80,'exact'}]]}]]}]]}}|[{'record_field',81,{'atom',81,'key'}}|[{'record_field',82,{'atom',82,'val'}}]]]]}],\n\t\t%% Line 84\n\t\t'record' =\n\t\t %% Line 84\n\t\t [{'c_module',[{'record_field',84,{'atom',84,'anno'},{'nil',84}}|[{'record_field',84,{'atom',84,'name'}}|[{'record_field',85,{'atom',85,'exports'}}|[{'record_field',86,{'atom',86,'attrs'}}|[{'record_field',87,{'atom',87,'defs'}}]]]]]}],\n\t\t%% Line 89\n\t\t'record' =\n\t\t %% Line 89\n\t\t [{'c_primop',[{'record_field',89,{'atom',89,'anno'},{'nil',89}}|[{'record_field',89,{'atom',89,'name'}}|[{'record_field',90,{'atom',90,'args'}}]]]}],\n\t\t%% Line 92\n\t\t'record' =\n\t\t %% Line 92\n\t\t [{'c_receive',[{'record_field',92,{'atom',92,'anno'},{'nil',92}}|[{'record_field',92,{'atom',92,'clauses'}}|[{'record_field',93,{'atom',93,'timeout'}}|[{'record_field',94,{'atom',94,'action'}}]]]]}],\n\t\t%% Line 96\n\t\t'record' =\n\t\t %% Line 96\n\t\t [{'c_seq',[{'record_field',96,{'atom',96,'anno'},{'nil',96}}|[{'record_field',96,{'atom',96,'arg'}}|[{'record_field',97,{'atom',97,'body'}}]]]}],\n\t\t%% Line 99\n\t\t'record' =\n\t\t %% Line 99\n\t\t [{'c_try',[{'record_field',99,{'atom',99,'anno'},{'nil',99}}|[{'record_field',99,{'atom',99,'arg'}}|[{'record_field',100,{'atom',100,'vars'}}|[{'record_field',101,{'atom',101,'body'}}|[{'record_field',102,{'atom',102,'evars'}}|[{'record_field',103,{'atom',103,'handler'}}]]]]]]}],\n\t\t%% Line 105\n\t\t'record' =\n\t\t %% Line 105\n\t\t [{'c_tuple',[{'record_field',105,{'atom',105,'anno'},{'nil',105}}|[{'record_field',105,{'atom',105,'es'}}]]}],\n\t\t%% Line 107\n\t\t'record' =\n\t\t %% Line 107\n\t\t [{'c_values',[{'record_field',107,{'atom',107,'anno'},{'nil',107}}|[{'record_field',107,{'atom',107,'es'}}]]}],\n\t\t%% Line 109\n\t\t'record' =\n\t\t %% Line 109\n\t\t [{'c_var',[{'record_field',109,{'atom',109,'anno'},{'nil',109}}|[{'typed_record_field',{'record_field',109,{'atom',109,'name'}},{'remote_type',109,[{'atom',109,'cerl'}|[{'atom',109,'var_name'}|[[]]]]}}]]}],\n\t\t%% Line 38\n\t\t'file' =\n\t\t %% Line 38\n\t\t [{[115|[114|[99|[47|[99|[111|[109|[112|[105|[108|[101|[46|[101|[114|[108]]]]]]]]]]]]]]],38}],\n\t\t%% Line 44\n\t\t'type' =\n\t\t %% Line 44\n\t\t [{'abstract_code',{'type',44,'list',[{'remote_type',44,[{'atom',44,'erl_parse'}|[{'atom',44,'abstract_form'}|[[]]]]}]},[]}],\n\t\t%% Line 48\n\t\t'type' =\n\t\t %% Line 48\n\t\t [{'forms',{'type',48,'union',[{'user_type',48,'abstract_code',[]}|[{'remote_type',48,[{'atom',48,'cerl'}|[{'atom',48,'c_module'}|[[]]]]}]]},[]}],\n\t\t%% Line 50\n\t\t'type' =\n\t\t %% Line 50\n\t\t [{'option',{'type',50,'union',[{'type',50,'atom',[]}|[{'type',50,'tuple',[{'type',50,'atom',[]}|[{'type',50,'term',[]}]]}|[{'type',50,'tuple',[{'atom',50,'d'}|[{'type',50,'atom',[]}|[{'type',50,'term',[]}]]]}]]]},[]}],\n\t\t%% Line 52\n\t\t'type' =\n\t\t %% Line 52\n\t\t [{'err_info',{'type',52,'tuple',[{'type',52,'union',[{'remote_type',52,[{'atom',52,'erl_anno'}|[{'atom',52,'line'}|[[]]]]}|[{'atom',52,'none'}]]}|[{'type',53,'module',[]}|[{'type',53,'term',[]}]]]},[]}],\n\t\t%% Line 54\n\t\t'type' =\n\t\t %% Line 54\n\t\t [{'errors',{'type',54,'list',[{'type',54,'tuple',[{'remote_type',54,[{'atom',54,'file'}|[{'atom',54,'filename'}|[[]]]]}|[{'type',54,'list',[{'user_type',54,'err_info',[]}]}]]}]},[]}],\n\t\t%% Line 55\n\t\t'type' =\n\t\t %% Line 55\n\t\t [{'warnings',{'type',55,'list',[{'type',55,'tuple',[{'remote_type',55,[{'atom',55,'file'}|[{'atom',55,'filename'}|[[]]]]}|[{'type',55,'list',[{'user_type',55,'err_info',[]}]}]]}]},[]}],\n\t\t%% Line 56\n\t\t'type' =\n\t\t %% Line 56\n\t\t [{'mod_ret',{'type',56,'union',[{'type',56,'tuple',[{'atom',56,'ok'}|[{'type',56,'module',[]}]]}|[{'type',57,'tuple',[{'atom',57,'ok'}|[{'type',57,'module',[]}|[{'remote_type',57,[{'atom',57,'cerl'}|[{'atom',57,'c_module'}|[[]]]]}]]]}|[{'type',58,'tuple',[{'atom',58,'ok'}|[{'type',59,'union',[{'type',59,'module',[]}|[{'type',59,'nil',[]}]]}|[{'user_type',60,'abstract_code',[]}]]]}|[{'type',61,'tuple',[{'atom',61,'ok'}|[{'type',61,'module',[]}|[{'user_type',61,'warnings',[]}]]]}]]]]},[]}],\n\t\t%% Line 62\n\t\t'type' =\n\t\t %% Line 62\n\t\t [{'bin_ret',{'type',62,'union',[{'type',62,'tuple',[{'atom',62,'ok'}|[{'type',62,'module',[]}|[{'type',62,'binary',[]}]]]}|[{'type',63,'tuple',[{'atom',63,'ok'}|[{'type',63,'module',[]}|[{'type',63,'binary',[]}|[{'user_type',63,'warnings',[]}]]]]}]]},[]}],\n\t\t%% Line 64\n\t\t'type' =\n\t\t %% Line 64\n\t\t [{'err_ret',{'type',64,'union',[{'atom',64,'error'}|[{'type',64,'tuple',[{'atom',64,'error'}|[{'user_type',64,'errors',[]}|[{'user_type',64,'warnings',[]}]]]}]]},[]}],\n\t\t%% Line 65\n\t\t'type' =\n\t\t %% Line 65\n\t\t [{'comp_ret',{'type',65,'union',[{'user_type',65,'mod_ret',[]}|[{'user_type',65,'bin_ret',[]}|[{'user_type',65,'err_ret',[]}]]]},[]}],\n\t\t%% Line 80\n\t\t'spec' =\n\t\t %% Line 80\n\t\t [{{'file',1},[{'type',80,'fun',[{'type',80,'product',[{'type',80,'union',[{'type',80,'module',[]}|[{'remote_type',80,[{'atom',80,'file'}|[{'atom',80,'filename'}|[[]]]]}]]}]}|[{'user_type',80,'comp_ret',[]}]]}]}],\n\t\t%% Line 84\n\t\t'spec' =\n\t\t %% Line 84\n\t\t [{{'file',2},[{'type',84,'fun',[{'type',84,'product',[{'type',84,'union',[{'type',84,'module',[]}|[{'remote_type',84,[{'atom',84,'file'}|[{'atom',84,'filename'}|[[]]]]}]]}|[{'type',84,'union',[{'type',84,'list',[{'user_type',84,'option',[]}]}|[{'user_type',84,'option',[]}]]}]]}|[{'user_type',84,'comp_ret',[]}]]}]}],\n\t\t%% Line 91\n\t\t'spec' =\n\t\t %% Line 91\n\t\t [{{'forms',1},[{'type',91,'fun',[{'type',91,'product',[{'user_type',91,'abstract_code',[]}]}|[{'user_type',91,'comp_ret',[]}]]}]}],\n\t\t%% Line 95\n\t\t'spec' =\n\t\t %% Line 95\n\t\t [{{'forms',2},[{'type',95,'fun',[{'type',95,'product',[{'user_type',95,'forms',[]}|[{'type',95,'union',[{'type',95,'list',[{'user_type',95,'option',[]}]}|[{'user_type',95,'option',[]}]]}]]}|[{'user_type',95,'comp_ret',[]}]]}]}],\n\t\t%% Line 106\n\t\t'spec' =\n\t\t %% Line 106\n\t\t [{{'output_generated',1},[{'type',106,'fun',[{'type',106,'product',[{'type',106,'list',[{'user_type',106,'option',[]}]}]}|[{'type',106,'boolean',[]}]]}]}],\n\t\t%% Line 116\n\t\t'spec' =\n\t\t %% Line 116\n\t\t [{{'noenv_file',2},[{'type',116,'fun',[{'type',116,'product',[{'type',116,'union',[{'type',116,'module',[]}|[{'remote_type',116,[{'atom',116,'file'}|[{'atom',116,'filename'}|[[]]]]}]]}|[{'type',116,'union',[{'type',116,'list',[{'user_type',116,'option',[]}]}|[{'user_type',116,'option',[]}]]}]]}|[{'user_type',116,'comp_ret',[]}]]}]}],\n\t\t%% Line 123\n\t\t'spec' =\n\t\t %% Line 123\n\t\t [{{'noenv_forms',2},[{'type',123,'fun',[{'type',123,'product',[{'user_type',123,'forms',[]}|[{'type',123,'union',[{'type',123,'list',[{'user_type',123,'option',[]}]}|[{'user_type',123,'option',[]}]]}]]}|[{'user_type',123,'comp_ret',[]}]]}]}],\n\t\t%% Line 130\n\t\t'spec' =\n\t\t %% Line 130\n\t\t [{{'noenv_output_generated',1},[{'type',130,'fun',[{'type',130,'product',[{'type',130,'list',[{'user_type',130,'option',[]}]}]}|[{'type',130,'boolean',[]}]]}]}],\n\t\t%% Line 142\n\t\t'spec' =\n\t\t %% Line 142\n\t\t [{{'env_compiler_options',0},[{'type',142,'fun',[{'type',142,'product',[]}|[{'type',142,'list',[{'type',142,'term',[]}]}]]}]}],\n\t\t%% Line 240\n\t\t'spec' =\n\t\t %% Line 240\n\t\t [{{'format_error',1},[{'type',240,'fun',[{'type',240,'product',[{'type',240,'term',[]}]}|[{'type',240,'iolist',[]}]]}]}],\n\t\t%% Line 302\n\t\t'type' =\n\t\t %% Line 302\n\t\t [{'err_warn_info',{'type',302,'tuple','any'},[]}],\n\t\t%% Line 305\n\t\t'record' =\n\t\t %% Line 305\n\t\t [{'compile',[{'typed_record_field',{'record_field',305,{'atom',305,'filename'},{'string',305,[]}},{'remote_type',305,[{'atom',305,'file'}|[{'atom',305,'filename'}|[[]]]]}}|[{'typed_record_field',{'record_field',306,{'atom',306,'dir'},{'string',306,[]}},{'remote_type',306,[{'atom',306,'file'}|[{'atom',306,'filename'}|[[]]]]}}|[{'typed_record_field',{'record_field',307,{'atom',307,'base'},{'string',307,[]}},{'remote_type',307,[{'atom',307,'file'}|[{'atom',307,'filename'}|[[]]]]}}|[{'typed_record_field',{'record_field',308,{'atom',308,'ifile'},{'string',308,[]}},{'remote_type',308,[{'atom',308,'file'}|[{'atom',308,'filename'}|[[]]]]}}|[{'typed_record_field',{'record_field',309,{'atom',309,'ofile'},{'string',309,[]}},{'remote_type',309,[{'atom',309,'file'}|[{'atom',309,'filename'}|[[]]]]}}|[{'typed_record_field',{'record_field',310,{'atom',310,'module'},{'nil',310}},{'type',310,'union',[{'type',310,'module',[]}|[{'type',310,'nil',[]}]]}}|[{'typed_record_field',{'record_field',311,{'atom',311,'core_code'},{'nil',311}},{'type',311,'union',[{'remote_type',311,[{'atom',311,'cerl'}|[{'atom',311,'c_module'}|[[]]]]}|[{'type',311,'nil',[]}]]}}|[{'typed_record_field',{'record_field',312,{'atom',312,'abstract_code'},{'nil',312}},{'user_type',312,'abstract_code',[]}}|[{'typed_record_field',{'record_field',313,{'atom',313,'options'},{'nil',313}},{'type',313,'list',[{'user_type',313,'option',[]}]}}|[{'typed_record_field',{'record_field',314,{'atom',314,'mod_options'},{'nil',314}},{'type',314,'list',[{'user_type',314,'option',[]}]}}|[{'typed_record_field',{'record_field',315,{'atom',315,'encoding'},{'atom',315,'none'}},{'type',315,'union',[{'atom',315,'none'}|[{'remote_type',315,[{'atom',315,'epp'}|[{'atom',315,'source_encoding'}|[[]]]]}]]}}|[{'typed_record_field',{'record_field',316,{'atom',316,'errors'},{'nil',316}},{'type',316,'list',[{'user_type',316,'err_warn_info',[]}]}}|[{'typed_record_field',{'record_field',317,{'atom',317,'warnings'},{'nil',317}},{'type',317,'list',[{'user_type',317,'err_warn_info',[]}]}}|[{'typed_record_field',{'record_field',318,{'atom',318,'extra_chunks'},{'nil',318}},{'type',318,'list',[{'type',318,'tuple',[{'type',318,'binary',[]}|[{'type',318,'binary',[]}]]}]}}]]]]]]]]]]]]]]}],\n\t\t%% Line 814\n\t\t'record' =\n\t\t %% Line 814\n\t\t [{'asm_module',[{'record_field',814,{'atom',814,'module'}}|[{'record_field',815,{'atom',815,'exports'}}|[{'record_field',816,{'atom',816,'labels'}}|[{'record_field',817,{'atom',817,'functions'},{'nil',817}}|[{'record_field',818,{'atom',818,'cfun'}}|[{'record_field',819,{'atom',819,'code'}}|[{'record_field',820,{'atom',820,'attributes'},{'nil',820}}]]]]]]]}],\n\t\t%% Line 1721\n\t\t'spec' =\n\t\t %% Line 1721\n\t\t [{{'iofile',1},[{'type',1721,'fun',[{'type',1721,'product',[{'type',1721,'union',[{'type',1721,'atom',[]}|[{'remote_type',1721,[{'atom',1721,'file'}|[{'atom',1721,'filename_all'}|[[]]]]}]]}]}|[{'type',1722,'tuple',[{'remote_type',1722,[{'atom',1722,'file'}|[{'atom',1722,'name_all'}|[[]]]]}|[{'remote_type',1722,[{'atom',1722,'file'}|[{'atom',1722,'name_all'}|[[]]]]}]]}]]}]}],\n\t\t%% Line 1833\n\t\t'spec' =\n\t\t %% Line 1833\n\t\t [{{'options',0},[{'type',1833,'fun',[{'type',1833,'product',[]}|[{'atom',1833,'ok'}]]}]}],\n\t\t%% Line 1873\n\t\t'spec' =\n\t\t %% Line 1873\n\t\t [{{'compile',3},[{'type',1873,'fun',[{'type',1873,'product',[{'remote_type',1873,[{'atom',1873,'file'}|[{'atom',1873,'filename'}|[[]]]]}|[{'var',1873,'_'}|[{'type',1873,'record',[{'atom',1873,'options'}]}]]]}|[{'type',1873,'union',[{'atom',1873,'ok'}|[{'atom',1873,'error'}]]}]]}]}],\n\t\t%% Line 1883\n\t\t'spec' =\n\t\t %% Line 1883\n\t\t [{{'compile_beam',3},[{'type',1883,'fun',[{'type',1883,'product',[{'remote_type',1883,[{'atom',1883,'file'}|[{'atom',1883,'filename'}|[[]]]]}|[{'var',1883,'_'}|[{'type',1883,'record',[{'atom',1883,'options'}]}]]]}|[{'type',1883,'union',[{'atom',1883,'ok'}|[{'atom',1883,'error'}]]}]]}]}],\n\t\t%% Line 1892\n\t\t'spec' =\n\t\t %% Line 1892\n\t\t [{{'compile_asm',3},[{'type',1892,'fun',[{'type',1892,'product',[{'remote_type',1892,[{'atom',1892,'file'}|[{'atom',1892,'filename'}|[[]]]]}|[{'var',1892,'_'}|[{'type',1892,'record',[{'atom',1892,'options'}]}]]]}|[{'type',1892,'union',[{'atom',1892,'ok'}|[{'atom',1892,'error'}]]}]]}]}],\n\t\t%% Line 1901\n\t\t'spec' =\n\t\t %% Line 1901\n\t\t [{{'compile_core',3},[{'type',1901,'fun',[{'type',1901,'product',[{'remote_type',1901,[{'atom',1901,'file'}|[{'atom',1901,'filename'}|[[]]]]}|[{'var',1901,'_'}|[{'type',1901,'record',[{'atom',1901,'options'}]}]]]}|[{'type',1901,'union',[{'atom',1901,'ok'}|[{'atom',1901,'error'}]]}]]}]}]]\n'file'/1 =\n %% Line 82\n fun (_0) ->\n\tapply 'file'/2\n\t (_0, ['verbose'|['report_errors'|['report_warnings']]])\n'file'/2 =\n %% Line 86\n fun (_1,_0) ->\n\tcase <_1,_0> of\n\t \n\t when call 'erlang':'is_list'\n\t\t (Opts) ->\n\t let <_2> =\n\t\t apply %% Line 87\n\t\t\t'env_default_opts'/0\n\t\t ()\n\t in let <_3> =\n\t\t call %% Line 87\n\t\t\t 'erlang':%% Line 87\n\t\t\t\t '++'\n\t\t\t (%% Line 87\n\t\t\t Opts, _2)\n\t\t in %% Line 87\n\t\t apply 'do_compile'/2\n\t\t\t ({'file',File}, _3)\n\t %% Line 88\n\t when 'true' ->\n\t %% Line 89\n\t apply 'file'/2\n\t\t (File, [Opt|['verbose'|['report_errors'|['report_warnings']]]])\n\tend\n'forms'/1 =\n %% Line 93\n fun (_0) ->\n\tapply 'forms'/2\n\t (_0, ['verbose'|['report_errors'|['report_warnings']]])\n'forms'/2 =\n %% Line 97\n fun (_1,_0) ->\n\tcase <_1,_0> of\n\t \n\t when call 'erlang':'is_list'\n\t\t (Opts) ->\n\t let <_2> =\n\t\t apply %% Line 98\n\t\t\t'env_default_opts'/0\n\t\t ()\n\t in let <_3> =\n\t\t call %% Line 98\n\t\t\t 'erlang':%% Line 98\n\t\t\t\t '++'\n\t\t\t (%% Line 98\n\t\t\t Opts, _2)\n\t\t in %% Line 98\n\t\t apply 'do_compile'/2\n\t\t\t ({'forms',Forms}, ['binary'|_3])\n\t %% Line 99\n\t \n\t when call 'erlang':'is_atom'\n\t\t (Opt) ->\n\t %% Line 100\n\t apply 'forms'/2\n\t\t (Forms, [Opt|['verbose'|['report_errors'|['report_warnings']]]])\n\t ( <_5,_4> when 'true' ->\n\t\t( primop 'match_fail'\n\t\t ({'function_clause',_5,_4})\n\t\t -| [{'function_name',{'forms',2}}] )\n\t -| ['compiler_generated'] )\n\tend\n'output_generated'/1 =\n %% Line 108\n fun (_0) ->\n\tlet <_1> =\n\t apply %% Line 109\n\t\t 'env_default_opts'/0\n\t\t()\n\tin let <_2> =\n\t\tcall %% Line 109\n\t\t 'erlang':%% Line 109\n\t\t\t '++'\n\t\t (_0, _1)\n\t in %% Line 109\n\t\tapply 'noenv_output_generated'/1\n\t\t (_2)\n'noenv_file'/2 =\n %% Line 118\n fun (_1,_0) ->\n\tcase <_1,_0> of\n\t \n\t when call 'erlang':'is_list'\n\t\t (Opts) ->\n\t %% Line 119\n\t apply 'do_compile'/2\n\t\t ({'file',File}, Opts)\n\t %% Line 120\n\t when 'true' ->\n\t %% Line 121\n\t apply 'noenv_file'/2\n\t\t (File, [Opt|['verbose'|['report_errors'|['report_warnings']]]])\n\tend\n'noenv_forms'/2 =\n %% Line 125\n fun (_1,_0) ->\n\tcase <_1,_0> of\n\t \n\t when call 'erlang':'is_list'\n\t\t (Opts) ->\n\t %% Line 126\n\t apply 'do_compile'/2\n\t\t ({'forms',Forms}, ['binary'|Opts])\n\t %% Line 127\n\t \n\t when call 'erlang':'is_atom'\n\t\t (Opt) ->\n\t %% Line 128\n\t apply 'noenv_forms'/2\n\t\t (Forms, [Opt|['verbose'|['report_errors'|['report_warnings']]]])\n\t ( <_3,_2> when 'true' ->\n\t\t( primop 'match_fail'\n\t\t ({'function_clause',_3,_2})\n\t\t -| [{'function_name',{'noenv_forms',2}}] )\n\t -| ['compiler_generated'] )\n\tend\n'noenv_output_generated'/1 =\n %% Line 132\n fun (_0) ->\n\tlet <_1> =\n\t apply %% Line 133\n\t\t 'expand_opts'/1\n\t\t(_0)\n\tin %% Line 133\n\t case apply 'passes'/2\n\t\t ('file', _1) of\n\t <{_7,Passes}> when 'true' ->\n\t\t let <_5> =\n\t\t fun (_3) ->\n\t\t\t %% Line 134\n\t\t\t case _3 of\n\t\t\t <{'save_binary',_X_T,_X_F}> when 'true' ->\n\t\t\t\t'true'\n\t\t\t %% Line 135\n\t\t\t <_X_Other> when 'true' ->\n\t\t\t\t'false'\n\t\t\t end\n\t\t in %% Line 134\n\t\t call 'lists':'any'\n\t\t\t (_5, %% Line 136\n\t\t\t Passes)\n\t ( <_2> when 'true' ->\n\t\t primop 'match_fail'\n\t\t\t({'badmatch',_2})\n\t\t-| ['compiler_generated'] )\n\t end\n'env_compiler_options'/0 =\n %% Line 144\n fun () ->\n\tapply 'env_default_opts'/0\n\t ()\n'env_default_opts'/0 =\n %% Line 153\n fun () ->\n\t%% Line 155\n\tcase call 'os':'getenv'\n\t\t ([69|[82|[76|[95|[67|[79|[77|[80|[73|[76|[69|[82|[95|[79|[80|[84|[73|[79|[78|[83]]]]]]]]]]]]]]]]]]]]) of\n\t %% Line 156\n\t <'false'> when 'true' ->\n\t []\n\t %% Line 157\n\t \n\t when call 'erlang':'is_list'\n\t\t (Str) ->\n\t %% Line 158\n\t case call 'erl_scan':'string'\n\t\t (Str) of\n\t\t%% Line 159\n\t\t<{'ok',Tokens,_7}> when 'true' ->\n\t\t let <_1> =\n\t\t\tcall %% Line 160\n\t\t\t 'erl_anno':%% Line 160\n\t\t\t\t\t'new'\n\t\t\t (%% Line 160\n\t\t\t 1)\n\t\t in let = {%% Line 160\n\t\t\t 'dot',_1}\n\t\t\tin let <_3> =\n\t\t\t\tcall %% Line 161\n\t\t\t\t 'erlang':%% Line 161\n\t\t\t\t\t '++'\n\t\t\t\t (%% Line 161\n\t\t\t\t Tokens, %% Line 161\n\t\t\t\t\t [Dot|[]])\n\t\t\t in %% Line 161\n\t\t\t\tcase call 'erl_parse':'parse_term'\n\t\t\t\t\t (_3) of\n\t\t\t\t %% Line 162\n\t\t\t\t <{'ok',List}>\n\t\t\t\t when call 'erlang':'is_list'\n\t\t\t\t\t (List) ->\n\t\t\t\t List\n\t\t\t\t %% Line 163\n\t\t\t\t <{'ok',Term}> when 'true' ->\n\t\t\t\t [Term|[]]\n\t\t\t\t %% Line 164\n\t\t\t\t <{'error',_X_Reason}> when 'true' ->\n\t\t\t\t do %% Line 165\n\t\t\t\t\t call 'io':'format'\n\t\t\t\t\t ([73|[103|[110|[111|[114|[105|[110|[103|[32|[98|[97|[100|[32|[116|[101|[114|[109|[32|[105|[110|[32|[126|[115|[10]]]]]]]]]]]]]]]]]]]]]]]], [[69|[82|[76|[95|[67|[79|[77|[80|[73|[76|[69|[82|[95|[79|[80|[84|[73|[79|[78|[83]]]]]]]]]]]]]]]]]]]]])\n\t\t\t\t\t %% Line 166\n\t\t\t\t\t []\n\t\t\t\t ( <_4> when 'true' ->\n\t\t\t\t\tprimop 'match_fail'\n\t\t\t\t\t ({'case_clause',_4})\n\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\tend\n\t\t%% Line 168\n\t\t<{'error',{_8,_9,_X_Reason},_10}> when 'true' ->\n\t\t do %% Line 169\n\t\t\tcall 'io':'format'\n\t\t\t ([73|[103|[110|[111|[114|[105|[110|[103|[32|[98|[97|[100|[32|[116|[101|[114|[109|[32|[105|[110|[32|[126|[115|[10]]]]]]]]]]]]]]]]]]]]]]]], [[69|[82|[76|[95|[67|[79|[77|[80|[73|[76|[69|[82|[95|[79|[80|[84|[73|[79|[78|[83]]]]]]]]]]]]]]]]]]]]])\n\t\t\t%% Line 170\n\t\t\t[]\n\t\t( <_5> when 'true' ->\n\t\t primop 'match_fail'\n\t\t\t ({'case_clause',_5})\n\t\t -| ['compiler_generated'] )\n\t end\n\t ( <_6> when 'true' ->\n\t\tprimop 'match_fail'\n\t\t ({'case_clause',_6})\n\t -| ['compiler_generated'] )\n\tend\n'do_compile'/2 =\n %% Line 174\n fun (_1,_0) ->\n\tlet =\n\t apply %% Line 175\n\t\t 'expand_opts'/1\n\t\t(_0)\n\tin let =\n\t\tfun () ->\n\t\t %% Line 176\n\t\t try\n\t\t\t%% Line 177\n\t\t\tapply 'internal'/2\n\t\t\t (_1, Opts)\n\t\t of <_3> ->\n\t\t\t_3\n\t\t catch <_6,_5,_4> ->\n\t\t\t%% Line 179\n\t\t\tcase <_6,_5,_4> of\n\t\t\t <( 'error'\n\t\t\t -| ['compiler_generated'] ),Reason,_14> when 'true' ->\n\t\t\t %% Line 180\n\t\t\t {'error',Reason}\n\t\t\t ( <_19,_20,_21> when 'true' ->\n\t\t\t\tprimop 'raise'\n\t\t\t\t (_21, _20)\n\t\t\t -| ['compiler_generated'] )\n\t\t\tend\n\t in %% Line 184\n\t\tcase call 'lists':'member'\n\t\t\t ('dialyzer', Opts) of\n\t\t %% Line 185\n\t\t <'true'> when 'true' ->\n\t\t %% Line 186\n\t\t apply IntFun\n\t\t\t ()\n\t\t %% Line 187\n\t\t <'false'> when 'true' ->\n\t\t let <_9> =\n\t\t\t fun () ->\n\t\t\t let <_8> =\n\t\t\t\t apply %% Line 190\n\t\t\t\t\tIntFun\n\t\t\t\t ()\n\t\t\t in %% Line 190\n\t\t\t\t call 'erlang':'exit'\n\t\t\t\t (_8)\n\t\t in %% Line 188\n\t\t\t case %% Line 189\n\t\t\t call 'erlang':'spawn_monitor'\n\t\t\t\t (_9) of\n\t\t\t <{Pid,Ref}> when 'true' ->\n\t\t\t\t%% Line 192\n\t\t\t\treceive\n\t\t\t\t %% Line 193\n\t\t\t\t <{'DOWN',_15,'process',_16,Rep}>\n\t\t\t\t when let <_17> =\n\t\t\t\t\t call 'erlang':'=:='\n\t\t\t\t\t\t(_15, Ref)\n\t\t\t\t\tin let <_18> =\n\t\t\t\t\t\tcall 'erlang':'=:='\n\t\t\t\t\t\t (_16, Pid)\n\t\t\t\t\t in call 'erlang':'and'\n\t\t\t\t\t\t (_17, _18) ->\n\t\t\t\t Rep\n\t\t\t\tafter 'infinity' ->\n\t\t\t\t 'true'\n\t\t\t ( <_10> when 'true' ->\n\t\t\t\t primop 'match_fail'\n\t\t\t\t ({'badmatch',_10})\n\t\t\t -| ['compiler_generated'] )\n\t\t\t end\n\t\t ( <_11> when 'true' ->\n\t\t\tprimop 'match_fail'\n\t\t\t ({'case_clause',_11})\n\t\t -| ['compiler_generated'] )\n\t\tend\n'expand_opts'/1 =\n %% Line 197\n fun (_0) ->\n\tlet <_3> =\n\t call %% Line 199\n\t\t 'proplists':%% Line 199\n\t\t\t 'get_value'\n\t\t(%% Line 199\n\t\t 'debug_info_key', _0)\n\tin let <_2> =\n\t\tcall %% Line 200\n\t\t 'proplists':%% Line 200\n\t\t\t\t 'get_value'\n\t\t (%% Line 200\n\t\t 'encrypt_debug_info', _0)\n\t in let <_1> =\n\t\t call %% Line 201\n\t\t\t 'proplists':%% Line 201\n\t\t\t\t 'get_value'\n\t\t\t(%% Line 201\n\t\t\t 'debug_info', _0)\n\t\tin let <_5> =\n\t\t\tcase <_3,_2,_1> of\n\t\t\t %% Line 202\n\t\t\t <( 'undefined'\n\t\t\t -| ['compiler_generated'] ),( 'undefined'\n\t\t\t\t\t\t\t -| ['compiler_generated'] ),_11> when 'true' ->\n\t\t\t _0\n\t\t\t %% Line 203\n\t\t\t <_12,_13,( 'undefined'\n\t\t\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\t ['debug_info'|_0]\n\t\t\t %% Line 204\n\t\t\t <_14,_15,_16> when 'true' ->\n\t\t\t _0\n\t\t\tend\n\t\t in let <_8> =\n\t\t\t case %% Line 207\n\t\t\t\t call 'proplists':'is_defined'\n\t\t\t\t ('makedep_side_effect', _5) of\n\t\t\t %% Line 208\n\t\t\t <'true'> when 'true' ->\n\t\t\t\t call 'proplists':'delete'\n\t\t\t\t ('makedep', _5)\n\t\t\t %% Line 209\n\t\t\t <'false'> when 'true' ->\n\t\t\t\t _5\n\t\t\t ( <_7> when 'true' ->\n\t\t\t\t %% Line 207\n\t\t\t\t primop 'match_fail'\n\t\t\t\t\t({'case_clause',_7})\n\t\t\t\t-| ['compiler_generated'] )\n\t\t\t end\n\t\t\tin %% Line 211\n\t\t\t call 'lists':'foldr'\n\t\t\t\t(( 'expand_opt'/2\n\t\t\t\t -| [{'id',{0,0,'-expand_opts/1-fun-0-'}}] ), [], _8)\n'expand_opt'/2 =\n %% Line 213\n fun (_1,_0) ->\n\tcase <_1,_0> of\n\t <'basic_validation',Os> when 'true' ->\n\t %% Line 214\n\t ['no_code_generation'|['to_pp'|['binary'|Os]]]\n\t %% Line 215\n\t <'strong_validation',Os> when 'true' ->\n\t %% Line 216\n\t ['no_code_generation'|['to_kernel'|['binary'|Os]]]\n\t %% Line 217\n\t <'report',Os> when 'true' ->\n\t %% Line 218\n\t ['report_errors'|['report_warnings'|Os]]\n\t %% Line 219\n\t <'return',Os> when 'true' ->\n\t %% Line 220\n\t ['return_errors'|['return_warnings'|Os]]\n\t %% Line 221\n\t <'r16',Os> when 'true' ->\n\t %% Line 222\n\t ['no_get_hd_tl'|['no_record_opt'|['no_utf8_atoms'|Os]]]\n\t %% Line 223\n\t <'r17',Os> when 'true' ->\n\t %% Line 224\n\t ['no_get_hd_tl'|['no_record_opt'|['no_utf8_atoms'|Os]]]\n\t %% Line 225\n\t <'r18',Os> when 'true' ->\n\t %% Line 226\n\t ['no_get_hd_tl'|['no_record_opt'|['no_utf8_atoms'|Os]]]\n\t %% Line 227\n\t <'r19',Os> when 'true' ->\n\t %% Line 228\n\t ['no_get_hd_tl'|['no_record_opt'|['no_utf8_atoms'|Os]]]\n\t %% Line 229\n\t <'r20',Os> when 'true' ->\n\t %% Line 230\n\t ['no_get_hd_tl'|['no_record_opt'|['no_utf8_atoms'|Os]]]\n\t %% Line 231\n\t when 'true' ->\n\t %% Line 232\n\t ['encrypt_debug_info'|[O|Os]]\n\t %% Line 233\n\t <'no_float_opt',Os> when 'true' ->\n\t %% Line 235\n\t ['no_topt'|Os]\n\t %% Line 236\n\t when 'true' ->\n\t [O|Os]\n\tend\n'format_error'/1 =\n %% Line 242\n fun (_0) ->\n\tcase _0 of\n\t <'no_native_support'> when 'true' ->\n\t %% Line 243\n\t [116|[104|[105|[115|[32|[115|[121|[115|[116|[101|[109|[32|[105|[115|[32|[110|[111|[116|[32|[99|[111|[110|[102|[105|[103|[117|[114|[101|[100|[32|[102|[111|[114|[32|[110|[97|[116|[105|[118|[101|[45|[99|[111|[100|[101|[32|[99|[111|[109|[112|[105|[108|[97|[116|[105|[111|[110|[46]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]\n\t %% Line 244\n\t <'no_crypto'> when 'true' ->\n\t %% Line 245\n\t [116|[104|[105|[115|[32|[115|[121|[115|[116|[101|[109|[32|[105|[115|[32|[110|[111|[116|[32|[99|[111|[110|[102|[105|[103|[117|[114|[101|[100|[32|[119|[105|[116|[104|[32|[99|[114|[121|[112|[116|[111|[32|[115|[117|[112|[112|[111|[114|[116|[46]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]\n\t %% Line 246\n\t <'bad_crypto_key'> when 'true' ->\n\t %% Line 247\n\t [105|[110|[118|[97|[108|[105|[100|[32|[99|[114|[121|[112|[116|[111|[32|[107|[101|[121|[46]]]]]]]]]]]]]]]]]]]\n\t %% Line 248\n\t <'no_crypto_key'> when 'true' ->\n\t %% Line 249\n\t [110|[111|[32|[99|[114|[121|[112|[116|[111|[32|[107|[101|[121|[32|[115|[117|[112|[112|[108|[105|[101|[100|[46]]]]]]]]]]]]]]]]]]]]]]]\n\t %% Line 250\n\t <{'native',E}> when 'true' ->\n\t %% Line 251\n\t call 'io_lib':'fwrite'\n\t\t ([110|[97|[116|[105|[118|[101|[45|[99|[111|[100|[101|[32|[99|[111|[109|[112|[105|[108|[97|[116|[105|[111|[110|[32|[102|[97|[105|[108|[101|[100|[32|[119|[105|[116|[104|[32|[114|[101|[97|[115|[111|[110|[58|[32|[126|[116|[80|[46]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]], %% Line 252\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t [E|[25]])\n\t %% Line 253\n\t <{'native_crash',E,Stk}> when 'true' ->\n\t %% Line 254\n\t call 'io_lib':'fwrite'\n\t\t ([110|[97|[116|[105|[118|[101|[45|[99|[111|[100|[101|[32|[99|[111|[109|[112|[105|[108|[97|[116|[105|[111|[110|[32|[99|[114|[97|[115|[104|[101|[100|[32|[119|[105|[116|[104|[32|[114|[101|[97|[115|[111|[110|[58|[32|[126|[116|[80|[46|[10|[126|[116|[80|[10]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]], %% Line 255\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t [E|[25|[Stk|[25]]]])\n\t %% Line 256\n\t <{'open',E}> when 'true' ->\n\t let <_1> =\n\t\t call %% Line 257\n\t\t 'file':%% Line 257\n\t\t\t 'format_error'\n\t\t (%% Line 257\n\t\t E)\n\t in %% Line 257\n\t\t call 'io_lib':'format'\n\t\t ([111|[112|[101|[110|[32|[101|[114|[114|[111|[114|[32|[39|[126|[116|[115|[39]]]]]]]]]]]]]]]], [_1|[]])\n\t %% Line 258\n\t <{'epp',E}> when 'true' ->\n\t %% Line 259\n\t call 'epp':'format_error'\n\t\t (E)\n\t %% Line 260\n\t <'write_error'> when 'true' ->\n\t %% Line 261\n\t [101|[114|[114|[111|[114|[32|[119|[114|[105|[116|[105|[110|[103|[32|[102|[105|[108|[101]]]]]]]]]]]]]]]]]]\n\t %% Line 262\n\t <{'write_error',Error}> when 'true' ->\n\t let <_2> =\n\t\t call %% Line 263\n\t\t 'file':%% Line 263\n\t\t\t 'format_error'\n\t\t (%% Line 263\n\t\t Error)\n\t in %% Line 263\n\t\t call 'io_lib':'format'\n\t\t ([101|[114|[114|[111|[114|[32|[119|[114|[105|[116|[105|[110|[103|[32|[102|[105|[108|[101|[58|[32|[126|[116|[115]]]]]]]]]]]]]]]]]]]]]]], [_2|[]])\n\t %% Line 264\n\t <{'rename',From,To,Error}> when 'true' ->\n\t let <_3> =\n\t\t call %% Line 266\n\t\t 'file':%% Line 266\n\t\t\t 'format_error'\n\t\t (%% Line 266\n\t\t Error)\n\t in %% Line 265\n\t\t call 'io_lib':'format'\n\t\t ([102|[97|[105|[108|[101|[100|[32|[116|[111|[32|[114|[101|[110|[97|[109|[101|[32|[126|[116|[115|[32|[116|[111|[32|[126|[116|[115|[58|[32|[126|[116|[115]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]], %% Line 266\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t [From|[To|[_3|[]]]])\n\t %% Line 267\n\t <{'delete',File,Error}> when 'true' ->\n\t let <_4> =\n\t\t call %% Line 269\n\t\t 'file':%% Line 269\n\t\t\t 'format_error'\n\t\t (%% Line 269\n\t\t Error)\n\t in %% Line 268\n\t\t call 'io_lib':'format'\n\t\t ([102|[97|[105|[108|[101|[100|[32|[116|[111|[32|[100|[101|[108|[101|[116|[101|[32|[102|[105|[108|[101|[32|[126|[116|[115|[58|[32|[126|[116|[115]]]]]]]]]]]]]]]]]]]]]]]]]]]]]], %% Line 269\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t [File|[_4|[]]])\n\t %% Line 270\n\t <{'delete_temp',File,Error}> when 'true' ->\n\t let <_5> =\n\t\t call %% Line 272\n\t\t 'file':%% Line 272\n\t\t\t 'format_error'\n\t\t (%% Line 272\n\t\t Error)\n\t in %% Line 271\n\t\t call 'io_lib':'format'\n\t\t ([102|[97|[105|[108|[101|[100|[32|[116|[111|[32|[100|[101|[108|[101|[116|[101|[32|[116|[101|[109|[112|[111|[114|[97|[114|[121|[32|[102|[105|[108|[101|[32|[126|[116|[115|[58|[32|[126|[116|[115]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]], %% Line 272\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t [File|[_5|[]]])\n\t %% Line 273\n\t <{'parse_transform',M,R}> when 'true' ->\n\t %% Line 274\n\t call 'io_lib':'format'\n\t\t ([101|[114|[114|[111|[114|[32|[105|[110|[32|[112|[97|[114|[115|[101|[32|[116|[114|[97|[110|[115|[102|[111|[114|[109|[32|[39|[126|[116|[115|[39|[58|[32|[126|[116|[112]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]], [M|[R|[]]])\n\t %% Line 275\n\t <{'undef_parse_transform',M}> when 'true' ->\n\t %% Line 276\n\t call 'io_lib':'format'\n\t\t ([117|[110|[100|[101|[102|[105|[110|[101|[100|[32|[112|[97|[114|[115|[101|[32|[116|[114|[97|[110|[115|[102|[111|[114|[109|[32|[39|[126|[116|[115|[39]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]], [M|[]])\n\t %% Line 277\n\t <{'core_transform',M,R}> when 'true' ->\n\t %% Line 278\n\t call 'io_lib':'format'\n\t\t ([101|[114|[114|[111|[114|[32|[105|[110|[32|[99|[111|[114|[101|[32|[116|[114|[97|[110|[115|[102|[111|[114|[109|[32|[39|[126|[115|[39|[58|[32|[126|[116|[112]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]], [M|[R|[]]])\n\t %% Line 279\n\t <{'crash',Pass,Reason}> when 'true' ->\n\t let <_6> =\n\t\t apply %% Line 280\n\t\t\t'format_error_reason'/1\n\t\t (%% Line 280\n\t\t Reason)\n\t in %% Line 280\n\t\t call 'io_lib':'format'\n\t\t ([105|[110|[116|[101|[114|[110|[97|[108|[32|[101|[114|[114|[111|[114|[32|[105|[110|[32|[126|[112|[59|[10|[99|[114|[97|[115|[104|[32|[114|[101|[97|[115|[111|[110|[58|[32|[126|[116|[115]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]], [Pass|[_6|[]]])\n\t %% Line 281\n\t <{'bad_return',Pass,Reason}> when 'true' ->\n\t let <_7> =\n\t\t apply %% Line 282\n\t\t\t'format_error_reason'/1\n\t\t (%% Line 282\n\t\t Reason)\n\t in %% Line 282\n\t\t call 'io_lib':'format'\n\t\t ([105|[110|[116|[101|[114|[110|[97|[108|[32|[101|[114|[114|[111|[114|[32|[105|[110|[32|[126|[112|[59|[10|[98|[97|[100|[32|[114|[101|[116|[117|[114|[110|[32|[118|[97|[108|[117|[101|[58|[32|[126|[116|[115]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]], [Pass|[_7|[]]])\n\t %% Line 283\n\t <{'module_name',Mod,Filename}> when 'true' ->\n\t %% Line 284\n\t call 'io_lib':'format'\n\t\t ([77|[111|[100|[117|[108|[101|[32|[110|[97|[109|[101|[32|[39|[126|[115|[39|[32|[100|[111|[101|[115|[32|[110|[111|[116|[32|[109|[97|[116|[99|[104|[32|[102|[105|[108|[101|[32|[110|[97|[109|[101|[32|[39|[126|[116|[115|[39]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]], [Mod|[Filename|[]]])\n\t %% Line 285\n\t <'reparsing_invalid_unicode'> when 'true' ->\n\t %% Line 286\n\t [78|[111|[110|[45|[85|[84|[70|[45|[56|[32|[99|[104|[97|[114|[97|[99|[116|[101|[114|[40|[115|[41|[32|[100|[101|[116|[101|[99|[116|[101|[100|[44|[32|[98|[117|[116|[32|[110|[111|[32|[101|[110|[99|[111|[100|[105|[110|[103|[32|[100|[101|[99|[108|[97|[114|[101|[100|[46|[32|[69|[110|[99|[111|[100|[101|[32|[116|[104|[101|[32|[102|[105|[108|[101|[32|[105|[110|[32|[85|[84|[70|[45|[56|[32|[111|[114|[32|[97|[100|[100|[32|[34|[37|[37|[32|[99|[111|[100|[105|[110|[103|[58|[32|[108|[97|[116|[105|[110|[45|[49|[34|[32|[97|[116|[32|[116|[104|[101|[32|[98|[101|[103|[105|[110|[110|[105|[110|[103|[32|[111|[102|[32|[116|[104|[101|[32|[102|[105|[108|[101|[46|[32|[82|[101|[116|[114|[121|[105|[110|[103|[32|[119|[105|[116|[104|[32|[108|[97|[116|[105|[110|[45|[49|[32|[101|[110|[99|[111|[100|[105|[110|[103|[46]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]\n\t ( <_8> when 'true' ->\n\t\t( primop 'match_fail'\n\t\t ({'function_clause',_8})\n\t\t -| [{'function_name',{'format_error',1}}] )\n\t -| ['compiler_generated'] )\n\tend\n'format_error_reason'/1 =\n %% Line 288\n fun (_0) ->\n\tcase _0 of\n\t <{Reason,Stack}>\n\t when call 'erlang':'is_list'\n\t\t (Stack) ->\n\t let =\n\t\t fun (_3,_2,_1) ->\n\t\t %% Line 289\n\t\t case <_3,_2,_1> of\n\t\t\t%% Line 290\n\t\t\t<'escript','run',2> when 'true' ->\n\t\t\t 'true'\n\t\t\t%% Line 291\n\t\t\t<'escript','start',1> when 'true' ->\n\t\t\t 'true'\n\t\t\t%% Line 292\n\t\t\t<'init','start_it',1> when 'true' ->\n\t\t\t 'true'\n\t\t\t%% Line 293\n\t\t\t<'init','start_em',1> when 'true' ->\n\t\t\t 'true'\n\t\t\t%% Line 294\n\t\t\t<_X_Mod,_X_Fun,_X_Arity> when 'true' ->\n\t\t\t 'false'\n\t\t end\n\t in let =\n\t\t fun (_9,_8) ->\n\t\t\t %% Line 296\n\t\t\t call 'io_lib':'format'\n\t\t\t ([126|[116|[112]]], [_9|[]])\n\t\t in let <_13> =\n\t\t\t call %% Line 297\n\t\t\t 'io_lib':%% Line 297\n\t\t\t\t\t'format'\n\t\t\t (%% Line 297\n\t\t\t [126|[116|[112]]], %% Line 297\n\t\t\t\t\t\t [Reason|[]])\n\t\t in let <_14> =\n\t\t\t call %% Line 298\n\t\t\t\t 'erl_error':%% Line 298\n\t\t\t\t\t 'format_stacktrace'\n\t\t\t\t (%% Line 298\n\t\t\t\t 1, %% Line 298\n\t\t\t\t Stack, %% Line 298\n\t\t\t\t\t StackFun, %% Line 298\n\t\t\t\t\t\t FormatFun)\n\t\t\t in %% Line 297\n\t\t\t [_13|[[10|[10]]|%% Line 298\n\t\t\t\t\t [_14|[]]]]\n\t %% Line 299\n\t when 'true' ->\n\t %% Line 300\n\t call 'io_lib':'format'\n\t\t ([126|[116|[112]]], [Reason|[]])\n\tend\n'internal'/2 =\n %% Line 320\n fun (_1,_0) ->\n\tcase <_1,_0> of\n\t <{'forms',Forms},Opts0> when 'true' ->\n\t %% Line 321\n\t case apply 'passes'/2\n\t\t ('forms', Opts0) of\n\t\t<{_10,Ps}> when 'true' ->\n\t\t let =\n\t\t\tcall %% Line 322\n\t\t\t 'proplists':%% Line 322\n\t\t\t\t\t 'get_value'\n\t\t\t (%% Line 322\n\t\t\t 'source', %% Line 322\n\t\t\t\t Opts0, %% Line 322\n\t\t\t\t\t [])\n\t\t in let =\n\t\t\t call %% Line 323\n\t\t\t\t 'proplists':%% Line 323\n\t\t\t\t\t 'delete'\n\t\t\t\t(%% Line 323\n\t\t\t\t 'source', %% Line 323\n\t\t\t\t\t Opts0)\n\t\t\tin let =\n\t\t\t\tapply %% Line 324\n\t\t\t\t 'build_compile'/1\n\t\t\t\t (%% Line 324\n\t\t\t\t Opts1)\n\t\t\t in %% Line 325\n\t\t\t\tapply 'internal_comp'/5\n\t\t\t\t (Ps, Forms, Source, [], Compile)\n\t\t( <_2> when 'true' ->\n\t\t primop 'match_fail'\n\t\t\t ({'badmatch',_2})\n\t\t -| ['compiler_generated'] )\n\t end\n\t %% Line 326\n\t <{'file',File},Opts> when 'true' ->\n\t %% Line 327\n\t case apply 'passes'/2\n\t\t ('file', Opts) of\n\t\t<{Ext,Ps}> when 'true' ->\n\t\t let =\n\t\t\tapply %% Line 328\n\t\t\t 'build_compile'/1\n\t\t\t (%% Line 328\n\t\t\t Opts)\n\t\t in %% Line 329\n\t\t\tapply 'internal_comp'/5\n\t\t\t (Ps, 'none', File, Ext, Compile)\n\t\t( <_6> when 'true' ->\n\t\t primop 'match_fail'\n\t\t\t ({'badmatch',_6})\n\t\t -| ['compiler_generated'] )\n\t end\n\t ( <_9,_8> when 'true' ->\n\t\t( primop 'match_fail'\n\t\t ({'function_clause',_9,_8})\n\t\t -| [{'function_name',{'internal',2}}] )\n\t -| ['compiler_generated'] )\n\tend\n'build_compile'/1 =\n %% Line 331\n fun (_0) ->\n\tlet =\n\t call %% Line 332\n\t\t 'proplists':%% Line 332\n\t\t\t 'get_value'\n\t\t(%% Line 332\n\t\t 'extra_chunks', _0, %% Line 332\n\t\t\t\t [])\n\tin let =\n\t\tcall %% Line 333\n\t\t 'proplists':%% Line 333\n\t\t\t\t 'delete'\n\t\t (%% Line 333\n\t\t 'extra_chunks', _0)\n\t in %% Line 334\n\t\t{'compile',[],[],[],[],[],[],[],[],Opts1,Opts1,'none',[],[],ExtraChunks}\n'internal_comp'/5 =\n %% Line 336\n fun (_4,_3,_2,_1,_0) ->\n\tlet

=\n\t call %% Line 337\n\t\t 'filename':%% Line 337\n\t\t\t 'dirname'\n\t\t(_2)\n\tin let =\n\t\tcall %% Line 338\n\t\t 'filename':%% Line 338\n\t\t\t\t'basename'\n\t\t (_2, _1)\n\t in let <_rec0> =\n\t\t apply %% Line 340\n\t\t\t 'erlfile'/3\n\t\t\t(%% Line 340\n\t\t\t Dir, %% Line 340\n\t\t\t Base, _1)\n\t\tin let <_rec1> =\n\t\t\tapply %% Line 341\n\t\t\t 'objfile'/2\n\t\t\t (%% Line 341\n\t\t\t Base, _0)\n\t\t in %% Line 339\n\t\t\tcase _0 of\n\t\t\t <{'compile',_44,_45,_46,_47,_48,_49,_50,_51,_52,_53,_54,_55,_56,_57}> when 'true' ->\n\t\t\t let <_10> =\n\t\t\t\t call %% Line 341\n\t\t\t\t 'erlang':%% Line 341\n\t\t\t\t\t\t'setelement'\n\t\t\t\t (%% Line 341\n\t\t\t\t 6, _0, %% Line 341\n\t\t\t\t\t _rec1)\n\t\t\t in let <_11> =\n\t\t\t\t call %% Line 340\n\t\t\t\t\t 'erlang':%% Line 340\n\t\t\t\t\t\t 'setelement'\n\t\t\t\t\t (%% Line 340\n\t\t\t\t\t 5, _10, %% Line 340\n\t\t\t\t\t\t _rec0)\n\t\t\t\t in let <_12> =\n\t\t\t\t\t call 'erlang':'setelement'\n\t\t\t\t\t (4, _11, Base)\n\t\t\t\t in let <_13> =\n\t\t\t\t\t call 'erlang':'setelement'\n\t\t\t\t\t\t (3, _12, Dir)\n\t\t\t\t\t in let <_15> =\n\t\t\t\t\t\t call 'erlang':'setelement'\n\t\t\t\t\t\t (2, _13, _2)\n\t\t\t\t\t in %% Line 342\n\t\t\t\t\t\t ( case _15 of\n\t\t\t\t\t\t ( <( {'compile',_59,_60,_61,_62,_63,_64,_65,_66,_rec3,_67,_68,_69,_70,_71}\n\t\t\t\t\t\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\t\t\t\t\t let <_27> =\n\t\t\t\t\t\t\t\tcase %% Line 343\n\t\t\t\t\t\t\t\t call 'lists':'member'\n\t\t\t\t\t\t\t\t\t ('time', _rec3) of\n\t\t\t\t\t\t\t\t %% Line 344\n\t\t\t\t\t\t\t\t <'true'> when 'true' ->\n\t\t\t\t\t\t\t\t do %% Line 345\n\t\t\t\t\t\t\t\t\t call 'io':'format'\n\t\t\t\t\t\t\t\t\t ([67|[111|[109|[112|[105|[108|[105|[110|[103|[32|[126|[116|[112|[10]]]]]]]]]]]]]], [_2|[]])\n\t\t\t\t\t\t\t\t\t %% Line 346\n\t\t\t\t\t\t\t\t\t ( 'run_tc'/3\n\t\t\t\t\t\t\t\t\t -| [{'id',{0,0,'-internal_comp/5-fun-0-'}}] )\n\t\t\t\t\t\t\t\t %% Line 347\n\t\t\t\t\t\t\t\t <'false'> when 'true' ->\n\t\t\t\t\t\t\t\t %% Line 348\n\t\t\t\t\t\t\t\t ( fun (_22,_21,_20) ->\n\t\t\t\t\t\t\t\t\t case <_22,_21,_20> of\n\t\t\t\t\t\t\t\t\t <{_X_Name,Fun},Code,St> when 'true' ->\n\t\t\t\t\t\t\t\t\t\t catch\n\t\t\t\t\t\t\t\t\t\t %% Line 349\n\t\t\t\t\t\t\t\t\t\t apply Fun\n\t\t\t\t\t\t\t\t\t\t\t (Code, St)\n\t\t\t\t\t\t\t\t\t ( <_25,_24,_23> when 'true' ->\n\t\t\t\t\t\t\t\t\t\t ( primop 'match_fail'\n\t\t\t\t\t\t\t\t\t\t\t ({'function_clause',_25,_24,_23})\n\t\t\t\t\t\t\t\t\t\t -| [{'function_name',{'-internal_comp/5-fun-1-',3}}] )\n\t\t\t\t\t\t\t\t\t\t-| ['compiler_generated'] )\n\t\t\t\t\t\t\t\t\t end\n\t\t\t\t\t\t\t\t\t-| [{'id',{0,0,'-internal_comp/5-fun-1-'}}] )\n\t\t\t\t\t\t\t\t ( <_26> when 'true' ->\n\t\t\t\t\t\t\t\t\t%% Line 343\n\t\t\t\t\t\t\t\t\tprimop 'match_fail'\n\t\t\t\t\t\t\t\t\t ({'case_clause',_26})\n\t\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t\t\t\tend\n\t\t\t\t\t\t\t in let <_36> =\n\t\t\t\t\t\t\t\t case %% Line 352\n\t\t\t\t\t\t\t\t\t call 'lists':'keyfind'\n\t\t\t\t\t\t\t\t\t ('eprof', 1, _rec3) of\n\t\t\t\t\t\t\t\t %% Line 353\n\t\t\t\t\t\t\t\t <{'eprof',EprofPass}> when 'true' ->\n\t\t\t\t\t\t\t\t\t %% Line 354\n\t\t\t\t\t\t\t\t\t ( fun (_31,_30,_29) ->\n\t\t\t\t\t\t\t\t\t\t%% Line 355\n\t\t\t\t\t\t\t\t\t\tapply 'run_eprof'/4\n\t\t\t\t\t\t\t\t\t\t (_31, _30, EprofPass, _29)\n\t\t\t\t\t\t\t\t\t -| [{'id',{0,0,'-internal_comp/5-fun-2-'}}] )\n\t\t\t\t\t\t\t\t %% Line 357\n\t\t\t\t\t\t\t\t <'false'> when 'true' ->\n\t\t\t\t\t\t\t\t\t _27\n\t\t\t\t\t\t\t\t ( <_35> when 'true' ->\n\t\t\t\t\t\t\t\t\t %% Line 352\n\t\t\t\t\t\t\t\t\t primop 'match_fail'\n\t\t\t\t\t\t\t\t\t\t({'case_clause',_35})\n\t\t\t\t\t\t\t\t\t-| ['compiler_generated'] )\n\t\t\t\t\t\t\t\t end\n\t\t\t\t\t\t\t\tin %% Line 360\n\t\t\t\t\t\t\t\t case apply 'fold_comp'/4\n\t\t\t\t\t\t\t\t\t (_4, _36, _3, _15) of\n\t\t\t\t\t\t\t\t %% Line 361\n\t\t\t\t\t\t\t\t <{'ok',Code,St2}> when 'true' ->\n\t\t\t\t\t\t\t\t\t apply 'comp_ret_ok'/2\n\t\t\t\t\t\t\t\t\t (Code, St2)\n\t\t\t\t\t\t\t\t %% Line 362\n\t\t\t\t\t\t\t\t <{'error',St2}> when 'true' ->\n\t\t\t\t\t\t\t\t\t apply 'comp_ret_err'/1\n\t\t\t\t\t\t\t\t\t (St2)\n\t\t\t\t\t\t\t\t ( <_38> when 'true' ->\n\t\t\t\t\t\t\t\t\t primop 'match_fail'\n\t\t\t\t\t\t\t\t\t\t({'case_clause',_38})\n\t\t\t\t\t\t\t\t\t-| ['compiler_generated'] )\n\t\t\t\t\t\t\t\t end\n\t\t\t\t\t\t\t-| ['compiler_generated'] )\n\t\t\t\t\t\t ( <_72> when 'true' ->\n\t\t\t\t\t\t\t ( call ( 'erlang'\n\t\t\t\t\t\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t\t\t\t (( {'badrecord','compile'}\n\t\t\t\t\t\t\t\t -| ['compiler_generated'] ))\n\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t\t\t-| ['compiler_generated'] )\n\t\t\t\t\t\t end\n\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t ( <_58> when 'true' ->\n\t\t\t\t( call ( 'erlang'\n\t\t\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t (( {'badrecord','compile'}\n\t\t\t\t\t -| ['compiler_generated'] ))\n\t\t\t\t -| ['compiler_generated'] )\n\t\t\t -| ['compiler_generated'] )\n\t\t\tend\n'fold_comp'/4 =\n %% Line 365\n fun (_3,_2,_1,_0) ->\n\tcase <_3,_2,_1,_0> of\n\t <[{'delay',Ps0}|Passes],Run,Code,St = {'compile',_30,_31,_32,_33,_34,_35,_36,_37,Opts,_38,_39,_40,_41,_42}> when 'true' ->\n\t let <_4> =\n\t\t apply %% Line 366\n\t\t\t'select_passes'/2\n\t\t (%% Line 366\n\t\t Ps0, %% Line 366\n\t\t\t Opts)\n\t in let =\n\t\t call %% Line 366\n\t\t\t 'erlang':%% Line 366\n\t\t\t\t '++'\n\t\t\t (_4, %% Line 366\n\t\t\t Passes)\n\t\t in %% Line 367\n\t\t apply 'fold_comp'/4\n\t\t\t (Ps, Run, Code, St)\n\t %% Line 368\n\t <[{Name,Test,Pass}|Ps],Run,Code,St> when 'true' ->\n\t %% Line 369\n\t case apply Test\n\t\t (St) of\n\t\t%% Line 370\n\t\t<'false'> when 'true' ->\n\t\t %% Line 371\n\t\t apply 'fold_comp'/4\n\t\t\t(Ps, Run, Code, St)\n\t\t%% Line 372\n\t\t<'true'> when 'true' ->\n\t\t %% Line 373\n\t\t apply 'fold_comp'/4\n\t\t\t([{Name,Pass}|Ps], Run, Code, St)\n\t\t( <_6> when 'true' ->\n\t\t primop 'match_fail'\n\t\t\t ({'case_clause',_6})\n\t\t -| ['compiler_generated'] )\n\t end\n\t %% Line 375\n\t <[_@r0 = {Name,Pass}|Ps],Run,Code0,St0> when 'true' ->\n\t %% Line 376\n\t case apply Run\n\t\t (_@r0, Code0, St0) of\n\t\t%% Line 377\n\t\t<{'ok',Code,St1}> when 'true' ->\n\t\t %% Line 378\n\t\t apply 'fold_comp'/4\n\t\t\t(Ps, Run, Code, St1)\n\t\t%% Line 379\n\t\t when 'true' ->\n\t\t %% Line 380\n\t\t Error\n\t\t%% Line 381\n\t\t<{'EXIT',Reason}> when 'true' ->\n\t\t %% Line 382\n\t\t ( case St0 of\n\t\t\t( <( {'compile',_43,_44,_45,_rec4,_46,_47,_48,_49,_50,_51,_52,_53,_54,_55}\n\t\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\t let =\n\t\t\t\t [{_rec4,[{'none','compile',{'crash',Name,Reason}}|[]]}|[]]\n\t\t\t in let <_rec5> =\n\t\t\t\t call %% Line 383\n\t\t\t\t\t 'erlang':%% Line 383\n\t\t\t\t\t\t '++'\n\t\t\t\t\t (_53, %% Line 383\n\t\t\t\t\t\tEs)\n\t\t\t\t in let <_15> =\n\t\t\t\t\t call %% Line 383\n\t\t\t\t\t 'erlang':%% Line 383\n\t\t\t\t\t\t\t'setelement'\n\t\t\t\t\t (%% Line 383\n\t\t\t\t\t 13, %% Line 383\n\t\t\t\t\t\t St0, %% Line 383\n\t\t\t\t\t\t\t_rec5)\n\t\t\t\t in %% Line 383\n\t\t\t\t\t {'error',_15}\n\t\t\t -| ['compiler_generated'] )\n\t\t\t( <_56> when 'true' ->\n\t\t\t ( call ( 'erlang'\n\t\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t (( {'badrecord','compile'}\n\t\t\t\t -| ['compiler_generated'] ))\n\t\t\t\t-| ['compiler_generated'] )\n\t\t\t -| ['compiler_generated'] )\n\t\t end\n\t\t -| ['compiler_generated'] )\n\t\t%% Line 384\n\t\t when 'true' ->\n\t\t %% Line 385\n\t\t ( case St0 of\n\t\t\t( <( {'compile',_86,_87,_88,_rec8,_89,_90,_91,_92,_93,_94,_95,_96,_97,_98}\n\t\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\t let =\n\t\t\t\t [{_rec8,[{'none','compile',{'bad_return',Name,Other}}|[]]}|[]]\n\t\t\t in let <_rec9> =\n\t\t\t\t call %% Line 386\n\t\t\t\t\t 'erlang':%% Line 386\n\t\t\t\t\t\t '++'\n\t\t\t\t\t (_96, %% Line 386\n\t\t\t\t\t\tEs)\n\t\t\t\t in let <_24> =\n\t\t\t\t\t call %% Line 386\n\t\t\t\t\t 'erlang':%% Line 386\n\t\t\t\t\t\t\t'setelement'\n\t\t\t\t\t (%% Line 386\n\t\t\t\t\t 13, %% Line 386\n\t\t\t\t\t\t St0, %% Line 386\n\t\t\t\t\t\t\t_rec9)\n\t\t\t\t in %% Line 386\n\t\t\t\t\t {'error',_24}\n\t\t\t -| ['compiler_generated'] )\n\t\t\t( <_99> when 'true' ->\n\t\t\t ( call ( 'erlang'\n\t\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t (( {'badrecord','compile'}\n\t\t\t\t -| ['compiler_generated'] ))\n\t\t\t\t-| ['compiler_generated'] )\n\t\t\t -| ['compiler_generated'] )\n\t\t end\n\t\t -| ['compiler_generated'] )\n\t end\n\t %% Line 388\n\t <[],_X_Run,Code,St> when 'true' ->\n\t {'ok',Code,St}\n\t ( <_29,_28,_27,_26> when 'true' ->\n\t\t( primop 'match_fail'\n\t\t ({'function_clause',_29,_28,_27,_26})\n\t\t -| [{'function_name',{'fold_comp',4}}] )\n\t -| ['compiler_generated'] )\n\tend\n'run_tc'/3 =\n %% Line 390\n fun (_2,_1,_0) ->\n\tcase <_2,_1,_0> of\n\t <{Name,Fun},Code,St> when 'true' ->\n\t let =\n\t\t call %% Line 391\n\t\t 'erlang':%% Line 391\n\t\t\t\t'monotonic_time'\n\t\t ()\n\t in let <_4> =\n\t\t catch\n\t\t\t %% Line 392\n\t\t\t apply Fun\n\t\t\t (Code, St)\n\t\t in let =\n\t\t\t call %% Line 393\n\t\t\t 'erlang':%% Line 393\n\t\t\t\t\t'monotonic_time'\n\t\t\t ()\n\t\t in let <_7> =\n\t\t\t call %% Line 394\n\t\t\t\t 'erlang':%% Line 394\n\t\t\t\t\t '-'\n\t\t\t\t (%% Line 394\n\t\t\t\t T2, %% Line 394\n\t\t\t\t T1)\n\t\t\t in let =\n\t\t\t\t call %% Line 394\n\t\t\t\t 'erlang':%% Line 394\n\t\t\t\t\t\t'convert_time_unit'\n\t\t\t\t (_7, %% Line 394\n\t\t\t\t\t 'native', %% Line 394\n\t\t\t\t\t\t 'millisecond')\n\t\t\t in let <_10> =\n\t\t\t\t call %% Line 395\n\t\t\t\t\t 'erts_debug':%% Line 395\n\t\t\t\t\t\t\t'flat_size'\n\t\t\t\t\t (_4)\n\t\t\t\t in let <_9> =\n\t\t\t\t\t call %% Line 395\n\t\t\t\t\t 'erlang':%% Line 395\n\t\t\t\t\t\t\t'system_info'\n\t\t\t\t\t (%% Line 395\n\t\t\t\t\t 'wordsize')\n\t\t\t\t in let =\n\t\t\t\t\t call %% Line 395\n\t\t\t\t\t\t 'erlang':%% Line 395\n\t\t\t\t\t\t\t '*'\n\t\t\t\t\t\t (_10, _9)\n\t\t\t\t\t in let <_12> =\n\t\t\t\t\t\t call %% Line 396\n\t\t\t\t\t\t 'erlang':%% Line 396\n\t\t\t\t\t\t\t\t'/'\n\t\t\t\t\t\t (%% Line 396\n\t\t\t\t\t\t Mem0, %% Line 396\n\t\t\t\t\t\t\t 1024)\n\t\t\t\t\t in let <_13> =\n\t\t\t\t\t\t call %% Line 396\n\t\t\t\t\t\t\t 'io_lib':%% Line 396\n\t\t\t\t\t\t\t\t 'format'\n\t\t\t\t\t\t\t (%% Line 396\n\t\t\t\t\t\t\t [126|[46|[49|[102|[32|[107|[66]]]]]]], %% Line 396\n\t\t\t\t\t\t\t\t\t\t\t\t [_12|[]])\n\t\t\t\t\t\t in let =\n\t\t\t\t\t\t\t call %% Line 396\n\t\t\t\t\t\t\t 'lists':%% Line 396\n\t\t\t\t\t\t\t\t 'flatten'\n\t\t\t\t\t\t\t (_13)\n\t\t\t\t\t\t in let <_15> =\n\t\t\t\t\t\t\t call %% Line 398\n\t\t\t\t\t\t\t\t 'erlang':%% Line 398\n\t\t\t\t\t\t\t\t\t '/'\n\t\t\t\t\t\t\t\t (%% Line 398\n\t\t\t\t\t\t\t\t Elapsed, %% Line 398\n\t\t\t\t\t\t\t\t\t 1000)\n\t\t\t\t\t\t\t in do %% Line 397\n\t\t\t\t\t\t\t\t call 'io':'format'\n\t\t\t\t\t\t\t\t ([32|[126|[45|[51|[48|[115|[58|[32|[126|[49|[48|[46|[51|[102|[32|[115|[32|[126|[49|[50|[115|[10]]]]]]]]]]]]]]]]]]]]]], %% Line 398\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t [Name|[_15|[Mem|[]]]])\n\t\t\t\t\t\t\t\t _4\n\t ( <_18,_17,_16> when 'true' ->\n\t\t( primop 'match_fail'\n\t\t ({'function_clause',_18,_17,_16})\n\t\t -| [{'function_name',{'run_tc',3}}] )\n\t -| ['compiler_generated'] )\n\tend\n'run_eprof'/4 =\n %% Line 401\n fun (_3,_2,_1,_0) ->\n\tcase <_3,_2,_1,_0> of\n\t <{Name,Fun},Code,_11,St>\n\t when call 'erlang':'=:='\n\t\t (_11,\n\t\t Name) ->\n\t do %% Line 402\n\t\t call 'io':'format'\n\t\t ([126|[112|[58|[32|[82|[117|[110|[110|[105|[110|[103|[32|[101|[112|[114|[111|[102|[10]]]]]]]]]]]]]]]]]], [Name|[]])\n\t\t let <_4> =\n\t\t call %% Line 403\n\t\t\t 'erlang':%% Line 403\n\t\t\t\t 'self'\n\t\t\t ()\n\t\t in do %% Line 403\n\t\t\t call 'c':'appcall'\n\t\t\t ('tools', 'eprof', 'start_profiling', [[_4|[]]|[]])\n\t\t\t let <_5> =\n\t\t\t catch\n\t\t\t\t %% Line 404\n\t\t\t\t apply Fun\n\t\t\t\t (Code, St)\n\t\t\t in do %% Line 405\n\t\t\t\t call 'c':'appcall'\n\t\t\t\t ('tools', 'eprof', 'stop_profiling', [])\n\t\t\t\t do %% Line 406\n\t\t\t\t call 'c':'appcall'\n\t\t\t\t\t ('tools', 'eprof', 'analyze', [])\n\t\t\t\t _5\n\t %% Line 408\n\t <{_12,Fun},Code,_13,St> when 'true' ->\n\t catch\n\t\t %% Line 409\n\t\t apply Fun\n\t\t (Code, St)\n\t ( <_10,_9,_8,_7> when 'true' ->\n\t\t( primop 'match_fail'\n\t\t ({'function_clause',_10,_9,_8,_7})\n\t\t -| [{'function_name',{'run_eprof',4}}] )\n\t -| ['compiler_generated'] )\n\tend\n'comp_ret_ok'/2 =\n %% Line 411\n fun (_1,_0) ->\n\tcase <_1,_0> of\n\t when 'true' ->\n\t %% Line 412\n\t case apply 'werror'/1\n\t\t (St) of\n\t\t%% Line 413\n\t\t<'true'> when 'true' ->\n\t\t do %% Line 414\n\t\t\tcase call 'lists':'member'\n\t\t\t\t ('report_warnings', Opts) of\n\t\t\t %% Line 415\n\t\t\t <'true'> when 'true' ->\n\t\t\t %% Line 416\n\t\t\t call 'io':'format'\n\t\t\t\t ([126|[112|[58|[32|[119|[97|[114|[110|[105|[110|[103|[115|[32|[98|[101|[105|[110|[103|[32|[116|[114|[101|[97|[116|[101|[100|[32|[97|[115|[32|[101|[114|[114|[111|[114|[115|[10]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]], %% Line 417\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t ['compile'])\n\t\t\t %% Line 418\n\t\t\t <'false'> when 'true' ->\n\t\t\t 'ok'\n\t\t\t ( <_2> when 'true' ->\n\t\t\t\tprimop 'match_fail'\n\t\t\t\t ({'case_clause',_2})\n\t\t\t -| ['compiler_generated'] )\n\t\t\tend\n\t\t\t%% Line 421\n\t\t\tapply 'comp_ret_err'/1\n\t\t\t (St)\n\t\t%% Line 422\n\t\t<'false'> when 'true' ->\n\t\t let =\n\t\t\tapply %% Line 423\n\t\t\t 'messages_per_file'/1\n\t\t\t (%% Line 423\n\t\t\t Warn0)\n\t\t in let <_6> =\n\t\t\t call %% Line 424\n\t\t\t\t 'erlang':%% Line 424\n\t\t\t\t\t 'setelement'\n\t\t\t\t(%% Line 424\n\t\t\t\t 14, %% Line 424\n\t\t\t\t St, %% Line 424\n\t\t\t\t\t Warn)\n\t\t\tin do %% Line 424\n\t\t\t\tapply 'report_warnings'/1\n\t\t\t\t (_6)\n\t\t\t\tlet <_10> =\n\t\t\t\t case %% Line 425\n\t\t\t\t\t call 'lists':'member'\n\t\t\t\t\t ('binary', Opts) of\n\t\t\t\t %% Line 425\n\t\t\t\t ( <( 'true'\n\t\t\t\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\t\t\t let <_8> =\n\t\t\t\t\t\tcall %% Line 426\n\t\t\t\t\t\t 'lists':%% Line 426\n\t\t\t\t\t\t\t 'member'\n\t\t\t\t\t\t (%% Line 426\n\t\t\t\t\t\t 'no_code_generation', %% Line 426\n\t\t\t\t\t\t\t\t\t Opts)\n\t\t\t\t\t in %% Line 426\n\t\t\t\t\t\tcall 'erlang':'not'\n\t\t\t\t\t\t (_8)\n\t\t\t\t\t-| ['compiler_generated'] )\n\t\t\t\t %% Line 425\n\t\t\t\t ( <( 'false'\n\t\t\t\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\t\t\t 'false'\n\t\t\t\t\t-| ['compiler_generated'] )\n\t\t\t\t %% Line 425\n\t\t\t\t ( <_7> when 'true' ->\n\t\t\t\t\t ( call ( 'erlang'\n\t\t\t\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t\t (( {( 'badarg'\n\t\t\t\t\t\t\t-| ['compiler_generated'] ),_7}\n\t\t\t\t\t\t -| ['compiler_generated'] ))\n\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t-| ['compiler_generated'] )\n\t\t\t\t end\n\t\t\t\tin let <_12> =\n\t\t\t\t\tcase _10 of\n\t\t\t\t\t %% Line 427\n\t\t\t\t\t <'true'> when 'true' ->\n\t\t\t\t\t [Code|[]]\n\t\t\t\t\t %% Line 428\n\t\t\t\t\t <'false'> when 'true' ->\n\t\t\t\t\t []\n\t\t\t\t\t ( <_11> when 'true' ->\n\t\t\t\t\t\t%% Line 425\n\t\t\t\t\t\tprimop 'match_fail'\n\t\t\t\t\t\t ({'case_clause',_11})\n\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\tend\n\t\t\t\t in let <_15> =\n\t\t\t\t\t case %% Line 430\n\t\t\t\t\t\t call 'lists':'member'\n\t\t\t\t\t\t ('return_warnings', Opts) of\n\t\t\t\t\t %% Line 431\n\t\t\t\t\t <'true'> when 'true' ->\n\t\t\t\t\t\t call 'erlang':'++'\n\t\t\t\t\t\t (_12, [Warn|[]])\n\t\t\t\t\t %% Line 432\n\t\t\t\t\t <'false'> when 'true' ->\n\t\t\t\t\t\t _12\n\t\t\t\t\t ( <_14> when 'true' ->\n\t\t\t\t\t\t %% Line 430\n\t\t\t\t\t\t primop 'match_fail'\n\t\t\t\t\t\t\t({'case_clause',_14})\n\t\t\t\t\t\t-| ['compiler_generated'] )\n\t\t\t\t\t end\n\t\t\t\t\tin %% Line 434\n\t\t\t\t\t call 'erlang':'list_to_tuple'\n\t\t\t\t\t\t(['ok'|[Mod|_15]])\n\t\t( <_17> when 'true' ->\n\t\t primop 'match_fail'\n\t\t\t ({'case_clause',_17})\n\t\t -| ['compiler_generated'] )\n\t end\n\t ( <_19,_18> when 'true' ->\n\t\t( primop 'match_fail'\n\t\t ({'function_clause',_19,_18})\n\t\t -| [{'function_name',{'comp_ret_ok',2}}] )\n\t -| ['compiler_generated'] )\n\tend\n'comp_ret_err'/1 =\n %% Line 437\n fun (_0) ->\n\tcase _0 of\n\t when 'true' ->\n\t let =\n\t\t apply %% Line 438\n\t\t\t'messages_per_file'/1\n\t\t (%% Line 438\n\t\t Warn0)\n\t in let =\n\t\t apply %% Line 439\n\t\t\t 'messages_per_file'/1\n\t\t\t (%% Line 439\n\t\t\t Err0)\n\t\t in let <_5> =\n\t\t\t call %% Line 440\n\t\t\t 'erlang':%% Line 440\n\t\t\t\t\t'setelement'\n\t\t\t (%% Line 440\n\t\t\t 13, %% Line 440\n\t\t\t\t St, %% Line 440\n\t\t\t\t Err)\n\t\t in do %% Line 440\n\t\t\t apply 'report_errors'/1\n\t\t\t\t (_5)\n\t\t\t let <_8> =\n\t\t\t\t call %% Line 441\n\t\t\t\t 'erlang':%% Line 441\n\t\t\t\t\t\t'setelement'\n\t\t\t\t (%% Line 441\n\t\t\t\t 14, %% Line 441\n\t\t\t\t\t St, %% Line 441\n\t\t\t\t\t Warn)\n\t\t\t in do %% Line 441\n\t\t\t\t apply 'report_warnings'/1\n\t\t\t\t\t (_8)\n\t\t\t\t %% Line 442\n\t\t\t\t case call 'lists':'member'\n\t\t\t\t\t ('return_errors', Opts) of\n\t\t\t\t\t%% Line 443\n\t\t\t\t\t<'true'> when 'true' ->\n\t\t\t\t\t {'error',Err,Warn}\n\t\t\t\t\t%% Line 444\n\t\t\t\t\t<'false'> when 'true' ->\n\t\t\t\t\t 'error'\n\t\t\t\t\t( <_9> when 'true' ->\n\t\t\t\t\t primop 'match_fail'\n\t\t\t\t\t\t ({'case_clause',_9})\n\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t end\n\t ( <_10> when 'true' ->\n\t\t( primop 'match_fail'\n\t\t ({'function_clause',_10})\n\t\t -| [{'function_name',{'comp_ret_err',1}}] )\n\t -| ['compiler_generated'] )\n\tend\n'not_werror'/1 =\n %% Line 447\n fun (_0) ->\n\tlet <_1> =\n\t apply 'werror'/1\n\t\t(_0)\n\tin call 'erlang':'not'\n\t\t(_1)\n'werror'/1 =\n %% Line 449\n fun (_0) ->\n\tcase _0 of\n\t <{'compile',_4,_5,_6,_7,_8,_9,_10,_11,Opts,_12,_13,_14,Ws,_15}> when 'true' ->\n\t %% Line 450\n\t ( case <> of\n\t\t ( <>\n\t\t\twhen call 'erlang':'=/='\n\t\t\t (Ws,\n\t\t\t []) ->\n\t\t\tcall 'lists':'member'\n\t\t\t ('warnings_as_errors', Opts)\n\t\t -| ['compiler_generated'] )\n\t\t ( <> when 'true' ->\n\t\t\t'false'\n\t\t -| ['compiler_generated'] )\n\t\tend\n\t\t-| ['compiler_generated'] )\n\t ( <_3> when 'true' ->\n\t\t( primop 'match_fail'\n\t\t ({'function_clause',_3})\n\t\t -| [{'function_name',{'werror',1}}] )\n\t -| ['compiler_generated'] )\n\tend\n'messages_per_file'/1 =\n %% Line 453\n fun (_0) ->\n\tlet <_8> =\n\t letrec\n\t\t'lc$^0'/1 =\n\t\t %% Line 454\n\t\t fun (_5) ->\n\t\t\tcase _5 of\n\t\t\t <[{File,Messages}|_2]> when 'true' ->\n\t\t\t ( letrec\n\t\t\t\t 'lc$^1'/1 =\n\t\t\t\t\tfun (_6) ->\n\t\t\t\t\t case _6 of\n\t\t\t\t\t <[M|_4]> when 'true' ->\n\t\t\t\t\t\t let <_7> =\n\t\t\t\t\t\t apply 'lc$^1'/1\n\t\t\t\t\t\t\t (_4)\n\t\t\t\t\t\t in ( [{File,M}|_7]\n\t\t\t\t\t\t\t-| ['compiler_generated'] )\n\t\t\t\t\t <[]> when 'true' ->\n\t\t\t\t\t\t apply 'lc$^0'/1\n\t\t\t\t\t\t (_2)\n\t\t\t\t\t ( <_38> when 'true' ->\n\t\t\t\t\t\t ( primop 'match_fail'\n\t\t\t\t\t\t\t ({'function_clause',_38})\n\t\t\t\t\t\t -| [{'function_name',{'lc$^1',1}}] )\n\t\t\t\t\t\t-| ['compiler_generated'] )\n\t\t\t\t\t end\n\t\t\t\tin apply 'lc$^1'/1\n\t\t\t\t\t(Messages)\n\t\t\t\t-| ['list_comprehension'] )\n\t\t\t ( <[_1|_2]> when 'true' ->\n\t\t\t\tapply 'lc$^0'/1\n\t\t\t\t (_2)\n\t\t\t -| ['compiler_generated'] )\n\t\t\t <[]> when 'true' ->\n\t\t\t []\n\t\t\t ( <_39> when 'true' ->\n\t\t\t\t( primop 'match_fail'\n\t\t\t\t ({'function_clause',_39})\n\t\t\t\t -| [{'function_name',{'lc$^0',1}}] )\n\t\t\t -| ['compiler_generated'] )\n\t\t\tend\n\t in %% Line 454\n\t\tapply 'lc$^0'/1\n\t\t (_0)\n\tin let =\n\t\tcall %% Line 454\n\t\t 'lists':%% Line 454\n\t\t\t 'sort'\n\t\t (_8)\n\t in let <_18> =\n\t\t fun (_15,_14) ->\n\t\t\tlet <_13> =\n\t\t\t fun (_11) ->\n\t\t\t\t%% Line 458\n\t\t\t\tcase _11 of\n\t\t\t\t <{_28,{_29,Mod,_30}}> when 'true' ->\n\t\t\t\t call 'erlang':'=:='\n\t\t\t\t\t (Mod, _15)\n\t\t\t\t %% Line 459\n\t\t\t\t <_31> when 'true' ->\n\t\t\t\t 'false'\n\t\t\t\tend\n\t\t\tin %% Line 458\n\t\t\t call 'lists':'partition'\n\t\t\t\t(_13, _14)\n\t\tin %% Line 456\n\t\t case %% Line 457\n\t\t\t call 'lists':'mapfoldl'\n\t\t\t (_18, %% Line 461\n\t\t\t\t T, ['erl_scan'|['epp'|['erl_parse']]]) of\n\t\t <{Prio0,Rest}> when 'true' ->\n\t\t\t let <_25> =\n\t\t\t fun (_22,_21) ->\n\t\t\t\t %% Line 462\n\t\t\t\t case <_22,_21> of\n\t\t\t\t <{_32,{L1,_33,_34}},{_35,{L2,_36,_37}}> when 'true' ->\n\t\t\t\t\tcall 'erlang':'=<'\n\t\t\t\t\t (L1, L2)\n\t\t\t\t ( <_24,_23> when 'true' ->\n\t\t\t\t\t ( primop 'match_fail'\n\t\t\t\t\t\t({'function_clause',_24,_23})\n\t\t\t\t\t -| [{'function_name',{'-messages_per_file/1-fun-4-',2}}] )\n\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t end\n\t\t\t in let <_20> =\n\t\t\t\t call %% Line 463\n\t\t\t\t 'lists':%% Line 463\n\t\t\t\t\t 'append'\n\t\t\t\t (%% Line 463\n\t\t\t\t Prio0)\n\t\t\t in let =\n\t\t\t\t call %% Line 462\n\t\t\t\t\t 'lists':%% Line 462\n\t\t\t\t\t\t 'sort'\n\t\t\t\t\t (_25, _20)\n\t\t\t\t in %% Line 464\n\t\t\t\t call 'lists':'flatmap'\n\t\t\t\t\t (( 'mpf'/1\n\t\t\t\t\t -| [{'id',{0,0,'-messages_per_file/1-fun-5-'}}] ), [Prio|[Rest|[]]])\n\t\t ( <_19> when 'true' ->\n\t\t\t primop 'match_fail'\n\t\t\t\t({'badmatch',_19})\n\t\t\t-| ['compiler_generated'] )\n\t\t end\n'mpf'/1 =\n %% Line 466\n fun (_0) ->\n\t%% Line 468\n\t( letrec\n\t 'lc$^1'/1 =\n\t\t fun (_9) ->\n\t\t case _9 of\n\t\t\t<[File|_2]> when 'true' ->\n\t\t\t let <_14> =\n\t\t\t\tletrec\n\t\t\t\t 'lc$^2'/1 =\n\t\t\t\t\tfun (_12) ->\n\t\t\t\t\t case _12 of\n\t\t\t\t\t <[{F,M}|_11]>\n\t\t\t\t\t\t when call 'erlang':'=:='\n\t\t\t\t\t\t\t(F,\n\t\t\t\t\t\t\t File) ->\n\t\t\t\t\t\t let <_13> =\n\t\t\t\t\t\t apply 'lc$^2'/1\n\t\t\t\t\t\t\t (_11)\n\t\t\t\t\t\t in ( [M|_13]\n\t\t\t\t\t\t\t-| ['compiler_generated'] )\n\t\t\t\t\t ( <[_10|_11]> when 'true' ->\n\t\t\t\t\t\t apply 'lc$^2'/1\n\t\t\t\t\t\t\t(_11)\n\t\t\t\t\t\t-| ['compiler_generated'] )\n\t\t\t\t\t <[]> when 'true' ->\n\t\t\t\t\t\t []\n\t\t\t\t\t ( <_18> when 'true' ->\n\t\t\t\t\t\t ( primop 'match_fail'\n\t\t\t\t\t\t\t ({'function_clause',_18})\n\t\t\t\t\t\t -| [{'function_name',{'lc$^2',1}}] )\n\t\t\t\t\t\t-| ['compiler_generated'] )\n\t\t\t\t\t end\n\t\t\t\tin apply 'lc$^2'/1\n\t\t\t\t\t(_0)\n\t\t\t in let <_15> =\n\t\t\t\t apply 'lc$^1'/1\n\t\t\t\t\t(_2)\n\t\t\t\tin ( [{File,_14}|_15]\n\t\t\t\t -| ['compiler_generated'] )\n\t\t\t<[]> when 'true' ->\n\t\t\t []\n\t\t\t( <_19> when 'true' ->\n\t\t\t ( primop 'match_fail'\n\t\t\t\t ({'function_clause',_19})\n\t\t\t\t-| [{'function_name',{'lc$^1',1}}] )\n\t\t\t -| ['compiler_generated'] )\n\t\t end\n\t in let <_7> =\n\t\t letrec\n\t\t 'lc$^0'/1 =\n\t\t\t fun (_5) ->\n\t\t\t case _5 of\n\t\t\t\t<[{F,_17}|_4]> when 'true' ->\n\t\t\t\t let <_6> =\n\t\t\t\t\tapply 'lc$^0'/1\n\t\t\t\t\t (_4)\n\t\t\t\t in ( [F|_6]\n\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t( <[_3|_4]> when 'true' ->\n\t\t\t\t apply 'lc$^0'/1\n\t\t\t\t\t (_4)\n\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t<[]> when 'true' ->\n\t\t\t\t []\n\t\t\t\t( <_20> when 'true' ->\n\t\t\t\t ( primop 'match_fail'\n\t\t\t\t\t ({'function_clause',_20})\n\t\t\t\t\t-| [{'function_name',{'lc$^0',1}}] )\n\t\t\t\t -| ['compiler_generated'] )\n\t\t\t end\n\t\t in apply 'lc$^0'/1\n\t\t\t (_0)\n\t in let <_8> =\n\t\t call 'lists':'usort'\n\t\t\t (_7)\n\t\t in apply 'lc$^1'/1\n\t\t\t (_8)\n\t -| ['list_comprehension'] )\n'passes'/2 =\n %% Line 474\n fun (_1,_0) ->\n\t%% Line 475\n\tcase apply 'passes_1'/1\n\t\t (_0) of\n\t <{Ext,Passes0}> when 'true' ->\n\t let <_4> =\n\t\t case _1 of\n\t\t %% Line 477\n\t\t <'file'> when 'true' ->\n\t\t\t%% Line 478\n\t\t\tPasses0\n\t\t %% Line 479\n\t\t <'forms'> when 'true' ->\n\t\t\t%% Line 480\n\t\t\tapply 'fix_first_pass'/1\n\t\t\t (Passes0)\n\t\t ( <_3> when 'true' ->\n\t\t\t %% Line 476\n\t\t\t primop 'match_fail'\n\t\t\t ({'case_clause',_3})\n\t\t -| ['compiler_generated'] )\n\t\t end\n\t in let =\n\t\t apply %% Line 482\n\t\t\t 'select_passes'/2\n\t\t\t (_4, _0)\n\t\t in let <_9> =\n\t\t\t case %% Line 487\n\t\t\t call 'lists':'last'\n\t\t\t\t (Passes) of\n\t\t\t %% Line 488\n\t\t\t <{'save_binary',_X_TestFun,_X_Fun}> when 'true' ->\n\t\t\t\t%% Line 489\n\t\t\t\tcase Passes of\n\t\t\t\t %% Line 490\n\t\t\t\t <[{'read_beam_file',_12}|_13]> when 'true' ->\n\t\t\t\t %% Line 493\n\t\t\t\t Passes\n\t\t\t\t %% Line 494\n\t\t\t\t <_14> when 'true' ->\n\t\t\t\t %% Line 495\n\t\t\t\t [{'remove_file',( 'remove_file'/2\n\t\t\t\t\t\t\t-| [{'id',{0,0,'-passes/2-fun-0-'}}] )}|Passes]\n\t\t\t\tend\n\t\t\t %% Line 497\n\t\t\t <_15> when 'true' ->\n\t\t\t\t%% Line 498\n\t\t\t\tPasses\n\t\t\t end\n\t\t in %% Line 487\n\t\t\t {Ext,_9}\n\t ( <_2> when 'true' ->\n\t\tprimop 'match_fail'\n\t\t ({'badmatch',_2})\n\t -| ['compiler_generated'] )\n\tend\n'passes_1'/1 =\n %% Line 501\n fun (_0) ->\n\tcase _0 of\n\t <[Opt|Opts]> when 'true' ->\n\t %% Line 502\n\t case apply 'pass'/1\n\t\t (Opt) of\n\t\t%% Line 503\n\t\t when 'true' ->\n\t\t Res\n\t\t%% Line 504\n\t\t<'none'> when 'true' ->\n\t\t apply 'passes_1'/1\n\t\t\t(Opts)\n\t\t( <_1> when 'true' ->\n\t\t primop 'match_fail'\n\t\t\t ({'case_clause',_1})\n\t\t -| ['compiler_generated'] )\n\t end\n\t %% Line 506\n\t <[]> when 'true' ->\n\t let <_2> =\n\t\t apply %% Line 507\n\t\t\t'standard_passes'/0\n\t\t ()\n\t in %% Line 507\n\t\t {[46|[101|[114|[108]]]],[{'parse_module',( 'parse_module'/2\n\t\t\t\t\t\t\t -| [{'id',{0,0,'-passes_1/1-fun-0-'}}] )}|_2]}\n\t ( <_3> when 'true' ->\n\t\t( primop 'match_fail'\n\t\t ({'function_clause',_3})\n\t\t -| [{'function_name',{'passes_1',1}}] )\n\t -| ['compiler_generated'] )\n\tend\n'pass'/1 =\n %% Line 509\n fun (_0) ->\n\tcase _0 of\n\t <'from_core'> when 'true' ->\n\t let <_1> =\n\t\t apply %% Line 510\n\t\t\t'core_passes'/0\n\t\t ()\n\t in %% Line 510\n\t\t {[46|[99|[111|[114|[101]]]]],[{'parse_core',( 'parse_core'/2\n\t\t\t\t\t\t\t\t-| [{'id',{0,0,'-pass/1-fun-0-'}}] )}|_1]}\n\t %% Line 511\n\t <'from_asm'> when 'true' ->\n\t let <_2> =\n\t\t apply %% Line 512\n\t\t\t'asm_passes'/0\n\t\t ()\n\t in %% Line 512\n\t\t {[46|[83]],[{'beam_consult_asm',( 'beam_consult_asm'/2\n\t\t\t\t\t\t -| [{'id',{0,0,'-pass/1-fun-1-'}}] )}|_2]}\n\t %% Line 513\n\t <'from_beam'> when 'true' ->\n\t let <_3> =\n\t\t apply %% Line 514\n\t\t\t'binary_passes'/0\n\t\t ()\n\t in %% Line 514\n\t\t {[46|[98|[101|[97|[109]]]]],[{'read_beam_file',( 'read_beam_file'/2\n\t\t\t\t\t\t\t\t -| [{'id',{0,0,'-pass/1-fun-2-'}}] )}|_3]}\n\t %% Line 515\n\t <_5> when 'true' ->\n\t 'none'\n\tend\n'fix_first_pass'/1 =\n %% Line 521\n fun (_0) ->\n\tcase _0 of\n\t <[{'parse_core',_2}|Passes]> when 'true' ->\n\t %% Line 522\n\t [{'get_module_name_from_core',( 'get_module_name_from_core'/2\n\t\t\t\t\t -| [{'id',{0,0,'-fix_first_pass/1-fun-0-'}}] )}|Passes]\n\t %% Line 523\n\t <[{'beam_consult_asm',_3}|Passes]> when 'true' ->\n\t %% Line 524\n\t [{'get_module_name_from_asm',( 'get_module_name_from_asm'/2\n\t\t\t\t\t -| [{'id',{0,0,'-fix_first_pass/1-fun-1-'}}] )}|Passes]\n\t %% Line 525\n\t <[{'read_beam_file',_4}|Passes]> when 'true' ->\n\t %% Line 526\n\t [{'get_module_name_from_beam',( 'get_module_name_from_beam'/2\n\t\t\t\t\t -| [{'id',{0,0,'-fix_first_pass/1-fun-2-'}}] )}|Passes]\n\t %% Line 527\n\t <[_5|Passes]> when 'true' ->\n\t %% Line 530\n\t Passes\n\t ( <_1> when 'true' ->\n\t\t( primop 'match_fail'\n\t\t ({'function_clause',_1})\n\t\t -| [{'function_name',{'fix_first_pass',1}}] )\n\t -| ['compiler_generated'] )\n\tend\n'select_passes'/2 =\n %% Line 583\n fun (_1,_0) ->\n\tcase <_1,_0> of\n\t <[{'pass',Mod}|Ps],Opts> when 'true' ->\n\t let =\n\t\t fun (_19,_18) ->\n\t\t let <_4> =\n\t\t\t catch\n\t\t\t %% Line 585\n\t\t\t ( case _18 of\n\t\t\t\t ( <( {'compile',_45,_46,_47,_48,_49,_50,_51,_52,_rec15,_53,_54,_55,_56,_57}\n\t\t\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\t\t\tcall Mod:'module'\n\t\t\t\t\t (_19, _rec15)\n\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t ( <_58> when 'true' ->\n\t\t\t\t\t( call ( 'erlang'\n\t\t\t\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t (( {'badrecord','compile'}\n\t\t\t\t\t\t -| ['compiler_generated'] ))\n\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\tend\n\t\t\t\t-| ['compiler_generated'] )\n\t\t in %% Line 585\n\t\t\t case _4 of\n\t\t\t %% Line 586\n\t\t\t <{'ok',Code}> when 'true' ->\n\t\t\t\t%% Line 587\n\t\t\t\t{'ok',Code,_18}\n\t\t\t %% Line 588\n\t\t\t <{'ok',Code,Ws}> when 'true' ->\n\t\t\t\t%% Line 589\n\t\t\t\t( case _18 of\n\t\t\t\t ( <( {'compile',_59,_60,_61,_62,_63,_64,_65,_66,_67,_68,_69,_70,_rec18,_71}\n\t\t\t\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\t\t\t let <_rec16> =\n\t\t\t\t\t call 'erlang':'++'\n\t\t\t\t\t\t (_rec18, Ws)\n\t\t\t\t\t in let <_10> =\n\t\t\t\t\t\t call 'erlang':'setelement'\n\t\t\t\t\t\t (14, _18, _rec16)\n\t\t\t\t\t in {'ok',Code,_10}\n\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t ( <_72> when 'true' ->\n\t\t\t\t\t ( call ( 'erlang'\n\t\t\t\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t\t(( {'badrecord','compile'}\n\t\t\t\t\t\t -| ['compiler_generated'] ))\n\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t end\n\t\t\t\t -| ['compiler_generated'] )\n\t\t\t %% Line 590\n\t\t\t <{'error',Es}> when 'true' ->\n\t\t\t\t%% Line 591\n\t\t\t\t( case _18 of\n\t\t\t\t ( <( {'compile',_88,_89,_90,_91,_92,_93,_94,_95,_96,_97,_98,_rec21,_99,_100}\n\t\t\t\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\t\t\t let <_rec19> =\n\t\t\t\t\t call 'erlang':'++'\n\t\t\t\t\t\t (_rec21, Es)\n\t\t\t\t\t in let <_16> =\n\t\t\t\t\t\t call 'erlang':'setelement'\n\t\t\t\t\t\t (13, _18, _rec19)\n\t\t\t\t\t in {'error',_16}\n\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t ( <_101> when 'true' ->\n\t\t\t\t\t ( call ( 'erlang'\n\t\t\t\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t\t(( {'badrecord','compile'}\n\t\t\t\t\t\t -| ['compiler_generated'] ))\n\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t end\n\t\t\t\t -| ['compiler_generated'] )\n\t\t\t ( <_17> when 'true' ->\n\t\t\t\t primop 'match_fail'\n\t\t\t\t ({'case_clause',_17})\n\t\t\t -| ['compiler_generated'] )\n\t\t\t end\n\t in let <_23> =\n\t\t apply %% Line 594\n\t\t\t 'select_passes'/2\n\t\t\t (%% Line 594\n\t\t\t Ps, %% Line 594\n\t\t\t Opts)\n\t\t in %% Line 594\n\t\t [{Mod,F}|_23]\n\t %% Line 595\n\t <[{'src_listing',Ext}|_117],_X_Opts> when 'true' ->\n\t let <_28> =\n\t\t fun (_25,_24) ->\n\t\t %% Line 596\n\t\t apply 'src_listing'/3\n\t\t\t (Ext, _25, _24)\n\t in %% Line 596\n\t\t [{'listing',_28}|[]]\n\t %% Line 597\n\t <[{'listing',Ext}|_118],_X_Opts> when 'true' ->\n\t let <_33> =\n\t\t fun (_30,_29) ->\n\t\t %% Line 598\n\t\t apply 'listing'/3\n\t\t\t (Ext, _30, _29)\n\t in %% Line 598\n\t\t [{'listing',_33}|[]]\n\t %% Line 599\n\t <['done'|_119],_X_Opts> when 'true' ->\n\t %% Line 600\n\t []\n\t %% Line 601\n\t <[{'done',Ext}|_120],Opts> when 'true' ->\n\t %% Line 602\n\t apply 'select_passes'/2\n\t\t ([{'unless','binary',{'listing',Ext}}|[]], Opts)\n\t %% Line 603\n\t <[{'iff',Flag,Pass}|Ps],Opts> when 'true' ->\n\t %% Line 604\n\t apply 'select_cond'/5\n\t\t (Flag, 'true', Pass, Ps, Opts)\n\t %% Line 605\n\t <[{'unless',Flag,Pass}|Ps],Opts> when 'true' ->\n\t %% Line 606\n\t apply 'select_cond'/5\n\t\t (Flag, 'false', Pass, Ps, Opts)\n\t %% Line 607\n\t <[P = {_121,Fun}|Ps],Opts>\n\t when call 'erlang':'is_function'\n\t\t (Fun) ->\n\t let <_34> =\n\t\t apply %% Line 608\n\t\t\t'select_passes'/2\n\t\t (%% Line 608\n\t\t Ps, %% Line 608\n\t\t\t Opts)\n\t in %% Line 608\n\t\t [P|_34]\n\t %% Line 609\n\t <[{'delay',Passes0}|Ps],Opts>\n\t when call 'erlang':'is_list'\n\t\t (Passes0) ->\n\t %% Line 614\n\t case apply 'select_list_passes'/2\n\t\t (Passes0, Opts) of\n\t\t%% Line 615\n\t\t<{'done',Passes}> when 'true' ->\n\t\t %% Line 616\n\t\t [{'delay',Passes}|[]]\n\t\t%% Line 617\n\t\t<{'not_done',Passes}> when 'true' ->\n\t\t let <_35> =\n\t\t\tapply %% Line 618\n\t\t\t 'select_passes'/2\n\t\t\t (%% Line 618\n\t\t\t Ps, %% Line 618\n\t\t\t\t Opts)\n\t\t in %% Line 618\n\t\t\t[{'delay',Passes}|_35]\n\t\t( <_36> when 'true' ->\n\t\t primop 'match_fail'\n\t\t\t ({'case_clause',_36})\n\t\t -| ['compiler_generated'] )\n\t end\n\t %% Line 620\n\t <[P = {_122,Test,Fun}|Ps],Opts>\n\t when try\n\t\t let <_37> =\n\t\t\tcall 'erlang':'is_function'\n\t\t\t (Test)\n\t\t in let <_38> =\n\t\t\t call %% Line 621\n\t\t\t\t 'erlang':%% Line 621\n\t\t\t\t\t 'is_function'\n\t\t\t\t(%% Line 621\n\t\t\t\t Fun)\n\t\t\tin call 'erlang':'and'\n\t\t\t\t(_37, _38)\n\t\tof ->\n\t\t Try\n\t\tcatch ->\n\t\t 'false' ->\n\t let <_39> =\n\t\t apply %% Line 622\n\t\t\t'select_passes'/2\n\t\t (%% Line 622\n\t\t Ps, %% Line 622\n\t\t\t Opts)\n\t in %% Line 622\n\t\t [P|_39]\n\t %% Line 623\n\t <[],_X_Opts> when 'true' ->\n\t %% Line 624\n\t []\n\t %% Line 625\n\t <[List|Ps],Opts>\n\t when call 'erlang':'is_list'\n\t\t (List) ->\n\t %% Line 626\n\t case apply 'select_passes'/2\n\t\t (List, Opts) of\n\t\t%% Line 627\n\t\t<[]> when 'true' ->\n\t\t apply 'select_passes'/2\n\t\t\t(Ps, Opts)\n\t\t%% Line 628\n\t\t when 'true' ->\n\t\t %% Line 629\n\t\t case call 'lists':'last'\n\t\t\t (Nested) of\n\t\t %% Line 630\n\t\t <{'listing',_X_Fun}> when 'true' ->\n\t\t\t Nested\n\t\t %% Line 631\n\t\t <_X_Other> when 'true' ->\n\t\t\t let <_40> =\n\t\t\t apply 'select_passes'/2\n\t\t\t\t (Ps, Opts)\n\t\t\t in call 'erlang':'++'\n\t\t\t\t (Nested, _40)\n\t\t end\n\t end\n\t ( <_44,_43> when 'true' ->\n\t\t( primop 'match_fail'\n\t\t ({'function_clause',_44,_43})\n\t\t -| [{'function_name',{'select_passes',2}}] )\n\t -| ['compiler_generated'] )\n\tend\n'select_cond'/5 =\n %% Line 635\n fun (_4,_3,_2,_1,_0) ->\n\tlet =\n\t call %% Line 636\n\t\t 'erlang':%% Line 636\n\t\t\t 'not'\n\t\t(_3)\n\tin %% Line 637\n\t case call 'lists':'member'\n\t\t (_4, _0) of\n\t %% Line 638\n\t <_12>\n\t\t when call 'erlang':'=:='\n\t\t\t(_12,\n\t\t\t _3) ->\n\t\t apply 'select_passes'/2\n\t\t ([_2|_1], _0)\n\t %% Line 639\n\t <_13>\n\t\t when call 'erlang':'=:='\n\t\t\t(_13,\n\t\t\t ShouldNotBe) ->\n\t\t apply 'select_passes'/2\n\t\t (_1, _0)\n\t ( <_6> when 'true' ->\n\t\t primop 'match_fail'\n\t\t\t({'case_clause',_6})\n\t\t-| ['compiler_generated'] )\n\t end\n'select_list_passes'/2 =\n %% Line 646\n fun (_1,_0) ->\n\t%% Line 647\n\tapply 'select_list_passes_1'/3\n\t (_1, _0, [])\n'select_list_passes_1'/3 =\n %% Line 649\n fun (_2,_1,_0) ->\n\tcase <_2,_1,_0> of\n\t <[{'iff',Flag,Listing = {'listing',_18}}|Ps],Opts,Acc> when 'true' ->\n\t %% Line 650\n\t case call 'lists':'member'\n\t\t (Flag, Opts) of\n\t\t%% Line 651\n\t\t<'true'> when 'true' ->\n\t\t let <_3> =\n\t\t\tcall 'lists':'reverse'\n\t\t\t (Acc, [Listing|[]])\n\t\t in {'done',_3}\n\t\t%% Line 652\n\t\t<'false'> when 'true' ->\n\t\t apply 'select_list_passes_1'/3\n\t\t\t(Ps, Opts, Acc)\n\t\t( <_4> when 'true' ->\n\t\t primop 'match_fail'\n\t\t\t ({'case_clause',_4})\n\t\t -| ['compiler_generated'] )\n\t end\n\t %% Line 654\n\t <[{'iff',Flag,{'done',Ext}}|Ps],Opts,Acc> when 'true' ->\n\t %% Line 655\n\t case call 'lists':'member'\n\t\t (Flag, Opts) of\n\t\t%% Line 656\n\t\t<'false'> when 'true' ->\n\t\t %% Line 657\n\t\t apply 'select_list_passes_1'/3\n\t\t\t(Ps, Opts, Acc)\n\t\t%% Line 658\n\t\t<'true'> when 'true' ->\n\t\t let <_6> =\n\t\t\tcase %% Line 659\n\t\t\t call 'lists':'member'\n\t\t\t\t ('binary', Opts) of\n\t\t\t %% Line 660\n\t\t\t <'false'> when 'true' ->\n\t\t\t call 'lists':'reverse'\n\t\t\t\t (Acc, [{'listing',Ext}|[]])\n\t\t\t %% Line 661\n\t\t\t <'true'> when 'true' ->\n\t\t\t call 'lists':'reverse'\n\t\t\t\t (Acc)\n\t\t\t ( <_5> when 'true' ->\n\t\t\t\t%% Line 659\n\t\t\t\tprimop 'match_fail'\n\t\t\t\t ({'case_clause',_5})\n\t\t\t -| ['compiler_generated'] )\n\t\t\tend\n\t\t in %% Line 659\n\t\t\t{'done',_6}\n\t\t( <_7> when 'true' ->\n\t\t primop 'match_fail'\n\t\t\t ({'case_clause',_7})\n\t\t -| ['compiler_generated'] )\n\t end\n\t %% Line 664\n\t <[{Op = 'iff',Flag,List0}|Ps],Opts,Acc>\n\t when call 'erlang':'is_list'\n\t\t (List0) ->\n\t %% Line 665\n\t case apply 'select_list_passes'/2\n\t\t (List0, Opts) of\n\t\t%% Line 666\n\t\t<{'done',List}> when 'true' ->\n\t\t let <_8> =\n\t\t\tcall 'lists':'reverse'\n\t\t\t (Acc)\n\t\t in let <_9> =\n\t\t\t call 'erlang':'++'\n\t\t\t\t(_8, List)\n\t\t\tin {'done',_9}\n\t\t%% Line 667\n\t\t<{'not_done',List}> when 'true' ->\n\t\t apply 'select_list_passes_1'/3\n\t\t\t(Ps, Opts, [{Op,Flag,List}|Acc])\n\t\t( <_10> when 'true' ->\n\t\t primop 'match_fail'\n\t\t\t ({'case_clause',_10})\n\t\t -| ['compiler_generated'] )\n\t end\n\t %% Line 669\n\t <[{Op = 'unless',Flag,List0}|Ps],Opts,Acc>\n\t when call 'erlang':'is_list'\n\t\t (List0) ->\n\t %% Line 670\n\t case apply 'select_list_passes'/2\n\t\t (List0, Opts) of\n\t\t%% Line 671\n\t\t<{'done',List}> when 'true' ->\n\t\t let <_11> =\n\t\t\tcall 'lists':'reverse'\n\t\t\t (Acc)\n\t\t in let <_12> =\n\t\t\t call 'erlang':'++'\n\t\t\t\t(_11, List)\n\t\t\tin {'done',_12}\n\t\t%% Line 672\n\t\t<{'not_done',List}> when 'true' ->\n\t\t apply 'select_list_passes_1'/3\n\t\t\t(Ps, Opts, [{Op,Flag,List}|Acc])\n\t\t( <_13> when 'true' ->\n\t\t primop 'match_fail'\n\t\t\t ({'case_clause',_13})\n\t\t -| ['compiler_generated'] )\n\t end\n\t %% Line 674\n\t <[P|Ps],Opts,Acc> when 'true' ->\n\t %% Line 675\n\t apply 'select_list_passes_1'/3\n\t\t (Ps, Opts, [P|Acc])\n\t %% Line 676\n\t <[],_19,Acc> when 'true' ->\n\t let <_14> =\n\t\t call %% Line 677\n\t\t 'lists':%% Line 677\n\t\t\t 'reverse'\n\t\t (%% Line 677\n\t\t Acc)\n\t in %% Line 677\n\t\t {'not_done',_14}\n\t ( <_17,_16,_15> when 'true' ->\n\t\t( primop 'match_fail'\n\t\t ({'function_clause',_17,_16,_15})\n\t\t -| [{'function_name',{'select_list_passes_1',3}}] )\n\t -| ['compiler_generated'] )\n\tend\n'standard_passes'/0 =\n %% Line 681\n fun () ->\n\tlet <_0> =\n\t apply %% Line 708\n\t\t 'core_passes'/0\n\t\t()\n\tin %% Line 682\n\t [{'transform_module',( 'transform_module'/2\n\t\t\t\t -| [{'id',{0,0,'-standard_passes/0-fun-0-'}}] )}|%% Line 684\n\t\t\t\t\t\t\t\t\t\t [{'iff','makedep_side_effect',{'makedep_and_output',( 'makedep_and_output'/2\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| [{'id',{0,0,'-standard_passes/0-fun-1-'}}] )}}|%% Line 685\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t [{'iff','makedep',[%% Line 686\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t {'makedep',( 'makedep'/2\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| [{'id',{0,0,'-standard_passes/0-fun-2-'}}] )}|%% Line 687\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t [{'unless','binary',{'makedep_output',( 'makedep_output'/2\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| [{'id',{0,0,'-standard_passes/0-fun-3-'}}] )}}|%% Line 688\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t []]]}|%% Line 689\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t [{'iff','makedep','done'}|%% Line 691\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t [{'iff','dpp',{'listing',[112|[112]]}}|%% Line 692\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t [{'lint_module',( 'lint_module'/2\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t-| [{'id',{0,0,'-standard_passes/0-fun-4-'}}] )}|%% Line 693\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t [{'iff','P',{'src_listing',[80]}}|%% Line 694\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t [{'iff','to_pp',{'done',[80]}}|%% Line 696\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t [{'iff','dabstr',{'listing',[97|[98|[115|[116|[114]]]]]}}|%% Line 697\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t [{'iff','debug_info',{'save_abstract_code',( 'save_abstract_code'/2\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| [{'id',{0,0,'-standard_passes/0-fun-5-'}}] )}}|%% Line 699\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t [{'expand_records',( 'expand_records'/2\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t-| [{'id',{0,0,'-standard_passes/0-fun-6-'}}] )}|%% Line 700\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t [{'iff','dexp',{'listing',[101|[120|[112|[97|[110|[100]]]]]]}}|%% Line 701\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t[{'iff','E',{'src_listing',[69]}}|%% Line 702\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t [{'iff','to_exp',{'done',[69]}}|%% Line 705\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t [{'core',( 'core'/2\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| [{'id',{0,0,'-standard_passes/0-fun-7-'}}] )}|%% Line 706\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t [{'iff','dcore',{'listing',[99|[111|[114|[101]]]]}}|%% Line 707\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t [{'iff','to_core0',{'done',[99|[111|[114|[101]]]]}}|_0]]]]]]]]]]]]]]]]]\n'core_passes'/0 =\n %% Line 710\n fun () ->\n\tlet <_0> =\n\t apply %% Line 728\n\t\t 'kernel_passes'/0\n\t\t()\n\tin %% Line 712\n\t [{'iff','clint0',{'core_lint_module',( 'core_lint_module'/2\n\t\t\t\t\t\t -| [{'id',{0,0,'-core_passes/0-fun-0-'}}] )}}|%% Line 713\n\t\t\t\t\t\t\t\t\t\t\t\t [{'delay',%% Line 714\n\t\t\t\t\t\t\t\t\t\t\t\t\t [{'unless','no_copt',%% Line 715\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t[{'core_old_inliner',( 'test_old_inliner'/1\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| [{'id',{0,0,'-core_passes/0-fun-2-'}}] ),( 'core_old_inliner'/2\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| [{'id',{0,0,'-core_passes/0-fun-1-'}}] )}|%% Line 716\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t [{'iff','doldinline',{'listing',[111|[108|[100|[105|[110|[108|[105|[110|[101]]]]]]]]]}}|%% Line 717\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t [{'unless','no_fold',{'pass','sys_core_fold'}}|%% Line 718\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t [{'iff','dcorefold',{'listing',[99|[111|[114|[101|[102|[111|[108|[100]]]]]]]]}}|%% Line 719\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t [{'core_inline_module',( 'test_core_inliner'/1\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| [{'id',{0,0,'-core_passes/0-fun-4-'}}] ),( 'core_inline_module'/2\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t-| [{'id',{0,0,'-core_passes/0-fun-3-'}}] )}|%% Line 720\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t [{'iff','dinline',{'listing',[105|[110|[108|[105|[110|[101]]]]]]}}|%% Line 721\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t[{'core_fold_after_inlining',( 'test_any_inliner'/1\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| [{'id',{0,0,'-core_passes/0-fun-6-'}}] ),%% Line 722\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t ( 'core_fold_module_after_inlining'/2\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| [{'id',{0,0,'-core_passes/0-fun-5-'}}] )}|%% Line 723\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t [{'iff','dcopt',{'listing',[99|[111|[112|[116]]]]}}|%% Line 724\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t [{'unless','no_alias',{'pass','sys_core_alias'}}|%% Line 725\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t [{'iff','dalias',{'listing',[99|[111|[114|[101|[95|[97|[108|[105|[97|[115]]]]]]]]]]}}|%% Line 726\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t [{'core_transforms',( 'core_transforms'/2\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| [{'id',{0,0,'-core_passes/0-fun-7-'}}] )}|[]]]]]]]]]]]]}|%% Line 727\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t [{'iff','to_core',{'done',[99|[111|[114|[101]]]]}}]]}|_0]]\n'kernel_passes'/0 =\n %% Line 730\n fun () ->\n\tlet <_0> =\n\t apply %% Line 746\n\t\t 'asm_passes'/0\n\t\t()\n\tin %% Line 732\n\t [{'pass','sys_core_bsm'}|%% Line 733\n\t\t\t\t [{'iff','dcbsm',{'listing',[99|[111|[114|[101|[95|[98|[115|[109]]]]]]]]}}|%% Line 734\n\t\t\t\t\t\t\t\t\t\t\t\t\t [{'pass','sys_core_dsetel'}|%% Line 735\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t [{'iff','dsetel',{'listing',[100|[115|[101|[116|[101|[108]]]]]]}}|%% Line 737\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t [{'iff','clint',{'core_lint_module',( 'core_lint_module'/2\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| [{'id',{0,0,'-kernel_passes/0-fun-0-'}}] )}}|%% Line 738\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t [{'iff','core',{'save_core_code',( 'save_core_code'/2\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| [{'id',{0,0,'-kernel_passes/0-fun-1-'}}] )}}|%% Line 741\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t [{'v3_kernel',( 'v3_kernel'/2\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| [{'id',{0,0,'-kernel_passes/0-fun-2-'}}] )}|%% Line 742\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t [{'iff','dkern',{'listing',[107|[101|[114|[110|[101|[108]]]]]]}}|%% Line 743\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t [{'iff','to_kernel',{'done',[107|[101|[114|[110|[101|[108]]]]]]}}|%% Line 744\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t[{'pass','v3_codegen'}|%% Line 745\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t [{'iff','dcg',{'listing',[99|[111|[100|[101|[103|[101|[110]]]]]]]}}|_0]]]]]]]]]]]\n'asm_passes'/0 =\n %% Line 748\n fun () ->\n\tlet <_0> =\n\t apply %% Line 797\n\t\t 'binary_passes'/0\n\t\t()\n\tin %% Line 750\n\t [{'delay',%% Line 751\n\t\t [{'pass','beam_a'}|%% Line 752\n\t\t\t\t\t [{'iff','da',{'listing',[97]}}|%% Line 753\n\t\t\t\t\t\t\t\t\t[{'unless','no_postopt',%% Line 754\n\t\t\t\t\t\t\t\t\t\t\t\t[{'unless','no_reorder',{'pass','beam_reorder'}}|%% Line 755\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t [{'iff','dre',{'listing',[114|[101|[111|[114|[100|[101|[114]]]]]]]}}|%% Line 756\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t [{'pass','beam_block'}|%% Line 757\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t [{'iff','dblk',{'listing',[98|[108|[111|[99|[107]]]]]}}|%% Line 758\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t [{'unless','no_except',{'pass','beam_except'}}|%% Line 759\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t [{'iff','dexcept',{'listing',[101|[120|[99|[101|[112|[116]]]]]]}}|%% Line 760\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t [{'unless','no_bs_opt',{'pass','beam_bs'}}|%% Line 761\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t [{'iff','dbs',{'listing',[98|[115]]}}|%% Line 762\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t [{'unless','no_topt',{'pass','beam_type'}}|%% Line 763\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t [{'iff','dtype',{'listing',[116|[121|[112|[101]]]]}}|%% Line 764\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t [{'pass','beam_split'}|%% Line 765\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t [{'iff','dsplit',{'listing',[115|[112|[108|[105|[116]]]]]}}|%% Line 766\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t [{'unless','no_dead',{'pass','beam_dead'}}|%% Line 767\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t [{'iff','ddead',{'listing',[100|[101|[97|[100]]]]}}|%% Line 768\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t [{'unless','no_jopt',{'pass','beam_jump'}}|%% Line 769\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t [{'iff','djmp',{'listing',[106|[117|[109|[112]]]]}}|%% Line 770\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t[{'unless','no_peep_opt',{'pass','beam_peep'}}|%% Line 771\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t [{'iff','dpeep',{'listing',[112|[101|[101|[112]]]]}}|%% Line 772\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t [{'pass','beam_clean'}|%% Line 773\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t [{'iff','dclean',{'listing',[99|[108|[101|[97|[110]]]]]}}|%% Line 774\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t [{'unless','no_bsm_opt',{'pass','beam_bsm'}}|%% Line 775\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t [{'iff','dbsm',{'listing',[98|[115|[109]]]}}|%% Line 776\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t [{'unless','no_recv_opt',{'pass','beam_receive'}}|%% Line 777\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t [{'iff','drecv',{'listing',[114|[101|[99|[118]]]]}}|%% Line 778\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t [{'unless','no_record_opt',{'pass','beam_record'}}|%% Line 779\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t[{'iff','drecord',{'listing',[114|[101|[99|[111|[114|[100]]]]]]}}|%% Line 780\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t [{'unless','no_blk2',{'block2',( 'block2'/2\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| [{'id',{0,0,'-asm_passes/0-fun-0-'}}] )}}|%% Line 781\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t[{'iff','dblk2',{'listing',[98|[108|[111|[99|[107|[50]]]]]]}}|[{'unless','no_stack_trimming',{'pass','beam_trim'}}|[{'iff','dtrim',{'listing',[116|[114|[105|[109]]]]}}|[{'pass','beam_flatten'}]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]}|%% Line 788\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t [{'iff','no_postopt',[{'pass','beam_clean'}]}|[{'pass','beam_z'}|[{'iff','dz',{'listing',[122]}}|[{'iff','dopt',{'listing',[111|[112|[116|[105|[109|[105|[122|[101]]]]]]]]}}|[{'iff','S',{'listing',[83]}}|[{'iff','to_asm',{'done',[83]}}]]]]]]]]]}|%% Line 795\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t [{'pass','beam_validator'}|%% Line 796\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t [{'beam_asm',( 'beam_asm'/2\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t-| [{'id',{0,0,'-asm_passes/0-fun-1-'}}] )}|_0]]]\n'binary_passes'/0 =\n %% Line 799\n fun () ->\n\t%% Line 800\n\t[{'iff','to_dis',{'to_dis',( 'to_dis'/2\n\t\t\t\t -| [{'id',{0,0,'-binary_passes/0-fun-0-'}}] )}}|%% Line 801\n\t\t\t\t\t\t\t\t\t\t [{'native_compile',( 'test_native'/1\n\t\t\t\t\t\t\t\t\t\t\t\t\t -| [{'id',{0,0,'-binary_passes/0-fun-2-'}}] ),( 'native_compile'/2\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| [{'id',{0,0,'-binary_passes/0-fun-1-'}}] )}|%% Line 802\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t [{'unless','binary',{'save_binary',( 'not_werror'/1\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| [{'id',{0,0,'-binary_passes/0-fun-4-'}}] ),( 'save_binary'/2\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t -| [{'id',{0,0,'-binary_passes/0-fun-3-'}}] )}}|%% Line 803\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t []]]]\n'remove_file'/2 =\n %% Line 810\n fun (_1,_0) ->\n\t%% Line 811\n\t( case _0 of\n\t ( <( {'compile',_7,_8,_9,_10,_rec22,_11,_12,_13,_14,_15,_16,_17,_18,_19}\n\t\t -| ['result_not_wanted','compiler_generated'] )> when 'true' ->\n\t\t do ( call ( 'file'\n\t\t\t -| ['result_not_wanted'] ):( 'delete'\n\t\t\t\t\t\t\t -| ['result_not_wanted'] )\n\t\t\t (_rec22)\n\t\t\t-| ['result_not_wanted'] )\n\t\t %% Line 812\n\t\t {'ok',_1,_0}\n\t -| ['compiler_generated'] )\n\t ( <_20> when 'true' ->\n\t\t ( call ( 'erlang'\n\t\t\t -| ['result_not_wanted','compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t\t\t -| ['result_not_wanted','compiler_generated'] )\n\t\t\t(( {'badrecord','compile'}\n\t\t\t -| ['result_not_wanted','compiler_generated'] ))\n\t\t -| ['result_not_wanted','compiler_generated'] )\n\t -| ['compiler_generated'] )\n\t end\n\t -| ['compiler_generated'] )\n'preprocess_asm_forms'/1 =\n %% Line 822\n fun (_0) ->\n\t%% Line 825\n\t( case apply 'collect_asm'/2\n\t\t (_0, {'asm_module','undefined','undefined','undefined',[],'undefined','undefined',[]}) of\n\t ( <( {'asm_module',_rec23,_16,_17,_18,_19,_20,_21}\n\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t {_rec23,%% Line 826\n\t\t\t {_rec23,_16,_21,_18,_17}}\n\t -| ['compiler_generated'] )\n\t ( <_22> when 'true' ->\n\t\t ( call ( 'erlang'\n\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t(( {'badrecord','asm_module'}\n\t\t\t -| ['compiler_generated'] ))\n\t\t -| ['compiler_generated'] )\n\t -| ['compiler_generated'] )\n\t end\n\t -| ['compiler_generated'] )\n'collect_asm'/2 =\n %% Line 832\n fun (_1,_0) ->\n\tcase <_1,_0> of\n\t <[],R> when 'true' ->\n\t %% Line 833\n\t ( case R of\n\t\t ( <( {'asm_module',_49,_50,_51,_52,_rec29,_53,_54}\n\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\tcase _rec29 of\n\t\t\t %% Line 834\n\t\t\t <'undefined'> when 'true' ->\n\t\t\t %% Line 835\n\t\t\t R\n\t\t\t %% Line 836\n\t\t\t <{A,B,C}> when 'true' ->\n\t\t\t let <_rec30> =\n\t\t\t\t call %% Line 837\n\t\t\t\t 'erlang':%% Line 837\n\t\t\t\t\t\t'++'\n\t\t\t\t (_52, %% Line 838\n\t\t\t\t\t [{'function',A,B,C,_53}|[]])\n\t\t\t in %% Line 837\n\t\t\t\t call 'erlang':'setelement'\n\t\t\t\t (5, R, _rec30)\n\t\t\t ( <_11> when 'true' ->\n\t\t\t\tprimop 'match_fail'\n\t\t\t\t ({'case_clause',_11})\n\t\t\t -| ['compiler_generated'] )\n\t\t\tend\n\t\t -| ['compiler_generated'] )\n\t\t ( <_55> when 'true' ->\n\t\t\t( call ( 'erlang'\n\t\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t (( {'badrecord','asm_module'}\n\t\t\t\t -| ['compiler_generated'] ))\n\t\t\t -| ['compiler_generated'] )\n\t\t -| ['compiler_generated'] )\n\t\tend\n\t\t-| ['compiler_generated'] )\n\t %% Line 840\n\t <[{'module',M}|Rest],R> when 'true' ->\n\t %% Line 841\n\t case R of\n\t\t<{'asm_module',_78,_79,_80,_81,_82,_83,_84}> when 'true' ->\n\t\t let <_14> =\n\t\t\tcall 'erlang':'setelement'\n\t\t\t (2, R, M)\n\t\t in apply 'collect_asm'/2\n\t\t\t (Rest, _14)\n\t\t( <_85> when 'true' ->\n\t\t ( call ( 'erlang'\n\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t (( {'badrecord','asm_module'}\n\t\t\t -| ['compiler_generated'] ))\n\t\t\t-| ['compiler_generated'] )\n\t\t -| ['compiler_generated'] )\n\t end\n\t %% Line 842\n\t <[{'exports',M}|Rest],R> when 'true' ->\n\t %% Line 843\n\t case R of\n\t\t<{'asm_module',_86,_87,_88,_89,_90,_91,_92}> when 'true' ->\n\t\t let <_17> =\n\t\t\tcall 'erlang':'setelement'\n\t\t\t (3, R, M)\n\t\t in apply 'collect_asm'/2\n\t\t\t (Rest, _17)\n\t\t( <_93> when 'true' ->\n\t\t ( call ( 'erlang'\n\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t (( {'badrecord','asm_module'}\n\t\t\t -| ['compiler_generated'] ))\n\t\t\t-| ['compiler_generated'] )\n\t\t -| ['compiler_generated'] )\n\t end\n\t %% Line 844\n\t <[{'labels',M}|Rest],R> when 'true' ->\n\t %% Line 845\n\t case R of\n\t\t<{'asm_module',_94,_95,_96,_97,_98,_99,_100}> when 'true' ->\n\t\t let <_20> =\n\t\t\tcall 'erlang':'setelement'\n\t\t\t (4, R, M)\n\t\t in apply 'collect_asm'/2\n\t\t\t (Rest, _20)\n\t\t( <_101> when 'true' ->\n\t\t ( call ( 'erlang'\n\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t (( {'badrecord','asm_module'}\n\t\t\t -| ['compiler_generated'] ))\n\t\t\t-| ['compiler_generated'] )\n\t\t -| ['compiler_generated'] )\n\t end\n\t %% Line 846\n\t <[{'function',A,B,C}|Rest],R> when 'true' ->\n\t %% Line 847\n\t ( case R of\n\t\t ( <( {'asm_module',_102,_103,_104,_105,_rec37,_106,_107}\n\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\tlet <_31> =\n\t\t\t case _rec37 of\n\t\t\t %% Line 848\n\t\t\t <'undefined'> when 'true' ->\n\t\t\t\t %% Line 849\n\t\t\t\t R\n\t\t\t %% Line 850\n\t\t\t <{A0,B0,C0}> when 'true' ->\n\t\t\t\t let <_rec38> =\n\t\t\t\t call %% Line 851\n\t\t\t\t\t 'erlang':%% Line 851\n\t\t\t\t\t\t '++'\n\t\t\t\t\t (_105, %% Line 852\n\t\t\t\t\t\t [{'function',A0,B0,C0,_106}|[]])\n\t\t\t\t in %% Line 851\n\t\t\t\t call 'erlang':'setelement'\n\t\t\t\t\t (5, R, _rec38)\n\t\t\t ( <_30> when 'true' ->\n\t\t\t\t primop 'match_fail'\n\t\t\t\t\t({'case_clause',_30})\n\t\t\t\t-| ['compiler_generated'] )\n\t\t\t end\n\t\t\tin let <_rec42> = {%% Line 854\n\t\t\t\t A,%% Line 854\n\t\t\t\t B,%% Line 854\n\t\t\t\t C}\n\t\t\t in %% Line 854\n\t\t\t\tcase _31 of\n\t\t\t\t <{'asm_module',_131,_132,_133,_134,_135,_136,_137}> when 'true' ->\n\t\t\t\t let <_35> =\n\t\t\t\t\t call 'erlang':'setelement'\n\t\t\t\t\t (7, _31, [])\n\t\t\t\t in let <_37> =\n\t\t\t\t\t call 'erlang':'setelement'\n\t\t\t\t\t\t (6, _35, _rec42)\n\t\t\t\t\t in apply 'collect_asm'/2\n\t\t\t\t\t\t (Rest, _37)\n\t\t\t\t ( <_138> when 'true' ->\n\t\t\t\t\t( call ( 'erlang'\n\t\t\t\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t (( {'badrecord','asm_module'}\n\t\t\t\t\t\t -| ['compiler_generated'] ))\n\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\tend\n\t\t -| ['compiler_generated'] )\n\t\t ( <_108> when 'true' ->\n\t\t\t( call ( 'erlang'\n\t\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t (( {'badrecord','asm_module'}\n\t\t\t\t -| ['compiler_generated'] ))\n\t\t\t -| ['compiler_generated'] )\n\t\t -| ['compiler_generated'] )\n\t\tend\n\t\t-| ['compiler_generated'] )\n\t %% Line 855\n\t <[{'attributes',Attr}|Rest],R> when 'true' ->\n\t %% Line 856\n\t case R of\n\t\t<{'asm_module',_139,_140,_141,_142,_143,_144,_145}> when 'true' ->\n\t\t let <_40> =\n\t\t\tcall 'erlang':'setelement'\n\t\t\t (8, R, Attr)\n\t\t in apply 'collect_asm'/2\n\t\t\t (Rest, _40)\n\t\t( <_146> when 'true' ->\n\t\t ( call ( 'erlang'\n\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t (( {'badrecord','asm_module'}\n\t\t\t -| ['compiler_generated'] ))\n\t\t\t-| ['compiler_generated'] )\n\t\t -| ['compiler_generated'] )\n\t end\n\t %% Line 857\n\t <[X|Rest],R> when 'true' ->\n\t %% Line 858\n\t ( case R of\n\t\t ( <( {'asm_module',_147,_148,_149,_150,_151,_rec47,_152}\n\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\tlet <_rec45> =\n\t\t\t call 'erlang':'++'\n\t\t\t\t(_rec47, [X|[]])\n\t\t\tin let <_46> =\n\t\t\t\tcall 'erlang':'setelement'\n\t\t\t\t (7, R, _rec45)\n\t\t\t in apply 'collect_asm'/2\n\t\t\t\t (Rest, _46)\n\t\t -| ['compiler_generated'] )\n\t\t ( <_153> when 'true' ->\n\t\t\t( call ( 'erlang'\n\t\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t (( {'badrecord','asm_module'}\n\t\t\t\t -| ['compiler_generated'] ))\n\t\t\t -| ['compiler_generated'] )\n\t\t -| ['compiler_generated'] )\n\t\tend\n\t\t-| ['compiler_generated'] )\n\t ( <_48,_47> when 'true' ->\n\t\t( primop 'match_fail'\n\t\t ({'function_clause',_48,_47})\n\t\t -| [{'function_name',{'collect_asm',2}}] )\n\t -| ['compiler_generated'] )\n\tend\n'beam_consult_asm'/2 =\n %% Line 860\n fun (_1,_0) ->\n\t%% Line 861\n\t( case _0 of\n\t ( <( {'compile',_24,_25,_26,_rec48,_27,_28,_29,_30,_31,_32,_33,_34,_35,_36}\n\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t case call 'file':'consult'\n\t\t\t (_rec48) of\n\t\t %% Line 862\n\t\t <{'ok',Forms0}> when 'true' ->\n\t\t\tlet =\n\t\t\t call %% Line 863\n\t\t\t\t 'epp':%% Line 863\n\t\t\t\t 'read_encoding'\n\t\t\t\t(_rec48)\n\t\t\tin %% Line 864\n\t\t\t case apply 'preprocess_asm_forms'/1\n\t\t\t\t (Forms0) of\n\t\t\t <{Module,Forms}> when 'true' ->\n\t\t\t\t let <_9> =\n\t\t\t\t call %% Line 865\n\t\t\t\t\t 'erlang':%% Line 865\n\t\t\t\t\t\t 'setelement'\n\t\t\t\t\t (%% Line 865\n\t\t\t\t\t 12, _0, %% Line 865\n\t\t\t\t\t\t Encoding)\n\t\t\t\t in let <_11> =\n\t\t\t\t\t call %% Line 865\n\t\t\t\t\t 'erlang':%% Line 865\n\t\t\t\t\t\t\t'setelement'\n\t\t\t\t\t (%% Line 865\n\t\t\t\t\t 7, _9, %% Line 865\n\t\t\t\t\t\t Module)\n\t\t\t\t in %% Line 865\n\t\t\t\t\t {'ok',Forms,_11}\n\t\t\t ( <_7> when 'true' ->\n\t\t\t\t primop 'match_fail'\n\t\t\t\t\t({'badmatch',_7})\n\t\t\t\t-| ['compiler_generated'] )\n\t\t\t end\n\t\t %% Line 866\n\t\t <{'error',E}> when 'true' ->\n\t\t\tlet =\n\t\t\t [%% Line 867\n\t\t\t {_rec48,[{'none','compile',{'open',E}}|[]]}|%% Line 867\n\t\t\t\t\t\t\t\t\t []]\n\t\t\tin let <_rec52> =\n\t\t\t\tcall %% Line 868\n\t\t\t\t 'erlang':%% Line 868\n\t\t\t\t\t '++'\n\t\t\t\t (_34, %% Line 868\n\t\t\t\t\t Es)\n\t\t\t in let <_20> =\n\t\t\t\t call %% Line 868\n\t\t\t\t\t 'erlang':%% Line 868\n\t\t\t\t\t\t 'setelement'\n\t\t\t\t\t(%% Line 868\n\t\t\t\t\t 13, _0, %% Line 868\n\t\t\t\t\t\t _rec52)\n\t\t\t\tin %% Line 868\n\t\t\t\t {'error',_20}\n\t\t ( <_21> when 'true' ->\n\t\t\t primop 'match_fail'\n\t\t\t ({'case_clause',_21})\n\t\t -| ['compiler_generated'] )\n\t\t end\n\t -| ['compiler_generated'] )\n\t ( <_37> when 'true' ->\n\t\t ( call ( 'erlang'\n\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t(( {'badrecord','compile'}\n\t\t\t -| ['compiler_generated'] ))\n\t\t -| ['compiler_generated'] )\n\t -| ['compiler_generated'] )\n\t end\n\t -| ['compiler_generated'] )\n'get_module_name_from_asm'/2 =\n %% Line 871\n fun (_1,_0) ->\n\tcase <_1,_0> of\n\t when 'true' ->\n\t %% Line 872\n\t case St of\n\t\t<{'compile',_11,_12,_13,_14,_15,_16,_17,_18,_19,_20,_21,_22,_23,_24}> when 'true' ->\n\t\t let <_4> =\n\t\t\tcall 'erlang':'setelement'\n\t\t\t (7, St, Mod)\n\t\t in {'ok',Asm,_4}\n\t\t( <_25> when 'true' ->\n\t\t ( call ( 'erlang'\n\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t (( {'badrecord','compile'}\n\t\t\t -| ['compiler_generated'] ))\n\t\t\t-| ['compiler_generated'] )\n\t\t -| ['compiler_generated'] )\n\t end\n\t %% Line 873\n\t when 'true' ->\n\t %% Line 875\n\t {'ok',Asm,St}\n\tend\n'read_beam_file'/2 =\n %% Line 877\n fun (_1,_0) ->\n\t%% Line 878\n\t( case _0 of\n\t ( <( {'compile',_30,_31,_32,_rec56,_33,_34,_35,_36,_37,_38,_39,_40,_41,_42}\n\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t case call 'file':'read_file'\n\t\t\t (_rec56) of\n\t\t %% Line 879\n\t\t <{'ok',Beam}> when 'true' ->\n\t\t\t%% Line 881\n\t\t\tcase apply 'no_native_compilation'/2\n\t\t\t\t (_rec56, _0) of\n\t\t\t %% Line 882\n\t\t\t <'true'> when 'true' ->\n\t\t\t let <_9> =\n\t\t\t\t call %% Line 883\n\t\t\t\t 'erlang':%% Line 883\n\t\t\t\t\t\t'setelement'\n\t\t\t\t (%% Line 883\n\t\t\t\t 7, _0, %% Line 883\n\t\t\t\t\t 'none')\n\t\t\t in %% Line 883\n\t\t\t\t {'ok','none',_9}\n\t\t\t %% Line 884\n\t\t\t <'false'> when 'true' ->\n\t\t\t let <_10> =\n\t\t\t\t call %% Line 885\n\t\t\t\t 'filename':%% Line 885\n\t\t\t\t\t\t 'basename'\n\t\t\t\t (_rec56)\n\t\t\t in let =\n\t\t\t\t call %% Line 885\n\t\t\t\t\t 'filename':%% Line 885\n\t\t\t\t\t\t 'rootname'\n\t\t\t\t\t (_10)\n\t\t\t\t in let =\n\t\t\t\t\t call %% Line 886\n\t\t\t\t\t 'erlang':%% Line 886\n\t\t\t\t\t\t\t'list_to_atom'\n\t\t\t\t\t (%% Line 886\n\t\t\t\t\t Mod0)\n\t\t\t\t in let <_14> =\n\t\t\t\t\t call %% Line 887\n\t\t\t\t\t\t 'erlang':%% Line 887\n\t\t\t\t\t\t\t 'setelement'\n\t\t\t\t\t\t (%% Line 887\n\t\t\t\t\t\t 7, _0, %% Line 887\n\t\t\t\t\t\t\t Mod)\n\t\t\t\t\t in let <_16> =\n\t\t\t\t\t\t call %% Line 887\n\t\t\t\t\t\t 'erlang':%% Line 887\n\t\t\t\t\t\t\t\t'setelement'\n\t\t\t\t\t\t (%% Line 887\n\t\t\t\t\t\t 6, _14, _rec56)\n\t\t\t\t\t in %% Line 887\n\t\t\t\t\t\t {'ok',Beam,_16}\n\t\t\t ( <_17> when 'true' ->\n\t\t\t\tprimop 'match_fail'\n\t\t\t\t ({'case_clause',_17})\n\t\t\t -| ['compiler_generated'] )\n\t\t\tend\n\t\t %% Line 889\n\t\t <{'error',E}> when 'true' ->\n\t\t\tlet =\n\t\t\t [%% Line 890\n\t\t\t {_rec56,[{'none','compile',{'open',E}}|[]]}|%% Line 890\n\t\t\t\t\t\t\t\t\t []]\n\t\t\tin let <_rec61> =\n\t\t\t\tcall %% Line 891\n\t\t\t\t 'erlang':%% Line 891\n\t\t\t\t\t '++'\n\t\t\t\t (_40, %% Line 891\n\t\t\t\t\t Es)\n\t\t\t in let <_26> =\n\t\t\t\t call %% Line 891\n\t\t\t\t\t 'erlang':%% Line 891\n\t\t\t\t\t\t 'setelement'\n\t\t\t\t\t(%% Line 891\n\t\t\t\t\t 13, _0, %% Line 891\n\t\t\t\t\t\t _rec61)\n\t\t\t\tin %% Line 891\n\t\t\t\t {'error',_26}\n\t\t ( <_27> when 'true' ->\n\t\t\t primop 'match_fail'\n\t\t\t ({'case_clause',_27})\n\t\t -| ['compiler_generated'] )\n\t\t end\n\t -| ['compiler_generated'] )\n\t ( <_43> when 'true' ->\n\t\t ( call ( 'erlang'\n\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t(( {'badrecord','compile'}\n\t\t\t -| ['compiler_generated'] ))\n\t\t -| ['compiler_generated'] )\n\t -| ['compiler_generated'] )\n\t end\n\t -| ['compiler_generated'] )\n'get_module_name_from_beam'/2 =\n %% Line 894\n fun (_1,_0) ->\n\t%% Line 895\n\tcase call 'beam_lib':'info'\n\t\t (_1) of\n\t %% Line 896\n\t <{'error','beam_lib',Error}> when 'true' ->\n\t let =\n\t\t [%% Line 897\n\t\t {[40|[40|[102|[111|[114|[109|[115|[41|[41]]]]]]]]],[{'none','beam_lib',Error}|[]]}|%% Line 897\n\t\t\t\t\t\t\t\t\t\t\t\t []]\n\t in %% Line 898\n\t\t ( case _0 of\n\t\t ( <( {'compile',_16,_17,_18,_19,_20,_21,_22,_23,_24,_25,_26,_rec66,_27,_28}\n\t\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\t let <_rec64> =\n\t\t\t\tcall 'erlang':'++'\n\t\t\t\t (_rec66, Es)\n\t\t\t in let <_8> =\n\t\t\t\t call 'erlang':'setelement'\n\t\t\t\t\t(13, _0, _rec64)\n\t\t\t\tin {'error',_8}\n\t\t\t-| ['compiler_generated'] )\n\t\t ( <_29> when 'true' ->\n\t\t\t ( call ( 'erlang'\n\t\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t (( {'badrecord','compile'}\n\t\t\t\t -| ['compiler_generated'] ))\n\t\t\t -| ['compiler_generated'] )\n\t\t\t-| ['compiler_generated'] )\n\t\t end\n\t\t -| ['compiler_generated'] )\n\t %% Line 899\n\t when 'true' ->\n\t %% Line 900\n\t case call 'lists':'keyfind'\n\t\t ('module', 1, Info) of\n\t\t<{'module',Mod}> when 'true' ->\n\t\t %% Line 901\n\t\t case _0 of\n\t\t <{'compile',_45,_46,_47,_48,_49,_50,_51,_52,_53,_54,_55,_56,_57,_58}> when 'true' ->\n\t\t\t let <_12> =\n\t\t\t call 'erlang':'setelement'\n\t\t\t\t (7, _0, Mod)\n\t\t\t in {'ok',_1,_12}\n\t\t ( <_59> when 'true' ->\n\t\t\t ( call ( 'erlang'\n\t\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t (( {'badrecord','compile'}\n\t\t\t\t -| ['compiler_generated'] ))\n\t\t\t -| ['compiler_generated'] )\n\t\t\t-| ['compiler_generated'] )\n\t\t end\n\t\t( <_9> when 'true' ->\n\t\t primop 'match_fail'\n\t\t\t ({'badmatch',_9})\n\t\t -| ['compiler_generated'] )\n\t end\n\tend\n'no_native_compilation'/2 =\n %% Line 904\n fun (_1,_0) ->\n\tcase <_1,_0> of\n\t when 'true' ->\n\t %% Line 905\n\t case call 'beam_lib':'chunks'\n\t\t (BeamFile, [[67|[73|[110|[102]]]]]) of\n\t\t%% Line 906\n\t\t<{'ok',{_24,[{[67|[73|[110|[102]]]],Term0}|[]]}}> when 'true' ->\n\t\t let =\n\t\t\tcall %% Line 907\n\t\t\t 'erlang':%% Line 907\n\t\t\t\t 'binary_to_term'\n\t\t\t (%% Line 907\n\t\t\t Term0)\n\t\t in let <_3> =\n\t\t\t call %% Line 911\n\t\t\t\t 'proplists':%% Line 911\n\t\t\t\t\t 'get_value'\n\t\t\t\t(%% Line 911\n\t\t\t\t 'options', %% Line 911\n\t\t\t\t\t Term, %% Line 911\n\t\t\t\t\t\t [])\n\t\t\tin let =\n\t\t\t\tcall %% Line 911\n\t\t\t\t 'erlang':%% Line 911\n\t\t\t\t\t '++'\n\t\t\t\t (_3, %% Line 911\n\t\t\t\t\t Opts0)\n\t\t\t in %% Line 912\n\t\t\t\t( case call 'lists':'member'\n\t\t\t\t\t ('no_new_funs', Opts) of\n\t\t\t\t ( <( 'true'\n\t\t\t\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\t\t\t 'true'\n\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t ( <( 'false'\n\t\t\t\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\t\t\t let <_6> =\n\t\t\t\t\t apply 'is_native_enabled'/1\n\t\t\t\t\t\t (Opts)\n\t\t\t\t\t in call 'erlang':'not'\n\t\t\t\t\t\t (_6)\n\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t ( <_5> when 'true' ->\n\t\t\t\t\t ( call ( 'erlang'\n\t\t\t\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t\t(( {( 'badarg'\n\t\t\t\t\t\t -| ['compiler_generated'] ),_5}\n\t\t\t\t\t\t -| ['compiler_generated'] ))\n\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t end\n\t\t\t\t -| ['compiler_generated'] )\n\t\t%% Line 913\n\t\t<_25> when 'true' ->\n\t\t 'false'\n\t end\n\t ( <_10,_9> when 'true' ->\n\t\t( primop 'match_fail'\n\t\t ({'function_clause',_10,_9})\n\t\t -| [{'function_name',{'no_native_compilation',2}}] )\n\t -| ['compiler_generated'] )\n\tend\n'parse_module'/2 =\n %% Line 916\n fun (_1,_0) ->\n\t%% Line 917\n\tcase apply 'do_parse_module'/2\n\t\t ('utf8', _0) of\n\t %% Line 918\n\t when 'true' ->\n\t %% Line 919\n\t Ret\n\t %% Line 920\n\t when 'true' ->\n\t %% Line 921\n\t Ret\n\t %% Line 922\n\t <{'invalid_unicode',File,Line}> when 'true' ->\n\t %% Line 923\n\t case apply 'do_parse_module'/2\n\t\t ('latin1', _0) of\n\t\t%% Line 924\n\t\t<{'ok',Code,St}> when 'true' ->\n\t\t let =\n\t\t\t[%% Line 925\n\t\t\t {File,[{Line,'compile','reparsing_invalid_unicode'}|[]]}|%% Line 925\n\t\t\t\t\t\t\t\t\t\t []]\n\t\t in %% Line 926\n\t\t\t( case St of\n\t\t\t ( <( {'compile',_23,_24,_25,_26,_27,_28,_29,_30,_31,_32,_33,_34,_rec70,_35}\n\t\t\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\t\t let <_rec68> =\n\t\t\t\t call 'erlang':'++'\n\t\t\t\t\t (Es, _rec70)\n\t\t\t\t in let <_8> =\n\t\t\t\t\t call 'erlang':'setelement'\n\t\t\t\t\t (14, St, _rec68)\n\t\t\t\t in {'ok',Code,_8}\n\t\t\t -| ['compiler_generated'] )\n\t\t\t ( <_36> when 'true' ->\n\t\t\t\t ( call ( 'erlang'\n\t\t\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t(( {'badrecord','compile'}\n\t\t\t\t\t -| ['compiler_generated'] ))\n\t\t\t\t -| ['compiler_generated'] )\n\t\t\t -| ['compiler_generated'] )\n\t\t\t end\n\t\t\t -| ['compiler_generated'] )\n\t\t%% Line 927\n\t\t<{'error',St}> when 'true' ->\n\t\t let =\n\t\t\t[%% Line 928\n\t\t\t {File,[{Line,'compile','reparsing_invalid_unicode'}|[]]}|%% Line 928\n\t\t\t\t\t\t\t\t\t\t []]\n\t\t in %% Line 929\n\t\t\t( case St of\n\t\t\t ( <( {'compile',_52,_53,_54,_55,_56,_57,_58,_59,_60,_61,_62,_rec73,_63,_64}\n\t\t\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\t\t let <_rec71> =\n\t\t\t\t call 'erlang':'++'\n\t\t\t\t\t (Es, _rec73)\n\t\t\t\t in let <_15> =\n\t\t\t\t\t call 'erlang':'setelement'\n\t\t\t\t\t (13, St, _rec71)\n\t\t\t\t in {'error',_15}\n\t\t\t -| ['compiler_generated'] )\n\t\t\t ( <_65> when 'true' ->\n\t\t\t\t ( call ( 'erlang'\n\t\t\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t(( {'badrecord','compile'}\n\t\t\t\t\t -| ['compiler_generated'] ))\n\t\t\t\t -| ['compiler_generated'] )\n\t\t\t -| ['compiler_generated'] )\n\t\t\t end\n\t\t\t -| ['compiler_generated'] )\n\t\t( <_16> when 'true' ->\n\t\t primop 'match_fail'\n\t\t\t ({'case_clause',_16})\n\t\t -| ['compiler_generated'] )\n\t end\n\t ( <_17> when 'true' ->\n\t\tprimop 'match_fail'\n\t\t ({'case_clause',_17})\n\t -| ['compiler_generated'] )\n\tend\n'do_parse_module'/2 =\n %% Line 933\n fun (_1,_0) ->\n\tcase <_1,_0> of\n\t when 'true' ->\n\t let <_2> =\n\t\t apply %% Line 935\n\t\t\t'inc_paths'/1\n\t\t (%% Line 935\n\t\t Opts)\n\t in let <_3> =\n\t\t apply %% Line 936\n\t\t\t 'pre_defs'/1\n\t\t\t (%% Line 936\n\t\t\t Opts)\n\t\t in %% Line 939\n\t\t case call 'epp':'parse_file'\n\t\t\t (File, [{'includes',[[46]|[Dir|_2]]}|[{'macros',_3}|[{'default_encoding',DefEncoding}|['extra']]]]) of\n\t\t\t%% Line 940\n\t\t\t<{'ok',Forms,Extra}> when 'true' ->\n\t\t\t let =\n\t\t\t\tcall %% Line 941\n\t\t\t\t 'proplists':%% Line 941\n\t\t\t\t\t\t 'get_value'\n\t\t\t\t (%% Line 941\n\t\t\t\t 'encoding', %% Line 941\n\t\t\t\t\t\t Extra)\n\t\t\t in %% Line 942\n\t\t\t\tcase apply 'find_invalid_unicode'/2\n\t\t\t\t\t (Forms, File) of\n\t\t\t\t %% Line 943\n\t\t\t\t <'none'> when 'true' ->\n\t\t\t\t let <_8> =\n\t\t\t\t\t call %% Line 944\n\t\t\t\t\t 'erlang':%% Line 944\n\t\t\t\t\t\t\t'setelement'\n\t\t\t\t\t (%% Line 944\n\t\t\t\t\t 12, %% Line 944\n\t\t\t\t\t\t St, %% Line 944\n\t\t\t\t\t\t Encoding)\n\t\t\t\t in %% Line 944\n\t\t\t\t\t {'ok',Forms,_8}\n\t\t\t\t %% Line 945\n\t\t\t\t when 'true' ->\n\t\t\t\t %% Line 946\n\t\t\t\t case Encoding of\n\t\t\t\t\t%% Line 947\n\t\t\t\t\t<'none'> when 'true' ->\n\t\t\t\t\t %% Line 948\n\t\t\t\t\t Ret\n\t\t\t\t\t%% Line 949\n\t\t\t\t\t<_54> when 'true' ->\n\t\t\t\t\t let <_11> =\n\t\t\t\t\t\tcall %% Line 950\n\t\t\t\t\t\t 'erlang':%% Line 950\n\t\t\t\t\t\t\t 'setelement'\n\t\t\t\t\t\t (%% Line 950\n\t\t\t\t\t\t 12, %% Line 950\n\t\t\t\t\t\t\t St, %% Line 950\n\t\t\t\t\t\t\t Encoding)\n\t\t\t\t\t in %% Line 950\n\t\t\t\t\t\t{'ok',Forms,_11}\n\t\t\t\t end\n\t\t\t\t ( <_13> when 'true' ->\n\t\t\t\t\tprimop 'match_fail'\n\t\t\t\t\t ({'case_clause',_13})\n\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\tend\n\t\t\t%% Line 953\n\t\t\t<{'error',E}> when 'true' ->\n\t\t\t let =\n\t\t\t\t[%% Line 954\n\t\t\t\t {File,[{'none','compile',{'epp',E}}|[]]}|%% Line 954\n\t\t\t\t\t\t\t\t\t []]\n\t\t\t in let <_rec77> =\n\t\t\t\t call %% Line 955\n\t\t\t\t\t 'erlang':%% Line 955\n\t\t\t\t\t\t '++'\n\t\t\t\t\t(_34, %% Line 955\n\t\t\t\t\t Es)\n\t\t\t\tin let <_22> =\n\t\t\t\t\tcall %% Line 955\n\t\t\t\t\t 'erlang':%% Line 955\n\t\t\t\t\t\t 'setelement'\n\t\t\t\t\t (%% Line 955\n\t\t\t\t\t 13, %% Line 955\n\t\t\t\t\t\t St, %% Line 955\n\t\t\t\t\t\t _rec77)\n\t\t\t\t in %% Line 955\n\t\t\t\t\t{'error',_22}\n\t\t\t( <_23> when 'true' ->\n\t\t\t primop 'match_fail'\n\t\t\t\t ({'case_clause',_23})\n\t\t\t -| ['compiler_generated'] )\n\t\t end\n\t ( <_25,_24> when 'true' ->\n\t\t( primop 'match_fail'\n\t\t ({'function_clause',_25,_24})\n\t\t -| [{'function_name',{'do_parse_module',2}}] )\n\t -| ['compiler_generated'] )\n\tend\n'find_invalid_unicode'/2 =\n %% Line 958\n fun (_1,_0) ->\n\tcase <_1,_0> of\n\t <[H|T],File0> when 'true' ->\n\t %% Line 959\n\t case H of\n\t\t%% Line 960\n\t\t<{'attribute',_5,'file',{File,_6}}> when 'true' ->\n\t\t %% Line 961\n\t\t apply 'find_invalid_unicode'/2\n\t\t\t(T, File)\n\t\t%% Line 962\n\t\t<{'error',{Line,'file_io_server','invalid_unicode'}}> when 'true' ->\n\t\t %% Line 963\n\t\t {'invalid_unicode',File0,Line}\n\t\t%% Line 964\n\t\t<_X_Other> when 'true' ->\n\t\t %% Line 965\n\t\t apply 'find_invalid_unicode'/2\n\t\t\t(T, File0)\n\t end\n\t %% Line 967\n\t <[],_7> when 'true' ->\n\t 'none'\n\t ( <_4,_3> when 'true' ->\n\t\t( primop 'match_fail'\n\t\t ({'function_clause',_4,_3})\n\t\t -| [{'function_name',{'find_invalid_unicode',2}}] )\n\t -| ['compiler_generated'] )\n\tend\n'parse_core'/2 =\n %% Line 969\n fun (_1,_0) ->\n\t%% Line 970\n\t( case _0 of\n\t ( <( {'compile',_45,_46,_47,_rec80,_48,_49,_50,_51,_52,_53,_54,_55,_56,_57}\n\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t case call 'file':'read_file'\n\t\t\t (_rec80) of\n\t\t %% Line 971\n\t\t <{'ok',Bin}> when 'true' ->\n\t\t\tlet <_4> =\n\t\t\t call %% Line 972\n\t\t\t\t 'erlang':%% Line 972\n\t\t\t\t\t 'binary_to_list'\n\t\t\t\t(%% Line 972\n\t\t\t\t Bin)\n\t\t\tin %% Line 972\n\t\t\t case call 'core_scan':'string'\n\t\t\t\t (_4) of\n\t\t\t %% Line 973\n\t\t\t <{'ok',Toks,_59}> when 'true' ->\n\t\t\t\t %% Line 974\n\t\t\t\t case call 'core_parse':'parse'\n\t\t\t\t\t (Toks) of\n\t\t\t\t %% Line 975\n\t\t\t\t <{'ok',Mod}> when 'true' ->\n\t\t\t\t\t%% Line 976\n\t\t\t\t\t( case Mod of\n\t\t\t\t\t ( <( {'c_module',_60,_rec82,_61,_62,_63}\n\t\t\t\t\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\t\t\t\t ( case _rec82 of\n\t\t\t\t\t\t ( <( {'c_literal',_65,_rec81}\n\t\t\t\t\t\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\t\t\t\t\t let <_12> =\n\t\t\t\t\t\t\t\tcall %% Line 977\n\t\t\t\t\t\t\t\t 'erlang':%% Line 977\n\t\t\t\t\t\t\t\t\t 'setelement'\n\t\t\t\t\t\t\t\t (%% Line 977\n\t\t\t\t\t\t\t\t 7, _0, _rec81)\n\t\t\t\t\t\t\t in %% Line 977\n\t\t\t\t\t\t\t\t{'ok',Mod,_12}\n\t\t\t\t\t\t\t-| ['compiler_generated'] )\n\t\t\t\t\t\t ( <_66> when 'true' ->\n\t\t\t\t\t\t\t ( call ( 'erlang'\n\t\t\t\t\t\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t\t\t\t (( {'badrecord','c_literal'}\n\t\t\t\t\t\t\t\t -| ['compiler_generated'] ))\n\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t\t\t-| ['compiler_generated'] )\n\t\t\t\t\t\t end\n\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t ( <_64> when 'true' ->\n\t\t\t\t\t\t ( call ( 'erlang'\n\t\t\t\t\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t\t\t(( {'badrecord','c_module'}\n\t\t\t\t\t\t\t -| ['compiler_generated'] ))\n\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t end\n\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t %% Line 978\n\t\t\t\t <{'error',E}> when 'true' ->\n\t\t\t\t\tlet =\n\t\t\t\t\t [%% Line 979\n\t\t\t\t\t {_rec80,[E|[]]}|%% Line 979\n\t\t\t\t\t\t\t []]\n\t\t\t\t\tin let <_rec85> =\n\t\t\t\t\t\tcall %% Line 980\n\t\t\t\t\t\t 'erlang':%% Line 980\n\t\t\t\t\t\t\t '++'\n\t\t\t\t\t\t (_55, %% Line 980\n\t\t\t\t\t\t\t Es)\n\t\t\t\t\t in let <_21> =\n\t\t\t\t\t\t call %% Line 980\n\t\t\t\t\t\t\t 'erlang':%% Line 980\n\t\t\t\t\t\t\t\t 'setelement'\n\t\t\t\t\t\t\t(%% Line 980\n\t\t\t\t\t\t\t 13, _0, %% Line 980\n\t\t\t\t\t\t\t\t _rec85)\n\t\t\t\t\t\tin %% Line 980\n\t\t\t\t\t\t {'error',_21}\n\t\t\t\t ( <_22> when 'true' ->\n\t\t\t\t\t primop 'match_fail'\n\t\t\t\t\t ({'case_clause',_22})\n\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t end\n\t\t\t %% Line 982\n\t\t\t <{'error',E,_125}> when 'true' ->\n\t\t\t\t let =\n\t\t\t\t [%% Line 983\n\t\t\t\t {_rec80,[E|[]]}|%% Line 983\n\t\t\t\t\t\t []]\n\t\t\t\t in let <_rec89> =\n\t\t\t\t\t call %% Line 984\n\t\t\t\t\t 'erlang':%% Line 984\n\t\t\t\t\t\t\t'++'\n\t\t\t\t\t (_55, %% Line 984\n\t\t\t\t\t\t Es)\n\t\t\t\t in let <_31> =\n\t\t\t\t\t call %% Line 984\n\t\t\t\t\t\t 'erlang':%% Line 984\n\t\t\t\t\t\t\t 'setelement'\n\t\t\t\t\t\t (%% Line 984\n\t\t\t\t\t\t 13, _0, %% Line 984\n\t\t\t\t\t\t\t _rec89)\n\t\t\t\t\t in %% Line 984\n\t\t\t\t\t {'error',_31}\n\t\t\t ( <_32> when 'true' ->\n\t\t\t\t primop 'match_fail'\n\t\t\t\t\t({'case_clause',_32})\n\t\t\t\t-| ['compiler_generated'] )\n\t\t\t end\n\t\t %% Line 986\n\t\t <{'error',E}> when 'true' ->\n\t\t\tlet =\n\t\t\t [%% Line 987\n\t\t\t {_rec80,[{'none','compile',{'open',E}}|[]]}|%% Line 987\n\t\t\t\t\t\t\t\t\t []]\n\t\t\tin let <_rec93> =\n\t\t\t\tcall %% Line 988\n\t\t\t\t 'erlang':%% Line 988\n\t\t\t\t\t '++'\n\t\t\t\t (_55, %% Line 988\n\t\t\t\t\t Es)\n\t\t\t in let <_41> =\n\t\t\t\t call %% Line 988\n\t\t\t\t\t 'erlang':%% Line 988\n\t\t\t\t\t\t 'setelement'\n\t\t\t\t\t(%% Line 988\n\t\t\t\t\t 13, _0, %% Line 988\n\t\t\t\t\t\t _rec93)\n\t\t\t\tin %% Line 988\n\t\t\t\t {'error',_41}\n\t\t ( <_42> when 'true' ->\n\t\t\t primop 'match_fail'\n\t\t\t ({'case_clause',_42})\n\t\t -| ['compiler_generated'] )\n\t\t end\n\t -| ['compiler_generated'] )\n\t ( <_58> when 'true' ->\n\t\t ( call ( 'erlang'\n\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t(( {'badrecord','compile'}\n\t\t\t -| ['compiler_generated'] ))\n\t\t -| ['compiler_generated'] )\n\t -| ['compiler_generated'] )\n\t end\n\t -| ['compiler_generated'] )\n'get_module_name_from_core'/2 =\n %% Line 991\n fun (_1,_0) ->\n\t%% Line 992\n\ttry\n\t let <_2> =\n\t\tcall %% Line 993\n\t\t 'cerl':%% Line 993\n\t\t\t 'module_name'\n\t\t (_1)\n\t in let =\n\t\t call %% Line 993\n\t\t\t 'cerl':%% Line 993\n\t\t\t\t'concrete'\n\t\t\t(_2)\n\t\tin %% Line 994\n\t\t case _0 of\n\t\t <{'compile',_13,_14,_15,_16,_17,_18,_19,_20,_21,_22,_23,_24,_25,_26}> when 'true' ->\n\t\t\t let <_6> =\n\t\t\t call 'erlang':'setelement'\n\t\t\t\t (7, _0, Mod)\n\t\t\t in {'ok',_1,_6}\n\t\t ( <_27> when 'true' ->\n\t\t\t ( call ( 'erlang'\n\t\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t (( {'badrecord','compile'}\n\t\t\t\t -| ['compiler_generated'] ))\n\t\t\t -| ['compiler_generated'] )\n\t\t\t-| ['compiler_generated'] )\n\t\t end\n\tof <_7> ->\n\t _7\n\tcatch <_10,_9,_8> ->\n\t %% Line 998\n\t {'ok',_1,_0}\n'compile_options'/1 =\n %% Line 1001\n fun (_0) ->\n\tcase _0 of\n\t <[{'attribute',_X_L,'compile',C}|Fs]>\n\t when call 'erlang':'is_list'\n\t\t (C) ->\n\t let <_1> =\n\t\t apply %% Line 1002\n\t\t\t'compile_options'/1\n\t\t (%% Line 1002\n\t\t Fs)\n\t in %% Line 1002\n\t\t call 'erlang':'++'\n\t\t (C, _1)\n\t %% Line 1003\n\t <[{'attribute',_X_L,'compile',C}|Fs]> when 'true' ->\n\t let <_2> =\n\t\t apply %% Line 1004\n\t\t\t'compile_options'/1\n\t\t (%% Line 1004\n\t\t Fs)\n\t in %% Line 1004\n\t\t [C|_2]\n\t %% Line 1005\n\t <[_X_F|Fs]> when 'true' ->\n\t apply 'compile_options'/1\n\t\t (Fs)\n\t %% Line 1006\n\t <[]> when 'true' ->\n\t []\n\t ( <_3> when 'true' ->\n\t\t( primop 'match_fail'\n\t\t ({'function_clause',_3})\n\t\t -| [{'function_name',{'compile_options',1}}] )\n\t -| ['compiler_generated'] )\n\tend\n'clean_parse_transforms'/1 =\n %% Line 1008\n fun (_0) ->\n\t%% Line 1009\n\tapply 'clean_parse_transforms_1'/2\n\t (_0, [])\n'clean_parse_transforms_1'/2 =\n %% Line 1011\n fun (_1,_0) ->\n\tcase <_1,_0> of\n\t <[{'attribute',L,'compile',C0}|Fs],Acc>\n\t when call 'erlang':'is_list'\n\t\t (C0) ->\n\t let <_4> =\n\t\t fun (_2) ->\n\t\t %% Line 1012\n\t\t case _2 of\n\t\t\t<{'parse_transform',_8}> when 'true' ->\n\t\t\t 'false'\n\t\t\t%% Line 1013\n\t\t\t<_9> when 'true' ->\n\t\t\t 'true'\n\t\t end\n\t in let =\n\t\t call %% Line 1012\n\t\t\t 'lists':%% Line 1012\n\t\t\t\t 'filter'\n\t\t\t (_4, %% Line 1014\n\t\t\t C0)\n\t\t in %% Line 1015\n\t\t apply 'clean_parse_transforms_1'/2\n\t\t\t (Fs, [{'attribute',L,'compile',C}|Acc])\n\t %% Line 1016\n\t <[{'attribute',_10,'compile',{'parse_transform',_11}}|Fs],Acc> when 'true' ->\n\t %% Line 1017\n\t apply 'clean_parse_transforms_1'/2\n\t\t (Fs, Acc)\n\t %% Line 1018\n\t <[F|Fs],Acc> when 'true' ->\n\t %% Line 1019\n\t apply 'clean_parse_transforms_1'/2\n\t\t (Fs, [F|Acc])\n\t %% Line 1020\n\t <[],Acc> when 'true' ->\n\t call 'lists':'reverse'\n\t\t (Acc)\n\t ( <_7,_6> when 'true' ->\n\t\t( primop 'match_fail'\n\t\t ({'function_clause',_7,_6})\n\t\t -| [{'function_name',{'clean_parse_transforms_1',2}}] )\n\t -| ['compiler_generated'] )\n\tend\n'transforms'/1 =\n %% Line 1022\n fun (_0) ->\n\t( letrec\n\t 'lc$^0'/1 =\n\t\t fun (_3) ->\n\t\t case _3 of\n\t\t\t<[{'parse_transform',M}|_2]> when 'true' ->\n\t\t\t let <_4> =\n\t\t\t\tapply 'lc$^0'/1\n\t\t\t\t (_2)\n\t\t\t in ( [M|_4]\n\t\t\t\t -| ['compiler_generated'] )\n\t\t\t( <[_1|_2]> when 'true' ->\n\t\t\t apply 'lc$^0'/1\n\t\t\t\t (_2)\n\t\t\t -| ['compiler_generated'] )\n\t\t\t<[]> when 'true' ->\n\t\t\t []\n\t\t\t( <_6> when 'true' ->\n\t\t\t ( primop 'match_fail'\n\t\t\t\t ({'function_clause',_6})\n\t\t\t\t-| [{'function_name',{'lc$^0',1}}] )\n\t\t\t -| ['compiler_generated'] )\n\t\t end\n\t in apply 'lc$^0'/1\n\t\t (_0)\n\t -| ['list_comprehension'] )\n'transform_module'/2 =\n %% Line 1024\n fun (_1,_0) ->\n\tcase <_1,_0> of\n\t when 'true' ->\n\t let <_2> =\n\t\t apply %% Line 1026\n\t\t\t'compile_options'/1\n\t\t (%% Line 1026\n\t\t Code0)\n\t in let <_3> =\n\t\t call %% Line 1026\n\t\t\t 'erlang':%% Line 1026\n\t\t\t\t '++'\n\t\t\t (%% Line 1026\n\t\t\t Opt, _2)\n\t\t in %% Line 1026\n\t\t case apply 'transforms'/1\n\t\t\t (_3) of\n\t\t\t%% Line 1027\n\t\t\t<[]> when 'true' ->\n\t\t\t %% Line 1029\n\t\t\t {'ok',Code0,St}\n\t\t\t%% Line 1030\n\t\t\t when 'true' ->\n\t\t\t let =\n\t\t\t\tapply %% Line 1033\n\t\t\t\t 'clean_parse_transforms'/1\n\t\t\t\t (%% Line 1033\n\t\t\t\t Code0)\n\t\t\t in %% Line 1034\n\t\t\t\tapply 'foldl_transform'/3\n\t\t\t\t (Ts, Code, St)\n\t\t end\n\t ( <_7,_6> when 'true' ->\n\t\t( primop 'match_fail'\n\t\t ({'function_clause',_7,_6})\n\t\t -| [{'function_name',{'transform_module',2}}] )\n\t -| ['compiler_generated'] )\n\tend\n'foldl_transform'/3 =\n %% Line 1037\n fun (_2,_1,_0) ->\n\tcase <_2,_1,_0> of\n\t <[T|Ts],Code0,St> when 'true' ->\n\t let <_3> =\n\t\t call %% Line 1038\n\t\t 'erlang':%% Line 1038\n\t\t\t\t'atom_to_list'\n\t\t (%% Line 1038\n\t\t T)\n\t in let =\n\t\t call %% Line 1038\n\t\t\t 'erlang':%% Line 1038\n\t\t\t\t '++'\n\t\t\t (%% Line 1038\n\t\t\t [116|[114|[97|[110|[115|[102|[111|[114|[109|[32]]]]]]]]]], _3)\n\t\t in let <_6> =\n\t\t\t call %% Line 1039\n\t\t\t 'code':%% Line 1039\n\t\t\t\t 'ensure_loaded'\n\t\t\t (%% Line 1039\n\t\t\t T)\n\t\t in let <_8> =\n\t\t\t case <> of\n\t\t\t\t%% Line 1039\n\t\t\t\t( <>\n\t\t\t\t when call 'erlang':'=:='\n\t\t\t\t\t (_6,\n\t\t\t\t\t {'module',T}) ->\n\t\t\t\t %% Line 1040\n\t\t\t\t call 'erlang':'function_exported'\n\t\t\t\t\t (T, 'parse_transform', 2)\n\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t%% Line 1039\n\t\t\t\t( <> when 'true' ->\n\t\t\t\t 'false'\n\t\t\t\t -| ['compiler_generated'] )\n\t\t\t end\n\t\t\t in %% Line 1039\n\t\t\t case _8 of\n\t\t\t\t%% Line 1041\n\t\t\t\t<'true'> when 'true' ->\n\t\t\t\t let =\n\t\t\t\t\tfun (_12,_11) ->\n\t\t\t\t\t %% Line 1043\n\t\t\t\t\t ( case _11 of\n\t\t\t\t\t\t( <( {'compile',_66,_67,_68,_69,_70,_71,_72,_73,_rec97,_74,_75,_76,_77,_78}\n\t\t\t\t\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\t\t\t\t call T:'parse_transform'\n\t\t\t\t\t\t\t (_12, _rec97)\n\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t\t( <_79> when 'true' ->\n\t\t\t\t\t\t ( call ( 'erlang'\n\t\t\t\t\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t\t\t (( {'badrecord','compile'}\n\t\t\t\t\t\t\t -| ['compiler_generated'] ))\n\t\t\t\t\t\t\t-| ['compiler_generated'] )\n\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t end\n\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t in %% Line 1045\n\t\t\t\t\t( case St of\n\t\t\t\t\t ( <( {'compile',_80,_81,_82,_83,_84,_85,_86,_87,_rec98,_88,_89,_90,_91,_92}\n\t\t\t\t\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\t\t\t\t let <_25> =\n\t\t\t\t\t\t case call 'lists':'member'\n\t\t\t\t\t\t\t ('time', _rec98) of\n\t\t\t\t\t\t\t%% Line 1046\n\t\t\t\t\t\t\t<'true'> when 'true' ->\n\t\t\t\t\t\t\t %% Line 1047\n\t\t\t\t\t\t\t ( 'run_tc'/3\n\t\t\t\t\t\t\t -| [{'id',{0,0,'-foldl_transform/3-fun-1-'}}] )\n\t\t\t\t\t\t\t%% Line 1048\n\t\t\t\t\t\t\t<'false'> when 'true' ->\n\t\t\t\t\t\t\t %% Line 1049\n\t\t\t\t\t\t\t ( fun (_20,_19,_18) ->\n\t\t\t\t\t\t\t\t case <_20,_19,_18> of\n\t\t\t\t\t\t\t\t <{_X_Name,F},Code,S> when 'true' ->\n\t\t\t\t\t\t\t\t\tcatch\n\t\t\t\t\t\t\t\t\t %% Line 1050\n\t\t\t\t\t\t\t\t\t apply F\n\t\t\t\t\t\t\t\t\t\t(Code, S)\n\t\t\t\t\t\t\t\t ( <_23,_22,_21> when 'true' ->\n\t\t\t\t\t\t\t\t\t ( primop 'match_fail'\n\t\t\t\t\t\t\t\t\t\t({'function_clause',_23,_22,_21})\n\t\t\t\t\t\t\t\t\t -| [{'function_name',{'-foldl_transform/3-fun-2-',3}}] )\n\t\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t\t\t\t end\n\t\t\t\t\t\t\t -| [{'id',{0,0,'-foldl_transform/3-fun-2-'}}] )\n\t\t\t\t\t\t\t( <_24> when 'true' ->\n\t\t\t\t\t\t\t primop 'match_fail'\n\t\t\t\t\t\t\t\t ({'case_clause',_24})\n\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t\t end\n\t\t\t\t\t\t in %% Line 1053\n\t\t\t\t\t\t case apply _25\n\t\t\t\t\t\t\t ({Name,Fun}, Code0, St) of\n\t\t\t\t\t\t\t%% Line 1054\n\t\t\t\t\t\t\t<{'error',Es,Ws}> when 'true' ->\n\t\t\t\t\t\t\t let <_rec99> =\n\t\t\t\t\t\t\t\tcall %% Line 1055\n\t\t\t\t\t\t\t\t 'erlang':%% Line 1055\n\t\t\t\t\t\t\t\t\t '++'\n\t\t\t\t\t\t\t\t (_91, %% Line 1055\n\t\t\t\t\t\t\t\t\t Ws)\n\t\t\t\t\t\t\t in let <_rec100> =\n\t\t\t\t\t\t\t\t call %% Line 1056\n\t\t\t\t\t\t\t\t\t 'erlang':%% Line 1056\n\t\t\t\t\t\t\t\t\t\t '++'\n\t\t\t\t\t\t\t\t\t(_90, %% Line 1056\n\t\t\t\t\t\t\t\t\t Es)\n\t\t\t\t\t\t\t\tin let <_34> =\n\t\t\t\t\t\t\t\t\tcall %% Line 1055\n\t\t\t\t\t\t\t\t\t 'erlang':%% Line 1055\n\t\t\t\t\t\t\t\t\t\t 'setelement'\n\t\t\t\t\t\t\t\t\t (%% Line 1055\n\t\t\t\t\t\t\t\t\t 14, %% Line 1055\n\t\t\t\t\t\t\t\t\t\t St, %% Line 1055\n\t\t\t\t\t\t\t\t\t\t _rec99)\n\t\t\t\t\t\t\t\t in let <_36> =\n\t\t\t\t\t\t\t\t\t call %% Line 1056\n\t\t\t\t\t\t\t\t\t\t 'erlang':%% Line 1056\n\t\t\t\t\t\t\t\t\t\t\t 'setelement'\n\t\t\t\t\t\t\t\t\t\t(%% Line 1056\n\t\t\t\t\t\t\t\t\t\t 13, _34, %% Line 1056\n\t\t\t\t\t\t\t\t\t\t\t _rec100)\n\t\t\t\t\t\t\t\t\tin %% Line 1055\n\t\t\t\t\t\t\t\t\t {'error',_36}\n\t\t\t\t\t\t\t%% Line 1057\n\t\t\t\t\t\t\t<{'EXIT',R}> when 'true' ->\n\t\t\t\t\t\t\t let =\n\t\t\t\t\t\t\t\t[%% Line 1058\n\t\t\t\t\t\t\t\t {_83,[{'none','compile',%% Line 1059\n\t\t\t\t\t\t\t\t\t\t\t {'parse_transform',T,R}}|%% Line 1059\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t []]}|%% Line 1059\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t []]\n\t\t\t\t\t\t\t in let <_rec105> =\n\t\t\t\t\t\t\t\t call %% Line 1060\n\t\t\t\t\t\t\t\t\t 'erlang':%% Line 1060\n\t\t\t\t\t\t\t\t\t\t '++'\n\t\t\t\t\t\t\t\t\t(_90, %% Line 1060\n\t\t\t\t\t\t\t\t\t Es)\n\t\t\t\t\t\t\t\tin let <_45> =\n\t\t\t\t\t\t\t\t\tcall %% Line 1060\n\t\t\t\t\t\t\t\t\t 'erlang':%% Line 1060\n\t\t\t\t\t\t\t\t\t\t 'setelement'\n\t\t\t\t\t\t\t\t\t (%% Line 1060\n\t\t\t\t\t\t\t\t\t 13, %% Line 1060\n\t\t\t\t\t\t\t\t\t\t St, %% Line 1060\n\t\t\t\t\t\t\t\t\t\t _rec105)\n\t\t\t\t\t\t\t\t in %% Line 1060\n\t\t\t\t\t\t\t\t\t{'error',_45}\n\t\t\t\t\t\t\t%% Line 1061\n\t\t\t\t\t\t\t<{'warning',Forms,Ws}> when 'true' ->\n\t\t\t\t\t\t\t let <_rec108> =\n\t\t\t\t\t\t\t\tcall %% Line 1063\n\t\t\t\t\t\t\t\t 'erlang':%% Line 1063\n\t\t\t\t\t\t\t\t\t '++'\n\t\t\t\t\t\t\t\t (_91, %% Line 1063\n\t\t\t\t\t\t\t\t\t Ws)\n\t\t\t\t\t\t\t in let <_51> =\n\t\t\t\t\t\t\t\t call %% Line 1063\n\t\t\t\t\t\t\t\t\t 'erlang':%% Line 1063\n\t\t\t\t\t\t\t\t\t\t 'setelement'\n\t\t\t\t\t\t\t\t\t(%% Line 1063\n\t\t\t\t\t\t\t\t\t 14, %% Line 1063\n\t\t\t\t\t\t\t\t\t St, %% Line 1063\n\t\t\t\t\t\t\t\t\t\t _rec108)\n\t\t\t\t\t\t\t\tin %% Line 1062\n\t\t\t\t\t\t\t\t apply 'foldl_transform'/3\n\t\t\t\t\t\t\t\t\t(Ts, Forms, _51)\n\t\t\t\t\t\t\t%% Line 1064\n\t\t\t\t\t\t\t when 'true' ->\n\t\t\t\t\t\t\t %% Line 1065\n\t\t\t\t\t\t\t apply 'foldl_transform'/3\n\t\t\t\t\t\t\t\t(Ts, Forms, St)\n\t\t\t\t\t\t end\n\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t ( <_93> when 'true' ->\n\t\t\t\t\t\t ( call ( 'erlang'\n\t\t\t\t\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t\t\t(( {'badrecord','compile'}\n\t\t\t\t\t\t\t -| ['compiler_generated'] ))\n\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t end\n\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t%% Line 1067\n\t\t\t\t<'false'> when 'true' ->\n\t\t\t\t %% Line 1068\n\t\t\t\t ( case St of\n\t\t\t\t\t( <( {'compile',_209,_210,_211,_rec111,_212,_213,_214,_215,_216,_217,_218,_219,_220,_221}\n\t\t\t\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\t\t\t let =\n\t\t\t\t\t\t [{_rec111,[{'none','compile',%% Line 1069\n\t\t\t\t\t\t\t\t\t {'undef_parse_transform',T}}|%% Line 1069\n\t\t\t\t\t\t\t\t\t\t\t\t\t []]}|%% Line 1069\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t []]\n\t\t\t\t\t in let <_rec112> =\n\t\t\t\t\t\t call %% Line 1070\n\t\t\t\t\t\t\t 'erlang':%% Line 1070\n\t\t\t\t\t\t\t\t '++'\n\t\t\t\t\t\t\t (_219, %% Line 1070\n\t\t\t\t\t\t\t\t Es)\n\t\t\t\t\t\t in let <_61> =\n\t\t\t\t\t\t\t call %% Line 1070\n\t\t\t\t\t\t\t 'erlang':%% Line 1070\n\t\t\t\t\t\t\t\t\t'setelement'\n\t\t\t\t\t\t\t (%% Line 1070\n\t\t\t\t\t\t\t 13, %% Line 1070\n\t\t\t\t\t\t\t\t St, %% Line 1070\n\t\t\t\t\t\t\t\t _rec112)\n\t\t\t\t\t\t in %% Line 1070\n\t\t\t\t\t\t\t {'error',_61}\n\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t( <_222> when 'true' ->\n\t\t\t\t\t ( call ( 'erlang'\n\t\t\t\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t\t (( {'badrecord','compile'}\n\t\t\t\t\t\t -| ['compiler_generated'] ))\n\t\t\t\t\t\t-| ['compiler_generated'] )\n\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t end\n\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t( <_62> when 'true' ->\n\t\t\t\t primop 'match_fail'\n\t\t\t\t\t ({'case_clause',_62})\n\t\t\t\t -| ['compiler_generated'] )\n\t\t\t end\n\t %% Line 1072\n\t <[],Code,St> when 'true' ->\n\t {'ok',Code,St}\n\t ( <_65,_64,_63> when 'true' ->\n\t\t( primop 'match_fail'\n\t\t ({'function_clause',_65,_64,_63})\n\t\t -| [{'function_name',{'foldl_transform',3}}] )\n\t -| ['compiler_generated'] )\n\tend\n'get_core_transforms'/1 =\n %% Line 1074\n fun (_0) ->\n\t( letrec\n\t 'lc$^0'/1 =\n\t\t fun (_3) ->\n\t\t case _3 of\n\t\t\t<[{'core_transform',M}|_2]> when 'true' ->\n\t\t\t let <_4> =\n\t\t\t\tapply 'lc$^0'/1\n\t\t\t\t (_2)\n\t\t\t in ( [M|_4]\n\t\t\t\t -| ['compiler_generated'] )\n\t\t\t( <[_1|_2]> when 'true' ->\n\t\t\t apply 'lc$^0'/1\n\t\t\t\t (_2)\n\t\t\t -| ['compiler_generated'] )\n\t\t\t<[]> when 'true' ->\n\t\t\t []\n\t\t\t( <_6> when 'true' ->\n\t\t\t ( primop 'match_fail'\n\t\t\t\t ({'function_clause',_6})\n\t\t\t\t-| [{'function_name',{'lc$^0',1}}] )\n\t\t\t -| ['compiler_generated'] )\n\t\t end\n\t in apply 'lc$^0'/1\n\t\t (_0)\n\t -| ['list_comprehension'] )\n'core_transforms'/2 =\n %% Line 1076\n fun (_1,_0) ->\n\t%% Line 1078\n\t( case _0 of\n\t ( <( {'compile',_7,_8,_9,_10,_11,_12,_13,_14,_rec115,_15,_16,_17,_18,_19}\n\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t let =\n\t\t apply 'get_core_transforms'/1\n\t\t\t (_rec115)\n\t\t in %% Line 1079\n\t\t apply 'foldl_core_transforms'/3\n\t\t\t (Ts, _1, _0)\n\t -| ['compiler_generated'] )\n\t ( <_20> when 'true' ->\n\t\t ( call ( 'erlang'\n\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t(( {'badrecord','compile'}\n\t\t\t -| ['compiler_generated'] ))\n\t\t -| ['compiler_generated'] )\n\t -| ['compiler_generated'] )\n\t end\n\t -| ['compiler_generated'] )\n'foldl_core_transforms'/3 =\n %% Line 1081\n fun (_2,_1,_0) ->\n\tcase <_2,_1,_0> of\n\t <[T|Ts],Code0,St> when 'true' ->\n\t let <_3> =\n\t\t call %% Line 1082\n\t\t 'erlang':%% Line 1082\n\t\t\t\t'atom_to_list'\n\t\t (%% Line 1082\n\t\t T)\n\t in let =\n\t\t call %% Line 1082\n\t\t\t 'erlang':%% Line 1082\n\t\t\t\t '++'\n\t\t\t (%% Line 1082\n\t\t\t [99|[111|[114|[101|[32|[116|[114|[97|[110|[115|[102|[111|[114|[109|[32]]]]]]]]]]]]]]], _3)\n\t\t in let =\n\t\t\t fun (_8,_7) ->\n\t\t\t %% Line 1083\n\t\t\t ( case _7 of\n\t\t\t\t ( <( {'compile',_36,_37,_38,_39,_40,_41,_42,_43,_rec116,_44,_45,_46,_47,_48}\n\t\t\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\t\t\tcall T:'core_transform'\n\t\t\t\t\t (_8, _rec116)\n\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t ( <_49> when 'true' ->\n\t\t\t\t\t( call ( 'erlang'\n\t\t\t\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t (( {'badrecord','compile'}\n\t\t\t\t\t\t -| ['compiler_generated'] ))\n\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\tend\n\t\t\t\t-| ['compiler_generated'] )\n\t\t in %% Line 1084\n\t\t\t ( case St of\n\t\t\t ( <( {'compile',_50,_51,_52,_53,_54,_55,_56,_57,_rec117,_58,_59,_60,_61,_62}\n\t\t\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\t\t let <_21> =\n\t\t\t\t\tcase call 'lists':'member'\n\t\t\t\t\t\t ('time', _rec117) of\n\t\t\t\t\t %% Line 1085\n\t\t\t\t\t <'true'> when 'true' ->\n\t\t\t\t\t %% Line 1086\n\t\t\t\t\t ( 'run_tc'/3\n\t\t\t\t\t\t-| [{'id',{0,0,'-foldl_core_transforms/3-fun-1-'}}] )\n\t\t\t\t\t %% Line 1087\n\t\t\t\t\t <'false'> when 'true' ->\n\t\t\t\t\t %% Line 1088\n\t\t\t\t\t ( fun (_16,_15,_14) ->\n\t\t\t\t\t\t case <_16,_15,_14> of\n\t\t\t\t\t\t <{_X_Name,F},Code,S> when 'true' ->\n\t\t\t\t\t\t\t catch\n\t\t\t\t\t\t\t %% Line 1089\n\t\t\t\t\t\t\t apply F\n\t\t\t\t\t\t\t\t (Code, S)\n\t\t\t\t\t\t ( <_19,_18,_17> when 'true' ->\n\t\t\t\t\t\t\t ( primop 'match_fail'\n\t\t\t\t\t\t\t\t ({'function_clause',_19,_18,_17})\n\t\t\t\t\t\t\t -| [{'function_name',{'-foldl_core_transforms/3-fun-2-',3}}] )\n\t\t\t\t\t\t\t-| ['compiler_generated'] )\n\t\t\t\t\t\t end\n\t\t\t\t\t\t-| [{'id',{0,0,'-foldl_core_transforms/3-fun-2-'}}] )\n\t\t\t\t\t ( <_20> when 'true' ->\n\t\t\t\t\t\tprimop 'match_fail'\n\t\t\t\t\t\t ({'case_clause',_20})\n\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\tend\n\t\t\t\t in %% Line 1092\n\t\t\t\t\tcase apply _21\n\t\t\t\t\t\t ({Name,Fun}, Code0, St) of\n\t\t\t\t\t %% Line 1093\n\t\t\t\t\t <{'EXIT',R}> when 'true' ->\n\t\t\t\t\t let =\n\t\t\t\t\t\t [%% Line 1094\n\t\t\t\t\t\t {_53,[{'none','compile',{'core_transform',T,R}}|[]]}|%% Line 1094\n\t\t\t\t\t\t\t\t\t\t\t\t\t[]]\n\t\t\t\t\t in let <_rec119> =\n\t\t\t\t\t\t call %% Line 1095\n\t\t\t\t\t\t\t 'erlang':%% Line 1095\n\t\t\t\t\t\t\t\t '++'\n\t\t\t\t\t\t\t (_60, %% Line 1095\n\t\t\t\t\t\t\t\tEs)\n\t\t\t\t\t\t in let <_31> =\n\t\t\t\t\t\t\t call %% Line 1095\n\t\t\t\t\t\t\t 'erlang':%% Line 1095\n\t\t\t\t\t\t\t\t\t'setelement'\n\t\t\t\t\t\t\t (%% Line 1095\n\t\t\t\t\t\t\t 13, %% Line 1095\n\t\t\t\t\t\t\t\t St, %% Line 1095\n\t\t\t\t\t\t\t\t _rec119)\n\t\t\t\t\t\t in %% Line 1095\n\t\t\t\t\t\t\t {'error',_31}\n\t\t\t\t\t %% Line 1096\n\t\t\t\t\t when 'true' ->\n\t\t\t\t\t %% Line 1097\n\t\t\t\t\t apply 'foldl_core_transforms'/3\n\t\t\t\t\t\t (Ts, Forms, St)\n\t\t\t\t\tend\n\t\t\t\t-| ['compiler_generated'] )\n\t\t\t ( <_63> when 'true' ->\n\t\t\t\t ( call ( 'erlang'\n\t\t\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t (( {'badrecord','compile'}\n\t\t\t\t\t -| ['compiler_generated'] ))\n\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t-| ['compiler_generated'] )\n\t\t\t end\n\t\t\t -| ['compiler_generated'] )\n\t %% Line 1099\n\t <[],Code,St> when 'true' ->\n\t {'ok',Code,St}\n\t ( <_35,_34,_33> when 'true' ->\n\t\t( primop 'match_fail'\n\t\t ({'function_clause',_35,_34,_33})\n\t\t -| [{'function_name',{'foldl_core_transforms',3}}] )\n\t -| ['compiler_generated'] )\n\tend\n'get_module'/1 =\n %% Line 1103\n fun (_0) ->\n\tcase _0 of\n\t <[{'attribute',_2,'module',M}|_3]> when 'true' ->\n\t M\n\t %% Line 1104\n\t <[_4|Rest]> when 'true' ->\n\t %% Line 1105\n\t apply 'get_module'/1\n\t\t (Rest)\n\t ( <_1> when 'true' ->\n\t\t( primop 'match_fail'\n\t\t ({'function_clause',_1})\n\t\t -| [{'function_name',{'get_module',1}}] )\n\t -| ['compiler_generated'] )\n\tend\n'add_default_base'/2 =\n %% Line 1110\n fun (_1,_0) ->\n\t%% Line 1111\n\t( case _1 of\n\t ( <( {'compile',_rec122,_12,_13,_14,_15,_16,_17,_18,_19,_20,_21,_22,_23,_24}\n\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t %% Line 1112\n\t\t case _rec122 of\n\t\t %% Line 1113\n\t\t <[]> when 'true' ->\n\t\t\tlet =\n\t\t\t apply %% Line 1114\n\t\t\t\t 'get_module'/1\n\t\t\t\t(_0)\n\t\t\tin let <_rec123> =\n\t\t\t\tcall %% Line 1115\n\t\t\t\t 'erlang':%% Line 1115\n\t\t\t\t\t 'atom_to_list'\n\t\t\t\t (%% Line 1115\n\t\t\t\t M)\n\t\t\t in %% Line 1115\n\t\t\t\tcall 'erlang':'setelement'\n\t\t\t\t (4, _1, _rec123)\n\t\t %% Line 1116\n\t\t <_41> when 'true' ->\n\t\t\t_1\n\t\t end\n\t -| ['compiler_generated'] )\n\t ( <_25> when 'true' ->\n\t\t ( call ( 'erlang'\n\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t(( {'badrecord','compile'}\n\t\t\t -| ['compiler_generated'] ))\n\t\t -| ['compiler_generated'] )\n\t -| ['compiler_generated'] )\n\t end\n\t -| ['compiler_generated'] )\n'lint_module'/2 =\n %% Line 1120\n fun (_1,_0) ->\n\t%% Line 1121\n\t( case _0 of\n\t ( <( {'compile',_26,_27,_28,_rec125,_29,_30,_31,_32,_33,_34,_35,_36,_37,_38}\n\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t case call 'erl_lint':'module'\n\t\t\t (_1, _rec125, _33) of\n\t\t %% Line 1122\n\t\t <{'ok',Ws}> when 'true' ->\n\t\t\tlet =\n\t\t\t apply %% Line 1125\n\t\t\t\t 'add_default_base'/2\n\t\t\t\t(_0, _1)\n\t\t\tin %% Line 1126\n\t\t\t ( case St1 of\n\t\t\t\t( <( {'compile',_54,_55,_56,_57,_58,_59,_60,_61,_62,_63,_64,_65,_rec129,_66}\n\t\t\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\t\t let <_rec127> =\n\t\t\t\t\t call 'erlang':'++'\n\t\t\t\t\t (_rec129, Ws)\n\t\t\t\t in let <_12> =\n\t\t\t\t\t call 'erlang':'setelement'\n\t\t\t\t\t\t (14, St1, _rec127)\n\t\t\t\t\t in {'ok',_1,_12}\n\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t( <_67> when 'true' ->\n\t\t\t\t ( call ( 'erlang'\n\t\t\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t (( {'badrecord','compile'}\n\t\t\t\t\t -| ['compiler_generated'] ))\n\t\t\t\t\t-| ['compiler_generated'] )\n\t\t\t\t -| ['compiler_generated'] )\n\t\t\t end\n\t\t\t -| ['compiler_generated'] )\n\t\t %% Line 1127\n\t\t <{'error',Es,Ws}> when 'true' ->\n\t\t\tlet <_rec130> =\n\t\t\t call %% Line 1128\n\t\t\t\t 'erlang':%% Line 1128\n\t\t\t\t\t '++'\n\t\t\t\t(_37, %% Line 1128\n\t\t\t\t Ws)\n\t\t\tin let <_rec131> =\n\t\t\t\tcall %% Line 1129\n\t\t\t\t 'erlang':%% Line 1129\n\t\t\t\t\t '++'\n\t\t\t\t (_36, %% Line 1129\n\t\t\t\t\t Es)\n\t\t\t in let <_20> =\n\t\t\t\t call %% Line 1128\n\t\t\t\t\t 'erlang':%% Line 1128\n\t\t\t\t\t\t 'setelement'\n\t\t\t\t\t(%% Line 1128\n\t\t\t\t\t 14, _0, %% Line 1128\n\t\t\t\t\t\t _rec130)\n\t\t\t\tin let <_22> =\n\t\t\t\t\tcall %% Line 1129\n\t\t\t\t\t 'erlang':%% Line 1129\n\t\t\t\t\t\t 'setelement'\n\t\t\t\t\t (%% Line 1129\n\t\t\t\t\t 13, _20, %% Line 1129\n\t\t\t\t\t\t _rec131)\n\t\t\t\t in %% Line 1128\n\t\t\t\t\t{'error',_22}\n\t\t ( <_23> when 'true' ->\n\t\t\t primop 'match_fail'\n\t\t\t ({'case_clause',_23})\n\t\t -| ['compiler_generated'] )\n\t\t end\n\t -| ['compiler_generated'] )\n\t ( <_39> when 'true' ->\n\t\t ( call ( 'erlang'\n\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t(( {'badrecord','compile'}\n\t\t\t -| ['compiler_generated'] ))\n\t\t -| ['compiler_generated'] )\n\t -| ['compiler_generated'] )\n\t end\n\t -| ['compiler_generated'] )\n'core_lint_module'/2 =\n %% Line 1132\n fun (_1,_0) ->\n\t%% Line 1133\n\t( case _0 of\n\t ( <( {'compile',_23,_24,_25,_26,_27,_28,_29,_30,_rec135,_31,_32,_33,_34,_35}\n\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t case call 'core_lint':'module'\n\t\t\t (_1, _rec135) of\n\t\t %% Line 1134\n\t\t <{'ok',Ws}> when 'true' ->\n\t\t\tlet <_rec136> =\n\t\t\t call %% Line 1135\n\t\t\t\t 'erlang':%% Line 1135\n\t\t\t\t\t '++'\n\t\t\t\t(_34, %% Line 1135\n\t\t\t\t Ws)\n\t\t\tin let <_9> =\n\t\t\t\tcall %% Line 1135\n\t\t\t\t 'erlang':%% Line 1135\n\t\t\t\t\t 'setelement'\n\t\t\t\t (%% Line 1135\n\t\t\t\t 14, _0, %% Line 1135\n\t\t\t\t\t _rec136)\n\t\t\t in %% Line 1135\n\t\t\t\t{'ok',_1,_9}\n\t\t %% Line 1136\n\t\t <{'error',Es,Ws}> when 'true' ->\n\t\t\tlet <_rec139> =\n\t\t\t call %% Line 1137\n\t\t\t\t 'erlang':%% Line 1137\n\t\t\t\t\t '++'\n\t\t\t\t(_34, %% Line 1137\n\t\t\t\t Ws)\n\t\t\tin let <_rec140> =\n\t\t\t\tcall %% Line 1138\n\t\t\t\t 'erlang':%% Line 1138\n\t\t\t\t\t '++'\n\t\t\t\t (_33, %% Line 1138\n\t\t\t\t\t Es)\n\t\t\t in let <_17> =\n\t\t\t\t call %% Line 1137\n\t\t\t\t\t 'erlang':%% Line 1137\n\t\t\t\t\t\t 'setelement'\n\t\t\t\t\t(%% Line 1137\n\t\t\t\t\t 14, _0, %% Line 1137\n\t\t\t\t\t\t _rec139)\n\t\t\t\tin let <_19> =\n\t\t\t\t\tcall %% Line 1138\n\t\t\t\t\t 'erlang':%% Line 1138\n\t\t\t\t\t\t 'setelement'\n\t\t\t\t\t (%% Line 1138\n\t\t\t\t\t 13, _17, %% Line 1138\n\t\t\t\t\t\t _rec140)\n\t\t\t\t in %% Line 1137\n\t\t\t\t\t{'error',_19}\n\t\t ( <_20> when 'true' ->\n\t\t\t primop 'match_fail'\n\t\t\t ({'case_clause',_20})\n\t\t -| ['compiler_generated'] )\n\t\t end\n\t -| ['compiler_generated'] )\n\t ( <_36> when 'true' ->\n\t\t ( call ( 'erlang'\n\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t(( {'badrecord','compile'}\n\t\t\t -| ['compiler_generated'] ))\n\t\t -| ['compiler_generated'] )\n\t -| ['compiler_generated'] )\n\t end\n\t -| ['compiler_generated'] )\n'makedep_and_output'/2 =\n %% Line 1142\n fun (_1,_0) ->\n\t%% Line 1143\n\tcase apply 'makedep'/2\n\t\t (_1, _0) of\n\t <{'ok',DepCode,St1}> when 'true' ->\n\t %% Line 1144\n\t case apply 'makedep_output'/2\n\t\t (DepCode, St1) of\n\t\t%% Line 1145\n\t\t<{'ok',_X_IgnoreCode,St2}> when 'true' ->\n\t\t %% Line 1146\n\t\t {'ok',_1,St2}\n\t\t%% Line 1147\n\t\t<_@r0 = {'error',St2}> when 'true' ->\n\t\t %% Line 1148\n\t\t _@r0\n\t\t( <_3> when 'true' ->\n\t\t primop 'match_fail'\n\t\t\t ({'case_clause',_3})\n\t\t -| ['compiler_generated'] )\n\t end\n\t ( <_2> when 'true' ->\n\t\tprimop 'match_fail'\n\t\t ({'badmatch',_2})\n\t -| ['compiler_generated'] )\n\tend\n'makedep'/2 =\n %% Line 1151\n fun (_1,_0) ->\n\tcase <_1,_0> of\n\t when 'true' ->\n\t let <_3> =\n\t\t case %% Line 1155\n\t\t call 'proplists':'get_value'\n\t\t\t ('makedep_target', Opts) of\n\t\t %% Line 1156\n\t\t <'undefined'> when 'true' ->\n\t\t\t%% Line 1160\n\t\t\tapply 'shorten_filename'/1\n\t\t\t (Ofile)\n\t\t %% Line 1161\n\t\t when 'true' ->\n\t\t\t%% Line 1163\n\t\t\tT\n\t\t end\n\t in let <_9> =\n\t\t case %% Line 1167\n\t\t\t call 'proplists':'get_value'\n\t\t\t ('makedep_quote_target', Opts) of\n\t\t\t%% Line 1168\n\t\t\t<'true'> when 'true' ->\n\t\t\t let =\n\t\t\t\tfun (_5) ->\n\t\t\t\t %% Line 1170\n\t\t\t\t case _5 of\n\t\t\t\t %% Line 1171\n\t\t\t\t <36> when 'true' ->\n\t\t\t\t\t [36|[36]]\n\t\t\t\t %% Line 1172\n\t\t\t\t when 'true' ->\n\t\t\t\t\t C\n\t\t\t\t end\n\t\t\t in %% Line 1174\n\t\t\t\tcall 'lists':'map'\n\t\t\t\t (Fun, _3)\n\t\t\t%% Line 1175\n\t\t\t<_31> when 'true' ->\n\t\t\t _3\n\t\t end\n\t\t in let =\n\t\t\t call %% Line 1178\n\t\t\t 'erlang':%% Line 1178\n\t\t\t\t\t'++'\n\t\t\t (_9, %% Line 1178\n\t\t\t\t [58])\n\t\t in let <_12> =\n\t\t\t call %% Line 1185\n\t\t\t\t 'erlang':%% Line 1185\n\t\t\t\t\t 'length'\n\t\t\t\t (%% Line 1185\n\t\t\t\t Target)\n\t\t\t in %% Line 1181\n\t\t\t case apply 'makedep_add_headers'/7\n\t\t\t\t (%% Line 1182\n\t\t\t\t\tIfile, %% Line 1183\n\t\t\t\t\t Code0, %% Line 1184\n\t\t\t\t\t\t [], _12, %% Line 1186\n\t\t\t\t\t\t\t Target, %% Line 1187\n\t\t\t\t\t\t\t\t [], %% Line 1188\n\t\t\t\t\t\t\t\t\t Opts) of\n\t\t\t\t<{MainRule,PhonyRules}> when 'true' ->\n\t\t\t\t let <_15> =\n\t\t\t\t\tcase %% Line 1199\n\t\t\t\t\t call 'proplists':'get_value'\n\t\t\t\t\t\t ('makedep_phony', Opts) of\n\t\t\t\t\t %% Line 1200\n\t\t\t\t\t <'true'> when 'true' ->\n\t\t\t\t\t call 'erlang':'++'\n\t\t\t\t\t\t (MainRule, PhonyRules)\n\t\t\t\t\t %% Line 1201\n\t\t\t\t\t <_32> when 'true' ->\n\t\t\t\t\t MainRule\n\t\t\t\t\tend\n\t\t\t\t in let =\n\t\t\t\t\t call %% Line 1203\n\t\t\t\t\t\t 'erlang':%% Line 1203\n\t\t\t\t\t\t\t 'iolist_to_binary'\n\t\t\t\t\t\t(%% Line 1203\n\t\t\t\t\t\t [_15|[[10]]])\n\t\t\t\t\tin %% Line 1204\n\t\t\t\t\t {'ok',Code,St}\n\t\t\t\t( <_13> when 'true' ->\n\t\t\t\t primop 'match_fail'\n\t\t\t\t\t ({'badmatch',_13})\n\t\t\t\t -| ['compiler_generated'] )\n\t\t\t end\n\t ( <_19,_18> when 'true' ->\n\t\t( primop 'match_fail'\n\t\t ({'function_clause',_19,_18})\n\t\t -| [{'function_name',{'makedep',2}}] )\n\t -| ['compiler_generated'] )\n\tend\n'makedep_add_headers'/7 =\n %% Line 1206\n fun (_6,_5,_4,_3,_2,_1,_0) ->\n\tcase <_6,_5,_4,_3,_2,_1,_0> of\n\t when 'true' ->\n\t %% Line 1209\n\t case %% Line 1210\n\t\t apply 'makedep_add_header'/6\n\t\t (Ifile, Included, LineLen, MainTarget, Phony, File) of\n\t\t<{Included1,LineLen1,MainTarget1,Phony1}> when 'true' ->\n\t\t %% Line 1211\n\t\t apply 'makedep_add_headers'/7\n\t\t\t(Ifile, Rest, Included1, LineLen1, %% Line 1212\n\t\t\t\t\t\t\t MainTarget1, %% Line 1212\n\t\t\t\t\t\t\t\t\tPhony1, %% Line 1212\n\t\t\t\t\t\t\t\t\t\tOpts)\n\t\t( <_7> when 'true' ->\n\t\t primop 'match_fail'\n\t\t\t ({'badmatch',_7})\n\t\t -| ['compiler_generated'] )\n\t end\n\t %% Line 1213\n\t when 'true' ->\n\t %% Line 1216\n\t case call 'proplists':'get_value'\n\t\t ('makedep_add_missing', Opts) of\n\t\t%% Line 1217\n\t\t<'true'> when 'true' ->\n\t\t %% Line 1218\n\t\t case %% Line 1219\n\t\t\t apply 'makedep_add_header'/6\n\t\t\t (Ifile, Included, LineLen, MainTarget, %% Line 1220\n\t\t\t\t\t\t\t\t Phony, %% Line 1220\n\t\t\t\t\t\t\t\t\t File) of\n\t\t <{Included1,LineLen1,MainTarget1,Phony1}> when 'true' ->\n\t\t\t %% Line 1221\n\t\t\t apply 'makedep_add_headers'/7\n\t\t\t (Ifile, Rest, Included1, LineLen1, %% Line 1222\n\t\t\t\t\t\t\t\t MainTarget1, %% Line 1222\n\t\t\t\t\t\t\t\t\t Phony1, %% Line 1222\n\t\t\t\t\t\t\t\t\t\t Opts)\n\t\t ( <_8> when 'true' ->\n\t\t\t primop 'match_fail'\n\t\t\t\t({'badmatch',_8})\n\t\t\t-| ['compiler_generated'] )\n\t\t end\n\t\t%% Line 1223\n\t\t<_20> when 'true' ->\n\t\t %% Line 1224\n\t\t apply 'makedep_add_headers'/7\n\t\t\t(Ifile, Rest, Included, LineLen, %% Line 1225\n\t\t\t\t\t\t\t MainTarget, %% Line 1225\n\t\t\t\t\t\t\t\t Phony, %% Line 1225\n\t\t\t\t\t\t\t\t\t Opts)\n\t end\n\t %% Line 1227\n\t when 'true' ->\n\t %% Line 1229\n\t apply 'makedep_add_headers'/7\n\t\t (Ifile, Rest, Included, %% Line 1230\n\t\t\t\t\t LineLen, %% Line 1230\n\t\t\t\t\t\t MainTarget, %% Line 1230\n\t\t\t\t\t\t\t Phony, %% Line 1230\n\t\t\t\t\t\t\t\t Opts)\n\t %% Line 1231\n\t <_X_Ifile,[],_X_Included,_X_LineLen,%% Line 1232\n\t\t\t\t\t MainTarget,%% Line 1232\n\t\t\t\t\t\t\t Phony,%% Line 1232\n\t\t\t\t\t\t\t _X_Opts> when 'true' ->\n\t %% Line 1233\n\t {MainTarget,Phony}\n\t ( <_16,_15,_14,_13,_12,_11,_10> when 'true' ->\n\t\t( primop 'match_fail'\n\t\t ({'function_clause',_16,_15,_14,_13,_12,_11,_10})\n\t\t -| [{'function_name',{'makedep_add_headers',7}}] )\n\t -| ['compiler_generated'] )\n\tend\n'makedep_add_header'/6 =\n %% Line 1235\n fun (_5,_4,_3,_2,_1,_0) ->\n\t%% Line 1236\n\tcase call 'lists':'member'\n\t\t (_0, _4) of\n\t %% Line 1237\n\t <'true'> when 'true' ->\n\t %% Line 1239\n\t {_4,_3,_2,_1}\n\t %% Line 1240\n\t <'false'> when 'true' ->\n\t let =\n\t\t [_0|_4]\n\t in let <_8> =\n\t\t case _0 of\n\t\t\t%% Line 1245\n\t\t\t<[46|[47|File0]]> when 'true' ->\n\t\t\t File0\n\t\t\t%% Line 1246\n\t\t\t<_34> when 'true' ->\n\t\t\t _0\n\t\t end\n\t\t in let <_13> =\n\t\t\t case _0 of\n\t\t\t %% Line 1251\n\t\t\t <_35>\n\t\t\t\twhen call 'erlang':'=:='\n\t\t\t\t (_0,\n\t\t\t\t _5) ->\n\t\t\t\t_1\n\t\t\t %% Line 1252\n\t\t\t <_36> when 'true' ->\n\t\t\t\tlet <_10> =\n\t\t\t\t call 'erlang':'++'\n\t\t\t\t\t(_8, [58])\n\t\t\t\tin let <_11> =\n\t\t\t\t\t[10|[10|_10]]\n\t\t\t\t in call 'erlang':'++'\n\t\t\t\t\t (_1, _11)\n\t\t\t end\n\t\t in %% Line 1257\n\t\t\t case <> of\n\t\t\t %% Line 1258\n\t\t\t <>\n\t\t\t\twhen try\n\t\t\t\t let <_16> =\n\t\t\t\t\t call 'erlang':'+'\n\t\t\t\t\t (_3, 1)\n\t\t\t\t in let <_15> =\n\t\t\t\t\t call 'erlang':'length'\n\t\t\t\t\t\t (_8)\n\t\t\t\t\t in let <_17> =\n\t\t\t\t\t\t call 'erlang':'+'\n\t\t\t\t\t\t (_16, _15)\n\t\t\t\t\t in call 'erlang':'>'\n\t\t\t\t\t\t (_17, 76)\n\t\t\t\t of ->\n\t\t\t\t Try\n\t\t\t\t catch ->\n\t\t\t\t 'false' ->\n\t\t\t\tlet <_18> =\n\t\t\t\t call %% Line 1259\n\t\t\t\t\t 'erlang':%% Line 1259\n\t\t\t\t\t\t 'length'\n\t\t\t\t\t(_8)\n\t\t\t\tin let =\n\t\t\t\t\tcall %% Line 1259\n\t\t\t\t\t 'erlang':%% Line 1259\n\t\t\t\t\t\t '+'\n\t\t\t\t\t (%% Line 1259\n\t\t\t\t\t 2, _18)\n\t\t\t\t in let <_20> =\n\t\t\t\t\t call %% Line 1260\n\t\t\t\t\t\t 'erlang':%% Line 1260\n\t\t\t\t\t\t\t '++'\n\t\t\t\t\t\t(%% Line 1260\n\t\t\t\t\t\t [32|[92|[10|[32|[32]]]]], _8)\n\t\t\t\t\tin let =\n\t\t\t\t\t\tcall %% Line 1260\n\t\t\t\t\t\t 'erlang':%% Line 1260\n\t\t\t\t\t\t\t '++'\n\t\t\t\t\t\t (_2, _20)\n\t\t\t\t\t in %% Line 1261\n\t\t\t\t\t\t{Included1,LineLen1,MainTarget1,_13}\n\t\t\t %% Line 1262\n\t\t\t <> when 'true' ->\n\t\t\t\tlet <_23> =\n\t\t\t\t call %% Line 1263\n\t\t\t\t\t 'erlang':%% Line 1263\n\t\t\t\t\t\t '+'\n\t\t\t\t\t(_3, %% Line 1263\n\t\t\t\t\t 1)\n\t\t\t\tin let <_22> =\n\t\t\t\t\tcall %% Line 1263\n\t\t\t\t\t 'erlang':%% Line 1263\n\t\t\t\t\t\t 'length'\n\t\t\t\t\t (_8)\n\t\t\t\t in let =\n\t\t\t\t\t call %% Line 1263\n\t\t\t\t\t\t 'erlang':%% Line 1263\n\t\t\t\t\t\t\t '+'\n\t\t\t\t\t\t(_23, _22)\n\t\t\t\t\tin let <_25> =\n\t\t\t\t\t\t[32|_8]\n\t\t\t\t\t in let =\n\t\t\t\t\t\t call %% Line 1264\n\t\t\t\t\t\t\t 'erlang':%% Line 1264\n\t\t\t\t\t\t\t\t '++'\n\t\t\t\t\t\t\t(_2, _25)\n\t\t\t\t\t\tin %% Line 1265\n\t\t\t\t\t\t {Included1,LineLen1,MainTarget1,_13}\n\t\t\t end\n\t ( <_27> when 'true' ->\n\t\tprimop 'match_fail'\n\t\t ({'case_clause',_27})\n\t -| ['compiler_generated'] )\n\tend\n'makedep_output'/2 =\n %% Line 1269\n fun (_1,_0) ->\n\tcase <_1,_0> of\n\t when 'true' ->\n\t let <_4> =\n\t\t case %% Line 1273\n\t\t call 'proplists':'get_value'\n\t\t\t ('makedep_output', Opts) of\n\t\t %% Line 1274\n\t\t <'undefined'> when 'true' ->\n\t\t\tlet <_2> =\n\t\t\t call %% Line 1276\n\t\t\t\t 'filename':%% Line 1276\n\t\t\t\t\t 'basename'\n\t\t\t\t(%% Line 1276\n\t\t\t\t Ofile, %% Line 1276\n\t\t\t\t\t[46|[98|[101|[97|[109]]]]])\n\t\t\tin %% Line 1276\n\t\t\t apply 'outfile'/3\n\t\t\t\t(_2, [80|[98|[101|[97|[109]]]]], Opts)\n\t\t %% Line 1277\n\t\t when 'true' ->\n\t\t\t%% Line 1278\n\t\t\tO\n\t\t end\n\t in let <_197,_198,_199> =\n\t\t case _4 of\n\t\t\t%% Line 1285\n\t\t\t<_60>\n\t\t\t when call 'erlang':'is_list'\n\t\t\t\t (_4) ->\n\t\t\t %% Line 1286\n\t\t\t case call 'file':'delete'\n\t\t\t\t (_4) of\n\t\t\t %% Line 1287\n\t\t\t \n\t\t\t\t when let <_6> =\n\t\t\t\t\tcall 'erlang':'=:='\n\t\t\t\t\t (Ret2, 'ok')\n\t\t\t\t in let <_7> =\n\t\t\t\t\t call 'erlang':'=:='\n\t\t\t\t\t\t(Ret2, {'error','enoent'})\n\t\t\t\t\tin call 'erlang':'or'\n\t\t\t\t\t\t(_6, _7) ->\n\t\t\t\t %% Line 1288\n\t\t\t\t case call 'file':'open'\n\t\t\t\t\t (_4, ['write']) of\n\t\t\t\t %% Line 1289\n\t\t\t\t <{'ok',IODev}> when 'true' ->\n\t\t\t\t\t%% Line 1290\n\t\t\t\t\t<'ok',IODev,'true'>\n\t\t\t\t %% Line 1291\n\t\t\t\t <{'error',Reason2}> when 'true' ->\n\t\t\t\t\t%% Line 1292\n\t\t\t\t\t<'error','open',Reason2>\n\t\t\t\t ( <_8> when 'true' ->\n\t\t\t\t\t primop 'match_fail'\n\t\t\t\t\t ({'case_clause',_8})\n\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t end\n\t\t\t %% Line 1294\n\t\t\t <{'error',Reason1}> when 'true' ->\n\t\t\t\t %% Line 1295\n\t\t\t\t <'error','delete',Reason1>\n\t\t\t ( <_9> when 'true' ->\n\t\t\t\t primop 'match_fail'\n\t\t\t\t\t({'case_clause',_9})\n\t\t\t\t-| ['compiler_generated'] )\n\t\t\t end\n\t\t\t%% Line 1297\n\t\t\t<_61> when 'true' ->\n\t\t\t %% Line 1298\n\t\t\t <'ok',_4,'false'>\n\t\t end\n\t\t in %% Line 1301\n\t\t case ( <( _197\n\t\t\t\t-| ['compiler_generated'] ),( _198\n\t\t\t\t\t\t\t -| ['compiler_generated'] ),( _199\n\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] )>\n\t\t\t -| ['compiler_generated'] ) of\n\t\t\t%% Line 1302\n\t\t\t<( 'ok'\n\t\t\t -| ['compiler_generated'] ),Output1,CloseOutput> when 'true' ->\n\t\t\t %% Line 1303\n\t\t\t try\n\t\t\t\tdo %% Line 1305\n\t\t\t\t call 'io':'fwrite'\n\t\t\t\t\t(Output1, [126|[116|[115]]], [Code|[]])\n\t\t\t\t do %% Line 1307\n\t\t\t\t\tcase <> of\n\t\t\t\t\t %% Line 1308\n\t\t\t\t\t <>\n\t\t\t\t\t when ( call 'erlang':'=:='\n\t\t\t\t\t\t (CloseOutput,\n\t\t\t\t\t\t 'true')\n\t\t\t\t\t\t -| ['compiler_generated'] ) ->\n\t\t\t\t\t case call 'file':'close'\n\t\t\t\t\t\t (Output1) of\n\t\t\t\t\t\t<'ok'> when 'true' ->\n\t\t\t\t\t\t 'ok'\n\t\t\t\t\t\t( <_13> when 'true' ->\n\t\t\t\t\t\t primop 'match_fail'\n\t\t\t\t\t\t\t ({'badmatch',_13})\n\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t\t end\n\t\t\t\t\t %% Line 1309\n\t\t\t\t\t <> when 'true' ->\n\t\t\t\t\t 'ok'\n\t\t\t\t\tend\n\t\t\t\t\t%% Line 1311\n\t\t\t\t\t{'ok',Code,St}\n\t\t\t of <_14> ->\n\t\t\t\t_14\n\t\t\t catch <_17,_16,_15> ->\n\t\t\t\t%% Line 1313\n\t\t\t\tcase <_17,_16,_15> of\n\t\t\t\t <( 'error'\n\t\t\t\t -| ['compiler_generated'] ),_63,_64> when 'true' ->\n\t\t\t\t let =\n\t\t\t\t\t {_51,%% Line 1315\n\t\t\t\t\t [{'none','compile','write_error'}]}\n\t\t\t\t in let <_rec145> =\n\t\t\t\t\t call %% Line 1316\n\t\t\t\t\t\t 'erlang':%% Line 1316\n\t\t\t\t\t\t\t '++'\n\t\t\t\t\t\t (_57, %% Line 1316\n\t\t\t\t\t\t\t[Err|[]])\n\t\t\t\t\t in let <_26> =\n\t\t\t\t\t\t call %% Line 1316\n\t\t\t\t\t\t 'erlang':%% Line 1316\n\t\t\t\t\t\t\t\t'setelement'\n\t\t\t\t\t\t (%% Line 1316\n\t\t\t\t\t\t 13, %% Line 1316\n\t\t\t\t\t\t\t St, %% Line 1316\n\t\t\t\t\t\t\t _rec145)\n\t\t\t\t\t in %% Line 1316\n\t\t\t\t\t\t {'error',_26}\n\t\t\t\t ( <_194,_195,_196> when 'true' ->\n\t\t\t\t\tprimop 'raise'\n\t\t\t\t\t (_196, _195)\n\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\tend\n\t\t\t%% Line 1318\n\t\t\t<( 'error'\n\t\t\t -| ['compiler_generated'] ),( 'open'\n\t\t\t\t\t\t\t -| ['compiler_generated'] ),Reason> when 'true' ->\n\t\t\t let =\n\t\t\t\t{_51,%% Line 1320\n\t\t\t\t [{'none','compile',{'open',Reason}}|[]]}\n\t\t\t in let <_rec149> =\n\t\t\t\t call %% Line 1321\n\t\t\t\t\t 'erlang':%% Line 1321\n\t\t\t\t\t\t '++'\n\t\t\t\t\t(_57, %% Line 1321\n\t\t\t\t\t [Err|[]])\n\t\t\t\tin let <_35> =\n\t\t\t\t\tcall %% Line 1321\n\t\t\t\t\t 'erlang':%% Line 1321\n\t\t\t\t\t\t 'setelement'\n\t\t\t\t\t (%% Line 1321\n\t\t\t\t\t 13, %% Line 1321\n\t\t\t\t\t\t St, %% Line 1321\n\t\t\t\t\t\t _rec149)\n\t\t\t\t in %% Line 1321\n\t\t\t\t\t{'error',_35}\n\t\t\t%% Line 1322\n\t\t\t<( 'error'\n\t\t\t -| ['compiler_generated'] ),( 'delete'\n\t\t\t\t\t\t\t -| ['compiler_generated'] ),Reason> when 'true' ->\n\t\t\t let =\n\t\t\t\t{_51,%% Line 1324\n\t\t\t\t [{'none','compile',{'delete',_4,Reason}}|[]]}\n\t\t\t in let <_rec153> =\n\t\t\t\t call %% Line 1325\n\t\t\t\t\t 'erlang':%% Line 1325\n\t\t\t\t\t\t '++'\n\t\t\t\t\t(_57, %% Line 1325\n\t\t\t\t\t [Err|[]])\n\t\t\t\tin let <_44> =\n\t\t\t\t\tcall %% Line 1325\n\t\t\t\t\t 'erlang':%% Line 1325\n\t\t\t\t\t\t 'setelement'\n\t\t\t\t\t (%% Line 1325\n\t\t\t\t\t 13, %% Line 1325\n\t\t\t\t\t\t St, %% Line 1325\n\t\t\t\t\t\t _rec153)\n\t\t\t\t in %% Line 1325\n\t\t\t\t\t{'error',_44}\n\t\t\t( <( _200\n\t\t\t -| ['compiler_generated'] ),( _201\n\t\t\t\t\t\t\t -| ['compiler_generated'] ),( _202\n\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t\t let <_45> = {( _200\n\t\t\t\t -| ['compiler_generated'] ),( _201\n\t\t\t\t\t\t\t\t -| ['compiler_generated'] ),( _202\n\t\t\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] )}\n\t\t\t in primop 'match_fail'\n\t\t\t\t ({'case_clause',_45})\n\t\t\t -| ['compiler_generated'] )\n\t\t end\n\t ( <_47,_46> when 'true' ->\n\t\t( primop 'match_fail'\n\t\t ({'function_clause',_47,_46})\n\t\t -| [{'function_name',{'makedep_output',2}}] )\n\t -| ['compiler_generated'] )\n\tend\n'expand_records'/2 =\n %% Line 1328\n fun (_1,_0) ->\n\tcase <_1,_0> of\n\t when 'true' ->\n\t let =\n\t\t call %% Line 1329\n\t\t 'erl_expand_records':%% Line 1329\n\t\t\t\t\t 'module'\n\t\t (%% Line 1329\n\t\t Code0, %% Line 1329\n\t\t\t Opts)\n\t in %% Line 1330\n\t\t {'ok',Code,St}\n\t ( <_4,_3> when 'true' ->\n\t\t( primop 'match_fail'\n\t\t ({'function_clause',_4,_3})\n\t\t -| [{'function_name',{'expand_records',2}}] )\n\t -| ['compiler_generated'] )\n\tend\n'core'/2 =\n %% Line 1332\n fun (_1,_0) ->\n\tcase <_1,_0> of\n\t when 'true' ->\n\t let <_6> =\n\t\t letrec\n\t\t 'lc$^0'/1 =\n\t\t\t %% Line 1333\n\t\t\t fun (_4) ->\n\t\t\t case _4 of\n\t\t\t\t<[{'attribute',_35,'compile',C}|_3]> when 'true' ->\n\t\t\t\t let <_5> =\n\t\t\t\t\tapply 'lc$^0'/1\n\t\t\t\t\t (_3)\n\t\t\t\t in ( [C|_5]\n\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t( <[_2|_3]> when 'true' ->\n\t\t\t\t apply 'lc$^0'/1\n\t\t\t\t\t (_3)\n\t\t\t\t -| ['compiler_generated'] )\n\t\t\t\t<[]> when 'true' ->\n\t\t\t\t Opts0\n\t\t\t\t( <_65> when 'true' ->\n\t\t\t\t ( primop 'match_fail'\n\t\t\t\t\t ({'function_clause',_65})\n\t\t\t\t\t-| [{'function_name',{'lc$^0',1}}] )\n\t\t\t\t -| ['compiler_generated'] )\n\t\t\t end\n\t\t in %% Line 1333\n\t\t apply 'lc$^0'/1\n\t\t\t (Forms)\n\t in let =\n\t\t call %% Line 1333\n\t\t\t 'lists':%% Line 1333\n\t\t\t\t 'flatten'\n\t\t\t (_6)\n\t\t in let =\n\t\t\t apply %% Line 1334\n\t\t\t\t'expand_opts'/1\n\t\t\t (%% Line 1334\n\t\t\t Opts1)\n\t\t in %% Line 1335\n\t\t\t case call 'v3_core':'module'\n\t\t\t\t (Forms, Opts) of\n\t\t\t <{'ok',Core,Ws}> when 'true' ->\n\t\t\t\tlet <_10> =\n\t\t\t\t call %% Line 1336\n\t\t\t\t\t 'cerl':%% Line 1336\n\t\t\t\t\t\t'module_name'\n\t\t\t\t\t(%% Line 1336\n\t\t\t\t\t Core)\n\t\t\t\tin let =\n\t\t\t\t\tcall %% Line 1336\n\t\t\t\t\t 'cerl':%% Line 1336\n\t\t\t\t\t\t 'concrete'\n\t\t\t\t\t (_10)\n\t\t\t\t in let <_rec156> =\n\t\t\t\t\t call %% Line 1338\n\t\t\t\t\t\t 'erlang':%% Line 1338\n\t\t\t\t\t\t\t '++'\n\t\t\t\t\t\t(_33, %% Line 1338\n\t\t\t\t\t\t Ws)\n\t\t\t\t\tin let <_16> =\n\t\t\t\t\t\tcall %% Line 1338\n\t\t\t\t\t\t 'erlang':%% Line 1338\n\t\t\t\t\t\t\t 'setelement'\n\t\t\t\t\t\t (%% Line 1338\n\t\t\t\t\t\t 14, %% Line 1337\n\t\t\t\t\t\t\t St, %% Line 1338\n\t\t\t\t\t\t\t _rec156)\n\t\t\t\t\t in let <_17> =\n\t\t\t\t\t\t call %% Line 1337\n\t\t\t\t\t\t\t 'erlang':%% Line 1337\n\t\t\t\t\t\t\t\t 'setelement'\n\t\t\t\t\t\t\t(%% Line 1337\n\t\t\t\t\t\t\t 10, _16, %% Line 1337\n\t\t\t\t\t\t\t\t Opts)\n\t\t\t\t\t\tin let <_19> =\n\t\t\t\t\t\t\tcall %% Line 1337\n\t\t\t\t\t\t\t 'erlang':%% Line 1337\n\t\t\t\t\t\t\t\t 'setelement'\n\t\t\t\t\t\t\t (%% Line 1337\n\t\t\t\t\t\t\t 7, _17, %% Line 1337\n\t\t\t\t\t\t\t\t Mod)\n\t\t\t\t\t\t in %% Line 1337\n\t\t\t\t\t\t\t{'ok',Core,_19}\n\t\t\t ( <_9> when 'true' ->\n\t\t\t\t primop 'match_fail'\n\t\t\t\t ({'badmatch',_9})\n\t\t\t -| ['compiler_generated'] )\n\t\t\t end\n\t ( <_21,_20> when 'true' ->\n\t\t( primop 'match_fail'\n\t\t ({'function_clause',_21,_20})\n\t\t -| [{'function_name',{'core',2}}] )\n\t -| ['compiler_generated'] )\n\tend\n'core_fold_module_after_inlining'/2 =\n %% Line 1340\n fun (_1,_0) ->\n\tcase <_1,_0> of\n\t when 'true' ->\n\t %% Line 1343\n\t case call 'sys_core_fold':'module'\n\t\t (Code0, Opts) of\n\t\t<{'ok',Code,_X_Ws}> when 'true' ->\n\t\t %% Line 1344\n\t\t {'ok',Code,St}\n\t\t( <_2> when 'true' ->\n\t\t primop 'match_fail'\n\t\t\t ({'badmatch',_2})\n\t\t -| ['compiler_generated'] )\n\t end\n\t ( <_4,_3> when 'true' ->\n\t\t( primop 'match_fail'\n\t\t ({'function_clause',_4,_3})\n\t\t -| [{'function_name',{'core_fold_module_after_inlining',2}}] )\n\t -| ['compiler_generated'] )\n\tend\n'v3_kernel'/2 =\n %% Line 1346\n fun (_1,_0) ->\n\tcase <_1,_0> of\n\t when 'true' ->\n\t %% Line 1347\n\t case call 'v3_kernel':'module'\n\t\t (Code0, Opts) of\n\t\t<{'ok',Code,Ws}> when 'true' ->\n\t\t let <_5> =\n\t\t\tcase <> of\n\t\t\t %% Line 1348\n\t\t\t ( <>\n\t\t\t\twhen call 'erlang':'=:='\n\t\t\t\t (Ws,\n\t\t\t\t []) ->\n\t\t\t\t'true'\n\t\t\t -| ['compiler_generated'] )\n\t\t\t %% Line 1348\n\t\t\t ( <> when 'true' ->\n\t\t\t\tapply 'test_core_inliner'/1\n\t\t\t\t (St)\n\t\t\t -| ['compiler_generated'] )\n\t\t\tend\n\t\t in %% Line 1348\n\t\t\tcase _5 of\n\t\t\t %% Line 1349\n\t\t\t <'false'> when 'true' ->\n\t\t\t let <_rec159> =\n\t\t\t\t call %% Line 1350\n\t\t\t\t 'erlang':%% Line 1350\n\t\t\t\t\t\t'++'\n\t\t\t\t (%% Line 1350\n\t\t\t\t Ws0, %% Line 1350\n\t\t\t\t\t Ws)\n\t\t\t in let <_9> =\n\t\t\t\t call %% Line 1350\n\t\t\t\t\t 'erlang':%% Line 1350\n\t\t\t\t\t\t 'setelement'\n\t\t\t\t\t (%% Line 1350\n\t\t\t\t\t 14, %% Line 1350\n\t\t\t\t\t St, %% Line 1350\n\t\t\t\t\t\t _rec159)\n\t\t\t\t in %% Line 1350\n\t\t\t\t {'ok',Code,_9}\n\t\t\t %% Line 1351\n\t\t\t <'true'> when 'true' ->\n\t\t\t %% Line 1354\n\t\t\t {'ok',Code,St}\n\t\t\t ( <_10> when 'true' ->\n\t\t\t\tprimop 'match_fail'\n\t\t\t\t ({'case_clause',_10})\n\t\t\t -| ['compiler_generated'] )\n\t\t\tend\n\t\t( <_2> when 'true' ->\n\t\t primop 'match_fail'\n\t\t\t ({'badmatch',_2})\n\t\t -| ['compiler_generated'] )\n\t end\n\t ( <_12,_11> when 'true' ->\n\t\t( primop 'match_fail'\n\t\t ({'function_clause',_12,_11})\n\t\t -| [{'function_name',{'v3_kernel',2}}] )\n\t -| ['compiler_generated'] )\n\tend\n'block2'/2 =\n %% Line 1357\n fun (_1,_0) ->\n\tcase <_1,_0> of\n\t when 'true' ->\n\t %% Line 1358\n\t case call 'beam_block':'module'\n\t\t (Code0, ['no_blockify'|Opts]) of\n\t\t<{'ok',Code}> when 'true' ->\n\t\t %% Line 1359\n\t\t {'ok',Code,St}\n\t\t( <_2> when 'true' ->\n\t\t primop 'match_fail'\n\t\t\t ({'badmatch',_2})\n\t\t -| ['compiler_generated'] )\n\t end\n\t ( <_4,_3> when 'true' ->\n\t\t( primop 'match_fail'\n\t\t ({'function_clause',_4,_3})\n\t\t -| [{'function_name',{'block2',2}}] )\n\t -| ['compiler_generated'] )\n\tend\n'test_old_inliner'/1 =\n %% Line 1361\n fun (_0) ->\n\tcase _0 of\n\t <{'compile',_5,_6,_7,_8,_9,_10,_11,_12,Opts,_13,_14,_15,_16,_17}> when 'true' ->\n\t let <_3> =\n\t\t fun (_1) ->\n\t\t %% Line 1364\n\t\t case _1 of\n\t\t\t<{'inline',_18}> when 'true' ->\n\t\t\t 'true'\n\t\t\t%% Line 1365\n\t\t\t<_19> when 'true' ->\n\t\t\t 'false'\n\t\t end\n\t in %% Line 1364\n\t\t call 'lists':'any'\n\t\t (_3, %% Line 1366\n\t\t\t Opts)\n\t ( <_4> when 'true' ->\n\t\t( primop 'match_fail'\n\t\t ({'function_clause',_4})\n\t\t -| [{'function_name',{'test_old_inliner',1}}] )\n\t -| ['compiler_generated'] )\n\tend\n'test_core_inliner'/1 =\n %% Line 1368\n fun (_0) ->\n\tcase _0 of\n\t <{'compile',_9,_10,_11,_12,_13,_14,_15,_16,Opts,_17,_18,_19,_20,_21}> when 'true' ->\n\t let <_3> =\n\t\t fun (_1) ->\n\t\t %% Line 1369\n\t\t case _1 of\n\t\t\t<'no_inline'> when 'true' ->\n\t\t\t 'true'\n\t\t\t%% Line 1370\n\t\t\t<_22> when 'true' ->\n\t\t\t 'false'\n\t\t end\n\t in %% Line 1369\n\t\t case call 'lists':'any'\n\t\t\t (_3, %% Line 1371\n\t\t\t\tOpts) of\n\t\t %% Line 1372\n\t\t <'true'> when 'true' ->\n\t\t\t'false'\n\t\t %% Line 1373\n\t\t <'false'> when 'true' ->\n\t\t\tlet <_6> =\n\t\t\t fun (_4) ->\n\t\t\t\t%% Line 1374\n\t\t\t\tcase _4 of\n\t\t\t\t <'inline'> when 'true' ->\n\t\t\t\t 'true'\n\t\t\t\t %% Line 1375\n\t\t\t\t <_23> when 'true' ->\n\t\t\t\t 'false'\n\t\t\t\tend\n\t\t\tin %% Line 1374\n\t\t\t call 'lists':'any'\n\t\t\t\t(_6, %% Line 1376\n\t\t\t\t Opts)\n\t\t ( <_7> when 'true' ->\n\t\t\t primop 'match_fail'\n\t\t\t ({'case_clause',_7})\n\t\t -| ['compiler_generated'] )\n\t\t end\n\t ( <_8> when 'true' ->\n\t\t( primop 'match_fail'\n\t\t ({'function_clause',_8})\n\t\t -| [{'function_name',{'test_core_inliner',1}}] )\n\t -| ['compiler_generated'] )\n\tend\n'test_any_inliner'/1 =\n %% Line 1379\n fun (_0) ->\n\t%% Line 1380\n\t( case apply 'test_old_inliner'/1\n\t\t (_0) of\n\t ( <( 'true'\n\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t 'true'\n\t -| ['compiler_generated'] )\n\t ( <( 'false'\n\t\t -| ['compiler_generated'] )> when 'true' ->\n\t\t apply 'test_core_inliner'/1\n\t\t (_0)\n\t -| ['compiler_generated'] )\n\t ( <_1> when 'true' ->\n\t\t ( call ( 'erlang'\n\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t(( {( 'badarg'\n\t\t\t -| ['compiler_generated'] ),_1}\n\t\t\t -| ['compiler_generated'] ))\n\t\t -| ['compiler_generated'] )\n\t -| ['compiler_generated'] )\n\t end\n\t -| ['compiler_generated'] )\n'core_old_inliner'/2 =\n %% Line 1382\n fun (_1,_0) ->\n\tcase <_1,_0> of\n\t when 'true' ->\n\t %% Line 1383\n\t case call 'sys_core_inline':'module'\n\t\t (Code0, Opts) of\n\t\t<{'ok',Code}> when 'true' ->\n\t\t %% Line 1384\n\t\t {'ok',Code,St}\n\t\t( <_2> when 'true' ->\n\t\t primop 'match_fail'\n\t\t\t ({'badmatch',_2})\n\t\t -| ['compiler_generated'] )\n\t end\n\t ( <_4,_3> when 'true' ->\n\t\t( primop 'match_fail'\n\t\t ({'function_clause',_4,_3})\n\t\t -| [{'function_name',{'core_old_inliner',2}}] )\n\t -| ['compiler_generated'] )\n\tend\n'core_inline_module'/2 =\n %% Line 1386\n fun (_1,_0) ->\n\tcase <_1,_0> of\n\t when 'true' ->\n\t let =\n\t\t call %% Line 1387\n\t\t 'cerl_inline':%% Line 1387\n\t\t\t\t 'core_transform'\n\t\t (%% Line 1387\n\t\t Code0, %% Line 1387\n\t\t\t Opts)\n\t in %% Line 1388\n\t\t {'ok',Code,St}\n\t ( <_4,_3> when 'true' ->\n\t\t( primop 'match_fail'\n\t\t ({'function_clause',_4,_3})\n\t\t -| [{'function_name',{'core_inline_module',2}}] )\n\t -| ['compiler_generated'] )\n\tend\n'save_abstract_code'/2 =\n %% Line 1390\n fun (_1,_0) ->\n\tlet <_rec161> =\n\t call %% Line 1391\n\t\t 'erl_parse':%% Line 1391\n\t\t\t 'anno_to_term'\n\t\t(_1)\n\tin %% Line 1391\n\t case _0 of\n\t <{'compile',_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19,_20,_21}> when 'true' ->\n\t\t let <_5> =\n\t\t call 'erlang':'setelement'\n\t\t\t (9, _0, _rec161)\n\t\t in {'ok',_1,_5}\n\t ( <_22> when 'true' ->\n\t\t ( call ( 'erlang'\n\t\t\t -| ['compiler_generated'] ):( 'error'\n\t\t\t\t\t\t\t -| ['compiler_generated'] )\n\t\t\t (( {'badrecord','compile'}\n\t\t\t -| ['compiler_generated'] ))\n\t\t -| ['compiler_generated'] )\n\t\t-| ['compiler_generated'] )\n\t end\n'debug_info'/1 =\n %% Line 1393\n fun (_0) ->\n\tcase _0 of\n\t <{'compile',_12,_13,_14,_15,OFile,Module,_16,Abst,_17,Opts0,_18,_19,_20,_21}> when 'true' ->\n\t let =\n\t\t apply %% Line 1394\n\t\t\t'cleanup_compile_options'/1\n\t\t (%% Line 1394\n\t\t Opts0)\n\t in let =\n\t\t call %% Line 1395\n\t\t\t 'proplists':%% Line 1395\n\t\t\t\t 'delete'\n\t\t\t (%% Line 1395\n\t\t\t 'debug_info', %% Line 1395\n\t\t\t\t\t Opts0)\n\t\t in let <_23,_24,_25> =\n\t\t\t case %% Line 1397\n\t\t\t call 'proplists':'get_value'\n\t\t\t\t ('debug_info', Opts0, 'false') of\n\t\t\t %% Line 1398\n\t\t\t <{OptBackend,OptMetadata}>\n\t\t\t\twhen call 'erlang':'is_atom'\n\t\t\t\t (OptBackend) ->\n\t\t\t\t\n\t\t\t %% Line 1399\n\t\t\t <'false'> when 'true' ->\n\t\t\t\t<'erl_abstract_code',{'none',AbstOpts},Opts1>\n\t\t\t %% Line 1400\n\t\t\t <'true'> when 'true' ->\n\t\t\t\t<'erl_abstract_code',{Abst,AbstOpts},['debug_info'|Opts1]>\n\t\t\t ( <_3> when 'true' ->\n\t\t\t\t %% Line 1397\n\t\t\t\t primop 'match_fail'\n\t\t\t\t ({'case_clause',_3})\n\t\t\t -| ['compiler_generated'] )\n\t\t\t end\n\t\t in let =\n\t\t\t call %% Line 1402\n\t\t\t\t 'erlang':%% Line 1402\n\t\t\t\t\t 'term_to_binary'\n\t\t\t\t (%% Line 1402\n\t\t\t\t {'debug_info_v1',( _23\n\t\t\t\t\t\t -| ['compiler_generated'] ),( _24\n\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] )}, %% Line 1402\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t ['compressed'])\n\t\t\t in %% Line 1404\n\t\t\t case call 'lists':'member'\n\t\t\t\t ('encrypt_debug_info', ( _25\n\t\t\t\t\t\t\t\t-| ['compiler_generated'] )) of\n\t\t\t\t%% Line 1405\n\t\t\t\t<'true'> when 'true' ->\n\t\t\t\t %% Line 1406\n\t\t\t\t case call 'lists':'keytake'\n\t\t\t\t\t ('debug_info_key', 1, ( _25\n\t\t\t\t\t\t\t\t -| ['compiler_generated'] )) of\n\t\t\t\t %% Line 1407\n\t\t\t\t <{'value',{_22,Key},Opts3}> when 'true' ->\n\t\t\t\t\t %% Line 1408\n\t\t\t\t\t apply 'encrypt_debug_info'/3\n\t\t\t\t\t (DebugInfo, Key, [{'debug_info_key','********'}|Opts3])\n\t\t\t\t %% Line 1409\n\t\t\t\t <'false'> when 'true' ->\n\t\t\t\t\t let =\n\t\t\t\t\t call %% Line 1410\n\t\t\t\t\t\t 'proplists':%% Line 1410\n\t\t\t\t\t\t\t 'get_value'\n\t\t\t\t\t\t (%% Line 1410\n\t\t\t\t\t\t 'crypto_mode', ( _25\n\t\t\t\t\t\t\t\t -| ['compiler_generated'] ), %% Line 1410\n\t\t\t\t\t\t\t\t\t\t\t\t 'des3_cbc')\n\t\t\t\t\t in %% Line 1411\n\t\t\t\t\t case call 'beam_lib':'get_crypto_key'\n\t\t\t\t\t\t ({'debug_info',Mode,Module,OFile}) of\n\t\t\t\t\t\t%% Line 1412\n\t\t\t\t\t\t<'error'> when 'true' ->\n\t\t\t\t\t\t %% Line 1413\n\t\t\t\t\t\t {'error',[{'none','compile','no_crypto_key'}]}\n\t\t\t\t\t\t%% Line 1414\n\t\t\t\t\t\t when 'true' ->\n\t\t\t\t\t\t %% Line 1415\n\t\t\t\t\t\t apply 'encrypt_debug_info'/3\n\t\t\t\t\t\t\t(DebugInfo, {Mode,Key}, ( _25\n\t\t\t\t\t\t\t\t\t\t -| ['compiler_generated'] ))\n\t\t\t\t\t end\n\t\t\t\t ( <_9> when 'true' ->\n\t\t\t\t\t primop 'match_fail'\n\t\t\t\t\t\t({'case_clause',_9})\n\t\t\t\t\t-| ['compiler_generated'] )\n\t\t\t\t end\n\t\t\t\t%% Line 1418\n\t\t\t\t<'false'> when 'true' ->\n\t\t\t\t %% Line 1419\n\t\t\t\t {'ok',DebugInfo,( _25\n\t\t\t\t\t\t -| ['compiler_generated'] )}\n\t\t\t\t( <_10> when 'true' ->\n\t\t\t\t primop 'match_fail'\n\t\t\t\t\t ({'case_clause',_10})\n\t\t\t\t -| ['compiler_generated'] )\n\t\t\t end\n\t ( <_11> when 'true' ->\n\t\t( primop 'match_fail'\n\t\t ({'function_clause',_11})\n\t\t -| [{'function_name',{'debug_info',1}}] )\n\t -| ['compiler_generated'] )\n\tend\n'encrypt_debug_info'/3 =\n %% Line 1422\n fun (_2,_1,_0) ->\n\t%% Line 1423\n\ttry\n\t let =\n\t\tapply %% Line 1424\n\t\t 'generate_key'/1\n\t\t (_1)\n\t in %% Line 1425\n\t\tcase apply 'start_crypto'/0\n\t\t\t () of\n\t\t %% Line 1426\n\t\t <'ok'> when 'true' ->\n\t\t let <_4> =\n\t\t\t apply 'encrypt'/2\n\t\t\t (RealKey, _2)\n\t\t in {'ok',_4,_0}\n\t\t %% Line 1427\n\t\t when 'true' ->\n\t\t E\n\t\t ( <_5> when 'true' ->\n\t\t\tprimop 'match_fail'\n\t\t\t ({'case_clause',_5})\n\t\t -| ['compiler_generated'] )\n\t\tend\n\tof <_6> ->\n\t _6\n\tcatch <_9,_8,_7> ->\n\t %% Line 1430\n\t case <_9,_8,_7> of\n\t <( 'error'\n\t\t -| ['compiler_generated'] ),_14,_15> when 'true' ->\n\t\t %% Line 1431\n\t\t {'error',[{'none','compile','bad_crypto_key'}]}\n\t ( <_16,_17,_18> when 'true' ->\n\t\t primop 'raise'\n\t\t\t(_18, _17)\n\t\t-| ['compiler_generated'] )\n\t end\n'cleanup_compile_options'/1 =\n %% Line 1434\n fun (_0) ->\n\t%% Line 1435\n\tcall 'lists':'filter'\n\t (( 'keep_compile_option'/1\n\t -| [{'id',{0,0,'-cleanup_compile_options/1-fun-0-'}}] ), _0)\n'keep_compile_option'/1 =\n %% Line 1438\n fun (_0) ->\n\tcase _0 of\n\t <'from_asm'> when 'true' ->\n\t 'false'\n\t %% Line 1439\n\t <'from_core'> when 'true' ->\n\t 'false'\n\t %% Line 1441\n\t <{'parse_transform',_2}> when 'true' ->\n\t 'false'\n\t %% Line 1442\n\t <{'d',_3,_4}> when 'true' ->\n\t 'false'\n\t %% Line 1444\n\t
=\n\t\t call %% Line 916\n\t\t 'gen':%% Line 916\n\t\t\t 'format_status_header'\n\t\t (%% Line 916\n\t\t [83|[116|[97|[116|[117|[115|[32|[102|[111|[114|[32|[103|[101|[110|[101|[114|[105|[99|[32|[115|[101|[114|[118|[101|[114]]]]]]]]]]]]]]]]]]]]]]]]], %% Line 916\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\tName)\n\t in let =\n\t\t call %% Line 917\n\t\t\t 'sys':%% Line 917\n\t\t\t\t 'get_debug'\n\t\t\t (%% Line 917\n\t\t\t 'log', %% Line 917\n\t\t\t\t Debug, %% Line 917\n\t\t\t\t\t [])\n\t\t in let <_@c6> =\n\t\t\t case %% Line 918\n\t\t\t apply 'format_status'/4\n\t\t\t\t (_@c1, Mod, PDict, State) of\n\t\t\t %% Line 919\n\t\t\t \n\t\t\t\twhen call 'erlang':'is_list'\n\t\t\t\t (S) ->\n\t\t\t\tS\n\t\t\t %% Line 920\n\t\t\t when 'true' ->\n\t\t\t\t[S|[]]\n\t\t\t end\n\t\t in %% Line 922\n\t\t\t [{'header',Header}|%% Line 923\n\t\t\t\t\t [{'data',[{[83|[116|[97|[116|[117|[115]]]]]],SysState}|%% Line 924\n\t\t\t\t\t\t\t\t\t\t\t\t [{[80|[97|[114|[101|[110|[116]]]]]],Parent}|%% Line 925\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t[{[76|[111|[103|[103|[101|[100|[32|[101|[118|[101|[110|[116|[115]]]]]]]]]]]]],Log}|[]]]]}|_@c6]]\n\t ( <_@c2> when 'true' ->\n\t\tprimop 'match_fail'\n\t\t ({'badmatch',_@c2})\n\t -| ['compiler_generated'] )\n\tend\n'format_status'/4 =\n %% Line 928\n fun (_@c3,_@c2,_@c1,_@c0) ->\n\tlet <_@c5> =\n\t case _@c3 of\n\t %% Line 930\n\t <'terminate'> when 'true' ->\n\t\t _@c0\n\t %% Line 931\n\t <_@c14> when 'true' ->\n\t\t [{'data',[{[83|[116|[97|[116|[101]]]]],_@c0}|[]]}|[]]\n\t end\n\tin %% Line 933\n\t case call 'erlang':'function_exported'\n\t\t (_@c2, 'format_status', 2) of\n\t %% Line 934\n\t <'true'> when 'true' ->\n\t\t let <_@c7> =\n\t\t catch\n\t\t\t %% Line 935\n\t\t\t call _@c2:'format_status'\n\t\t\t (_@c3, [_@c1|[_@c0|[]]])\n\t\t in %% Line 935\n\t\t case _@c7 of\n\t\t\t%% Line 936\n\t\t\t<{'EXIT',_@c15}> when 'true' ->\n\t\t\t _@c5\n\t\t\t%% Line 937\n\t\t\t when 'true' ->\n\t\t\t Else\n\t\t end\n\t %% Line 939\n\t <_@c16> when 'true' ->\n\t\t _@c5\n\t end\n'behaviour_info'/1 =\n fun (_@c0) ->\n\tcase _@c0 of\n\t <'callbacks'> when 'true' ->\n\t [{'init',1}|[{'handle_call',3}|[{'handle_cast',2}|[{'handle_info',2}|[{'terminate',2}|[{'code_change',3}|[{'format_status',2}]]]]]]]\n\t <'optional_callbacks'> when 'true' ->\n\t [{'handle_info',2}|[{'terminate',2}|[{'code_change',3}|[{'format_status',2}]]]]\n\t ( <_@c1> when 'true' ->\n\t\t( primop 'match_fail'\n\t\t ({'function_clause',_@c1})\n\t\t -| [{'function_name',{'behaviour_info',1}}] )\n\t -| ['compiler_generated'] )\n\tend\n'module_info'/0 =\n fun () ->\n\tcall 'erlang':'get_module_info'\n\t ('gen_server')\n'module_info'/1 =\n fun (_@c0) ->\n\tcall 'erlang':'get_module_info'\n\t ('gen_server', _@c0)\nend\n" }, { "path": "test_data/language_test.core", "content": "module 'language_test' ['module_info'/0,\n\t\t\t'module_info'/1]\n attributes [%% Line 1\n\t\t'file' =\n\t\t %% Line 1\n\t\t [{[108|[97|[110|[103|[117|[97|[103|[101|[95|[116|[101|[115|[116|[46|[101|[114|[108]]]]]]]]]]]]]]]]],1}]]\n'module_function_capture'/0 =\n %% Line 5\n fun () ->\n\t%% Line 6\n\tfun 'woohoo':'hoo'/2\n'do_throw'/0 =\n %% Line 8\n fun () ->\n\t%% Line 9\n\tcall 'erlang':'throw'\n\t ('something')\n'do_error'/0 =\n %% Line 10\n fun () ->\n\t%% Line 11\n\tcall 'erlang':'error'\n\t ('something')\n'do_exit'/0 =\n %% Line 12\n fun () ->\n\t%% Line 13\n\tcall 'erlang':'exit'\n\t ('something')\n'try_catch'/1 =\n %% Line 15\n fun (_0) ->\n\t%% Line 16\n\ttry\n\t apply _0\n\t\t()\n\tof <_1> ->\n\t %% Line 17\n\t 'woo'\n\tcatch <_5,_4,_3> ->\n\t %% Line 19\n\t case <_5,_4,_3> of\n\t <( 'throw'\n\t\t -| ['compiler_generated'] ),( 'hoo'\n\t\t\t\t\t -| ['compiler_generated'] ),_8> when 'true' ->\n\t\t 'a_throw'\n\t ( <_10,_11,_12> when 'true' ->\n\t\t primop 'raise'\n\t\t\t(_12, _11)\n\t\t-| ['compiler_generated'] )\n\t end\n'try_catch_finally'/1 =\n %% Line 22\n fun (_0) ->\n\t%% Line 23\n\tletrec\n\t 'after$^0'/0 =\n\t\tfun () ->\n\t\t %% Line 28\n\t\t 'some_after_clause'\n\tin try\n\t\ttry\n\t\t apply _0\n\t\t\t()\n\t\tof <_1> ->\n\t\t %% Line 24\n\t\t 'woo'\n\t\tcatch <_5,_4,_3> ->\n\t\t %% Line 26\n\t\t case <_5,_4,_3> of\n\t\t <( 'throw'\n\t\t\t -| ['compiler_generated'] ),( 'hoo'\n\t\t\t\t\t\t -| ['compiler_generated'] ),_12> when 'true' ->\n\t\t\t 'a_throw'\n\t\t ( <_14,_15,_16> when 'true' ->\n\t\t\t primop 'raise'\n\t\t\t\t(_16, _15)\n\t\t\t-| ['compiler_generated'] )\n\t\t end\n\t of <_6> ->\n\t\tdo ( apply 'after$^0'/0\n\t\t\t ()\n\t\t -| ['compiler_generated'] )\n\t\t _6\n\t catch <_9,_8,_7> ->\n\t\tdo ( apply 'after$^0'/0\n\t\t\t ()\n\t\t -| ['compiler_generated'] )\n\t\t primop 'raise'\n\t\t\t(_7, _8)\n'self_tail_call'/1 =\n %% Line 31\n fun (_0) ->\n\t%% Line 32\n\tcase _0 of\n\t %% Line 33\n\t <0> when 'true' ->\n\t %% Line 34\n\t 'reached_end'\n\t %% Line 35\n\t <_4> when 'true' ->\n\t let <_1> =\n\t\t call %% Line 36\n\t\t 'erlang':%% Line 36\n\t\t\t\t'-'\n\t\t (_0, %% Line 36\n\t\t\t 1)\n\t in %% Line 36\n\t\t apply 'self_tail_call'/1\n\t\t (_1)\n\tend\n'binary_construct_1'/1 =\n %% Line 39\n fun (_0) ->\n\t%% Line 40\n\t#{#<_0>(8,1,'integer',['unsigned'|['big']])}#\n'binary_pattern_match_1'/1 =\n %% Line 42\n fun (_0) ->\n\tcase _0 of\n\t <#{#<_X_A>(4,8,'integer',['signed'|['little']]),\n\t #<_X_B>('all',8,'binary',['unsigned'|['big']])}#> when 'true' ->\n\t %% Line 43\n\t 'matched'\n\t ( <_1> when 'true' ->\n\t\t( primop 'match_fail'\n\t\t ({'function_clause',_1})\n\t\t -| [{'function_name',{'binary_pattern_match_1',1}}] )\n\t -| ['compiler_generated'] )\n\tend\n'binary_pattern_match_2'/1 =\n %% Line 44\n fun (_0) ->\n\tcase _0 of\n\t <#{#<_X_A>(4,8,'integer',['signed'|['little']]),\n\t #<_X_B>(8,1,'integer',['unsigned'|['big']])}#> when 'true' ->\n\t %% Line 45\n\t 'matched'\n\t ( <_1> when 'true' ->\n\t\t( primop 'match_fail'\n\t\t ({'function_clause',_1})\n\t\t -| [{'function_name',{'binary_pattern_match_2',1}}] )\n\t -| ['compiler_generated'] )\n\tend\n'binary_pattern_match_3'/1 =\n %% Line 46\n fun (_0) ->\n\tcase _0 of\n\t <#{#<_X_A>(2,2,'integer',['signed'|['little']]),\n\t #<_X_B>('all',8,'binary',['unsigned'|['big']])}#> when 'true' ->\n\t %% Line 47\n\t 'matched'\n\t ( <_1> when 'true' ->\n\t\t( primop 'match_fail'\n\t\t ({'function_clause',_1})\n\t\t -| [{'function_name',{'binary_pattern_match_3',1}}] )\n\t -| ['compiler_generated'] )\n\tend\n'binary_pattern_match_4'/1 =\n %% Line 48\n fun (_0) ->\n\tcase _0 of\n\t <#{#<_X_A>(4,8,'float',['unsigned'|['big']]),\n\t #<_X_B>('all',8,'binary',['unsigned'|['big']])}#> when 'true' ->\n\t %% Line 49\n\t 'matched'\n\t ( <_1> when 'true' ->\n\t\t( primop 'match_fail'\n\t\t ({'function_clause',_1})\n\t\t -| [{'function_name',{'binary_pattern_match_4',1}}] )\n\t -| ['compiler_generated'] )\n\tend\n'module_info'/0 =\n fun () ->\n\tcall 'erlang':'get_module_info'\n\t ('language_test')\n'module_info'/1 =\n fun (_0) ->\n\tcall 'erlang':'get_module_info'\n\t ('language_test', _0)\nend\n" }, { "path": "test_data/language_test.erl", "content": "-module(language_test).\n\n-export([]).\n\nmodule_function_capture() ->\n fun woohoo:hoo/2.\n\ndo_throw() ->\n throw(something).\ndo_error() ->\n erlang:error(something).\ndo_exit() ->\n erlang:exit(something).\n\ntry_catch(A) ->\n try A() of\n _ -> woo\n catch\n throw:hoo -> a_throw\n end.\n\ntry_catch_finally(A) ->\n try A() of\n _ -> woo\n catch\n throw:hoo -> a_throw\n after\n some_after_clause\n end.\n\nself_tail_call(A) ->\n case A of\n 0 ->\n reached_end;\n _ ->\n self_tail_call(A - 1)\n end.\n\nbinary_construct_1(A) ->\n <>.\n\nbinary_pattern_match_1(<<_A:4/integer-signed-little-unit:8, _B/binary>>) ->\n matched.\nbinary_pattern_match_2(<<_A:4/integer-signed-little-unit:8, _B/integer>>) ->\n matched.\nbinary_pattern_match_3(<<_A:2/integer-signed-little-unit:2, _B/binary>>) ->\n matched.\nbinary_pattern_match_4(<<_A:4/float-unit:8, _B/binary>>) ->\n matched.\n" }, { "path": "test_data/long_strings.core", "content": "module 'long_strings' ['format_error'/1]\n attributes []\n\n'format_error'/1 =\n %% Line 242\n fun (_0) ->\n\tcase _0 of\n\t <'no_native_support'> when 'true' ->\n\t %% Line 243\n\t [116|[104|[105|[115|[32|[115|[121|[115|[116|[101|[109|[32|[105|[115|[32|[110|[111|[116|[32|[99|[111|[110|[102|[105|[103|[117|[114|[101|[100|[32|[102|[111|[114|[32|[110|[97|[116|[105|[118|[101|[45|[99|[111|[100|[101|[32|[99|[111|[109|[112|[105|[108|[97|[116|[105|[111|[110|[46]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]\n\t %% Line 244\n\t <'no_crypto'> when 'true' ->\n\t %% Line 245\n\t [116|[104|[105|[115|[32|[115|[121|[115|[116|[101|[109|[32|[105|[115|[32|[110|[111|[116|[32|[99|[111|[110|[102|[105|[103|[117|[114|[101|[100|[32|[119|[105|[116|[104|[32|[99|[114|[121|[112|[116|[111|[32|[115|[117|[112|[112|[111|[114|[116|[46]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]\n\t %% Line 246\n\t <'bad_crypto_key'> when 'true' ->\n\t %% Line 247\n\t [105|[110|[118|[97|[108|[105|[100|[32|[99|[114|[121|[112|[116|[111|[32|[107|[101|[121|[46]]]]]]]]]]]]]]]]]]]\n\t %% Line 248\n\t <'no_crypto_key'> when 'true' ->\n\t %% Line 249\n\t [110|[111|[32|[99|[114|[121|[112|[116|[111|[32|[107|[101|[121|[32|[115|[117|[112|[112|[108|[105|[101|[100|[46]]]]]]]]]]]]]]]]]]]]]]]\n\t %% Line 250\n\t <{'native',E}> when 'true' ->\n\t %% Line 251\n\t call 'io_lib':'fwrite'\n\t\t ([110|[97|[116|[105|[118|[101|[45|[99|[111|[100|[101|[32|[99|[111|[109|[112|[105|[108|[97|[116|[105|[111|[110|[32|[102|[97|[105|[108|[101|[100|[32|[119|[105|[116|[104|[32|[114|[101|[97|[115|[111|[110|[58|[32|[126|[116|[80|[46]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]], %% Line 252\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t [E|[25]])\n\t %% Line 253\n\t <{'native_crash',E,Stk}> when 'true' ->\n\t %% Line 254\n\t call 'io_lib':'fwrite'\n\t\t ([110|[97|[116|[105|[118|[101|[45|[99|[111|[100|[101|[32|[99|[111|[109|[112|[105|[108|[97|[116|[105|[111|[110|[32|[99|[114|[97|[115|[104|[101|[100|[32|[119|[105|[116|[104|[32|[114|[101|[97|[115|[111|[110|[58|[32|[126|[116|[80|[46|[10|[126|[116|[80|[10]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]], %% Line 255\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t [E|[25|[Stk|[25]]]])\n\t %% Line 256\n\t <{'open',E}> when 'true' ->\n\t let <_1> =\n\t\t call %% Line 257\n\t\t 'file':%% Line 257\n\t\t\t 'format_error'\n\t\t (%% Line 257\n\t\t E)\n\t in %% Line 257\n\t\t call 'io_lib':'format'\n\t\t ([111|[112|[101|[110|[32|[101|[114|[114|[111|[114|[32|[39|[126|[116|[115|[39]]]]]]]]]]]]]]]], [_1|[]])\n\t %% Line 258\n\t <{'epp',E}> when 'true' ->\n\t %% Line 259\n\t call 'epp':'format_error'\n\t\t (E)\n\t %% Line 260\n\t <'write_error'> when 'true' ->\n\t %% Line 261\n\t [101|[114|[114|[111|[114|[32|[119|[114|[105|[116|[105|[110|[103|[32|[102|[105|[108|[101]]]]]]]]]]]]]]]]]]\n\t %% Line 262\n\t <{'write_error',Error}> when 'true' ->\n\t let <_2> =\n\t\t call %% Line 263\n\t\t 'file':%% Line 263\n\t\t\t 'format_error'\n\t\t (%% Line 263\n\t\t Error)\n\t in %% Line 263\n\t\t call 'io_lib':'format'\n\t\t ([101|[114|[114|[111|[114|[32|[119|[114|[105|[116|[105|[110|[103|[32|[102|[105|[108|[101|[58|[32|[126|[116|[115]]]]]]]]]]]]]]]]]]]]]]], [_2|[]])\n\t %% Line 264\n\t <{'rename',From,To,Error}> when 'true' ->\n\t let <_3> =\n\t\t call %% Line 266\n\t\t 'file':%% Line 266\n\t\t\t 'format_error'\n\t\t (%% Line 266\n\t\t Error)\n\t in %% Line 265\n\t\t call 'io_lib':'format'\n\t\t ([102|[97|[105|[108|[101|[100|[32|[116|[111|[32|[114|[101|[110|[97|[109|[101|[32|[126|[116|[115|[32|[116|[111|[32|[126|[116|[115|[58|[32|[126|[116|[115]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]], %% Line 266\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t [From|[To|[_3|[]]]])\n\t %% Line 267\n\t <{'delete',File,Error}> when 'true' ->\n\t let <_4> =\n\t\t call %% Line 269\n\t\t 'file':%% Line 269\n\t\t\t 'format_error'\n\t\t (%% Line 269\n\t\t Error)\n\t in %% Line 268\n\t\t call 'io_lib':'format'\n\t\t ([102|[97|[105|[108|[101|[100|[32|[116|[111|[32|[100|[101|[108|[101|[116|[101|[32|[102|[105|[108|[101|[32|[126|[116|[115|[58|[32|[126|[116|[115]]]]]]]]]]]]]]]]]]]]]]]]]]]]]], %% Line 269\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t [File|[_4|[]]])\n\t %% Line 270\n\t <{'delete_temp',File,Error}> when 'true' ->\n\t let <_5> =\n\t\t call %% Line 272\n\t\t 'file':%% Line 272\n\t\t\t 'format_error'\n\t\t (%% Line 272\n\t\t Error)\n\t in %% Line 271\n\t\t call 'io_lib':'format'\n\t\t ([102|[97|[105|[108|[101|[100|[32|[116|[111|[32|[100|[101|[108|[101|[116|[101|[32|[116|[101|[109|[112|[111|[114|[97|[114|[121|[32|[102|[105|[108|[101|[32|[126|[116|[115|[58|[32|[126|[116|[115]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]], %% Line 272\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t [File|[_5|[]]])\n\t %% Line 273\n\t <{'parse_transform',M,R}> when 'true' ->\n\t %% Line 274\n\t call 'io_lib':'format'\n\t\t ([101|[114|[114|[111|[114|[32|[105|[110|[32|[112|[97|[114|[115|[101|[32|[116|[114|[97|[110|[115|[102|[111|[114|[109|[32|[39|[126|[116|[115|[39|[58|[32|[126|[116|[112]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]], [M|[R|[]]])\n\t %% Line 275\n\t <{'undef_parse_transform',M}> when 'true' ->\n\t %% Line 276\n\t call 'io_lib':'format'\n\t\t ([117|[110|[100|[101|[102|[105|[110|[101|[100|[32|[112|[97|[114|[115|[101|[32|[116|[114|[97|[110|[115|[102|[111|[114|[109|[32|[39|[126|[116|[115|[39]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]], [M|[]])\n\t %% Line 277\n\t <{'core_transform',M,R}> when 'true' ->\n\t %% Line 278\n\t call 'io_lib':'format'\n\t\t ([101|[114|[114|[111|[114|[32|[105|[110|[32|[99|[111|[114|[101|[32|[116|[114|[97|[110|[115|[102|[111|[114|[109|[32|[39|[126|[115|[39|[58|[32|[126|[116|[112]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]], [M|[R|[]]])\n\t %% Line 279\n\t <{'crash',Pass,Reason}> when 'true' ->\n\t let <_6> =\n\t\t apply %% Line 280\n\t\t\t'format_error_reason'/1\n\t\t (%% Line 280\n\t\t Reason)\n\t in %% Line 280\n\t\t call 'io_lib':'format'\n\t\t ([105|[110|[116|[101|[114|[110|[97|[108|[32|[101|[114|[114|[111|[114|[32|[105|[110|[32|[126|[112|[59|[10|[99|[114|[97|[115|[104|[32|[114|[101|[97|[115|[111|[110|[58|[32|[126|[116|[115]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]], [Pass|[_6|[]]])\n\t %% Line 281\n\t <{'bad_return',Pass,Reason}> when 'true' ->\n\t let <_7> =\n\t\t apply %% Line 282\n\t\t\t'format_error_reason'/1\n\t\t (%% Line 282\n\t\t Reason)\n\t in %% Line 282\n\t\t call 'io_lib':'format'\n\t\t ([105|[110|[116|[101|[114|[110|[97|[108|[32|[101|[114|[114|[111|[114|[32|[105|[110|[32|[126|[112|[59|[10|[98|[97|[100|[32|[114|[101|[116|[117|[114|[110|[32|[118|[97|[108|[117|[101|[58|[32|[126|[116|[115]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]], [Pass|[_7|[]]])\n\t %% Line 283\n\t <{'module_name',Mod,Filename}> when 'true' ->\n\t %% Line 284\n\t call 'io_lib':'format'\n\t\t ([77|[111|[100|[117|[108|[101|[32|[110|[97|[109|[101|[32|[39|[126|[115|[39|[32|[100|[111|[101|[115|[32|[110|[111|[116|[32|[109|[97|[116|[99|[104|[32|[102|[105|[108|[101|[32|[110|[97|[109|[101|[32|[39|[126|[116|[115|[39]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]], [Mod|[Filename|[]]])\n\t ( <_8> when 'true' ->\n\t\t( primop 'match_fail'\n\t\t ({'function_clause',_8})\n\t\t -| [{'function_name',{'format_error',1}}] )\n\t -| ['compiler_generated'] )\n\tend\n\nend\n" }, { "path": "test_data/long_strings.core.bak", "content": "module 'long_strings' ['format_error'/1]\n attributes []\n\n'format_error'/1 =\n %% Line 242\n fun (_0) ->\n\tcase _0 of\n\t <'no_native_support'> when 'true' ->\n\t %% Line 243\n\t [116|[104|[105|[115|[32|[115|[121|[115|[116|[101|[109|[32|[105|[115|[32|[110|[111|[116|[32|[99|[111|[110|[102|[105|[103|[117|[114|[101|[100|[32|[102|[111|[114|[32|[110|[97|[116|[105|[118|[101|[45|[99|[111|[100|[101|[32|[99|[111|[109|[112|[105|[108|[97|[116|[105|[111|[110|[46]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]\n\t %% Line 244\n\t <'no_crypto'> when 'true' ->\n\t %% Line 245\n\t [116|[104|[105|[115|[32|[115|[121|[115|[116|[101|[109|[32|[105|[115|[32|[110|[111|[116|[32|[99|[111|[110|[102|[105|[103|[117|[114|[101|[100|[32|[119|[105|[116|[104|[32|[99|[114|[121|[112|[116|[111|[32|[115|[117|[112|[112|[111|[114|[116|[46]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]\n\t %% Line 246\n\t <'bad_crypto_key'> when 'true' ->\n\t %% Line 247\n\t [105|[110|[118|[97|[108|[105|[100|[32|[99|[114|[121|[112|[116|[111|[32|[107|[101|[121|[46]]]]]]]]]]]]]]]]]]]\n\t %% Line 248\n\t <'no_crypto_key'> when 'true' ->\n\t %% Line 249\n\t [110|[111|[32|[99|[114|[121|[112|[116|[111|[32|[107|[101|[121|[32|[115|[117|[112|[112|[108|[105|[101|[100|[46]]]]]]]]]]]]]]]]]]]]]]]\n\t %% Line 250\n\t <{'native',E}> when 'true' ->\n\t %% Line 251\n\t call 'io_lib':'fwrite'\n\t\t ([110|[97|[116|[105|[118|[101|[45|[99|[111|[100|[101|[32|[99|[111|[109|[112|[105|[108|[97|[116|[105|[111|[110|[32|[102|[97|[105|[108|[101|[100|[32|[119|[105|[116|[104|[32|[114|[101|[97|[115|[111|[110|[58|[32|[126|[116|[80|[46]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]], %% Line 252\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t [E|[25]])\n\t %% Line 253\n\t <{'native_crash',E,Stk}> when 'true' ->\n\t %% Line 254\n\t call 'io_lib':'fwrite'\n\t\t ([110|[97|[116|[105|[118|[101|[45|[99|[111|[100|[101|[32|[99|[111|[109|[112|[105|[108|[97|[116|[105|[111|[110|[32|[99|[114|[97|[115|[104|[101|[100|[32|[119|[105|[116|[104|[32|[114|[101|[97|[115|[111|[110|[58|[32|[126|[116|[80|[46|[10|[126|[116|[80|[10]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]], %% Line 255\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t [E|[25|[Stk|[25]]]])\n\t %% Line 256\n\t <{'open',E}> when 'true' ->\n\t let <_1> =\n\t\t call %% Line 257\n\t\t 'file':%% Line 257\n\t\t\t 'format_error'\n\t\t (%% Line 257\n\t\t E)\n\t in %% Line 257\n\t\t call 'io_lib':'format'\n\t\t ([111|[112|[101|[110|[32|[101|[114|[114|[111|[114|[32|[39|[126|[116|[115|[39]]]]]]]]]]]]]]]], [_1|[]])\n\t %% Line 258\n\t <{'epp',E}> when 'true' ->\n\t %% Line 259\n\t call 'epp':'format_error'\n\t\t (E)\n\t %% Line 260\n\t <'write_error'> when 'true' ->\n\t %% Line 261\n\t [101|[114|[114|[111|[114|[32|[119|[114|[105|[116|[105|[110|[103|[32|[102|[105|[108|[101]]]]]]]]]]]]]]]]]]\n\t %% Line 262\n\t <{'write_error',Error}> when 'true' ->\n\t let <_2> =\n\t\t call %% Line 263\n\t\t 'file':%% Line 263\n\t\t\t 'format_error'\n\t\t (%% Line 263\n\t\t Error)\n\t in %% Line 263\n\t\t call 'io_lib':'format'\n\t\t ([101|[114|[114|[111|[114|[32|[119|[114|[105|[116|[105|[110|[103|[32|[102|[105|[108|[101|[58|[32|[126|[116|[115]]]]]]]]]]]]]]]]]]]]]]], [_2|[]])\n\t %% Line 264\n\t <{'rename',From,To,Error}> when 'true' ->\n\t let <_3> =\n\t\t call %% Line 266\n\t\t 'file':%% Line 266\n\t\t\t 'format_error'\n\t\t (%% Line 266\n\t\t Error)\n\t in %% Line 265\n\t\t call 'io_lib':'format'\n\t\t ([102|[97|[105|[108|[101|[100|[32|[116|[111|[32|[114|[101|[110|[97|[109|[101|[32|[126|[116|[115|[32|[116|[111|[32|[126|[116|[115|[58|[32|[126|[116|[115]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]], %% Line 266\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t [From|[To|[_3|[]]]])\n\t %% Line 267\n\t <{'delete',File,Error}> when 'true' ->\n\t let <_4> =\n\t\t call %% Line 269\n\t\t 'file':%% Line 269\n\t\t\t 'format_error'\n\t\t (%% Line 269\n\t\t Error)\n\t in %% Line 268\n\t\t call 'io_lib':'format'\n\t\t ([102|[97|[105|[108|[101|[100|[32|[116|[111|[32|[100|[101|[108|[101|[116|[101|[32|[102|[105|[108|[101|[32|[126|[116|[115|[58|[32|[126|[116|[115]]]]]]]]]]]]]]]]]]]]]]]]]]]]]], %% Line 269\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t [File|[_4|[]]])\n\t %% Line 270\n\t <{'delete_temp',File,Error}> when 'true' ->\n\t let <_5> =\n\t\t call %% Line 272\n\t\t 'file':%% Line 272\n\t\t\t 'format_error'\n\t\t (%% Line 272\n\t\t Error)\n\t in %% Line 271\n\t\t call 'io_lib':'format'\n\t\t ([102|[97|[105|[108|[101|[100|[32|[116|[111|[32|[100|[101|[108|[101|[116|[101|[32|[116|[101|[109|[112|[111|[114|[97|[114|[121|[32|[102|[105|[108|[101|[32|[126|[116|[115|[58|[32|[126|[116|[115]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]], %% Line 272\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t [File|[_5|[]]])\n\t %% Line 273\n\t <{'parse_transform',M,R}> when 'true' ->\n\t %% Line 274\n\t call 'io_lib':'format'\n\t\t ([101|[114|[114|[111|[114|[32|[105|[110|[32|[112|[97|[114|[115|[101|[32|[116|[114|[97|[110|[115|[102|[111|[114|[109|[32|[39|[126|[116|[115|[39|[58|[32|[126|[116|[112]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]], [M|[R|[]]])\n\t %% Line 275\n\t <{'undef_parse_transform',M}> when 'true' ->\n\t %% Line 276\n\t call 'io_lib':'format'\n\t\t ([117|[110|[100|[101|[102|[105|[110|[101|[100|[32|[112|[97|[114|[115|[101|[32|[116|[114|[97|[110|[115|[102|[111|[114|[109|[32|[39|[126|[116|[115|[39]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]], [M|[]])\n\t %% Line 277\n\t <{'core_transform',M,R}> when 'true' ->\n\t %% Line 278\n\t call 'io_lib':'format'\n\t\t ([101|[114|[114|[111|[114|[32|[105|[110|[32|[99|[111|[114|[101|[32|[116|[114|[97|[110|[115|[102|[111|[114|[109|[32|[39|[126|[115|[39|[58|[32|[126|[116|[112]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]], [M|[R|[]]])\n\t %% Line 279\n\t <{'crash',Pass,Reason}> when 'true' ->\n\t let <_6> =\n\t\t apply %% Line 280\n\t\t\t'format_error_reason'/1\n\t\t (%% Line 280\n\t\t Reason)\n\t in %% Line 280\n\t\t call 'io_lib':'format'\n\t\t ([105|[110|[116|[101|[114|[110|[97|[108|[32|[101|[114|[114|[111|[114|[32|[105|[110|[32|[126|[112|[59|[10|[99|[114|[97|[115|[104|[32|[114|[101|[97|[115|[111|[110|[58|[32|[126|[116|[115]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]], [Pass|[_6|[]]])\n\t %% Line 281\n\t <{'bad_return',Pass,Reason}> when 'true' ->\n\t let <_7> =\n\t\t apply %% Line 282\n\t\t\t'format_error_reason'/1\n\t\t (%% Line 282\n\t\t Reason)\n\t in %% Line 282\n\t\t call 'io_lib':'format'\n\t\t ([105|[110|[116|[101|[114|[110|[97|[108|[32|[101|[114|[114|[111|[114|[32|[105|[110|[32|[126|[112|[59|[10|[98|[97|[100|[32|[114|[101|[116|[117|[114|[110|[32|[118|[97|[108|[117|[101|[58|[32|[126|[116|[115]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]], [Pass|[_7|[]]])\n\t %% Line 283\n\t <{'module_name',Mod,Filename}> when 'true' ->\n\t %% Line 284\n\t call 'io_lib':'format'\n\t\t ([77|[111|[100|[117|[108|[101|[32|[110|[97|[109|[101|[32|[39|[126|[115|[39|[32|[100|[111|[101|[115|[32|[110|[111|[116|[32|[109|[97|[116|[99|[104|[32|[102|[105|[108|[101|[32|[110|[97|[109|[101|[32|[39|[126|[116|[115|[39]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]], [Mod|[Filename|[]]])\n\t %% Line 285\n\t <'reparsing_invalid_unicode'> when 'true' ->\n\t %% Line 286\n\t [78|[111|[110|[45|[85|[84|[70|[45|[56|[32|[99|[104|[97|[114|[97|[99|[116|[101|[114|[40|[115|[41|[32|[100|[101|[116|[101|[99|[116|[101|[100|[44|[32|[98|[117|[116|[32|[110|[111|[32|[101|[110|[99|[111|[100|[105|[110|[103|[32|[100|[101|[99|[108|[97|[114|[101|[100|[46|[32|[69|[110|[99|[111|[100|[101|[32|[116|[104|[101|[32|[102|[105|[108|[101|[32|[105|[110|[32|[85|[84|[70|[45|[56|[32|[111|[114|[32|[97|[100|[100|[32|[34|[37|[37|[32|[99|[111|[100|[105|[110|[103|[58|[32|[108|[97|[116|[105|[110|[45|[49|[34|[32|[97|[116|[32|[116|[104|[101|[32|[98|[101|[103|[105|[110|[110|[105|[110|[103|[32|[111|[102|[32|[116|[104|[101|[32|[102|[105|[108|[101|[46|[32|[82|[101|[116|[114|[121|[105|[110|[103|[32|[119|[105|[116|[104|[32|[108|[97|[116|[105|[110|[45|[49|[32|[101|[110|[99|[111|[100|[105|[110|[103|[46]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]\n\t ( <_8> when 'true' ->\n\t\t( primop 'match_fail'\n\t\t ({'function_clause',_8})\n\t\t -| [{'function_name',{'format_error',1}}] )\n\t -| ['compiler_generated'] )\n\tend\n\nend\n" }, { "path": "test_data/map_test.core", "content": "module 'maptest' ['module_info'/0,\n\t\t 'module_info'/1,\n\t\t 'test'/0,\n\t\t 'test6'/1,\n\t\t 'test7'/1]\n attributes [%% Line 1\n\t\t'file' =\n\t\t %% Line 1\n\t\t [{[109|[97|[112|[95|[116|[101|[115|[116|[46|[101|[114|[108]]]]]]]]]]]],1}]]\n'test'/0 =\n %% Line 5\n fun () ->\n\t%% Line 6\n\t~{'foo'=>'bar','woo'=>[104|[111|[111]]]}~\n'test6'/1 =\n %% Line 8\n fun (_0) ->\n\t%% Line 9\n\tcase _0 of\n\t %% Line 10\n\t <~{{'hoo'}:='true','foo':='bar'}~> when 'true' ->\n\t 'lsdlla'\n\t %% Line 11\n\t <_3> when 'true' ->\n\t 'false'\n\tend\n'test7'/2 =\n %% Line 14\n fun (_0, _1) ->\n\t%% Line 15\n\tcase <_0, _1> of\n\t %% Line 16\n\t <~{~{'foo'=>'bar'}~:='true'}~, _something> when 'true' ->\n\t 'lpsdlas'\n\t %% Line 17\n\t <_3, _somethingelse> when 'true' ->\n\t apply 'test7'/1\n\t\t (_0)\n\tend\n'foo'/0 =\n %% Line 20\n fun () ->\n\t12\n'module_info'/0 =\n fun () ->\n\tcall 'erlang':'get_module_info'\n\t ('maptest')\n'module_info'/1 =\n fun (_0) ->\n\tcall 'erlang':'get_module_info'\n\t ('maptest', _0)\nend\n" }, { "path": "test_data/map_test.erl", "content": "-module(maptest).\n-export([test/0, test6/1, test7/1]).\n%-export([test/0, test2/2, test3/2, test4/2]).\n\ntest() ->\n #{woo => \"hoo\", foo => bar}.\n\ntest6(Woo) ->\n case Woo of\n #{ {hoo} := true, foo := bar } -> lsdlla;\n _ -> false\n end.\n\ntest7(Woo, Hoo) ->\n case of\n <#{ #{ foo => bar } := true }, _> -> lpsdlas;\n <_, _> -> test7(Woo, Hoo)\n end.\n\nfoo() -> 12.\n\n% test2(Woo, Hoo) ->\n% case Woo of\n% #{Hoo := true} -> true;\n% _ -> false\n% end.\n% \n% test3(Woo, Hoo) ->\n% case Woo of\n% { Hoo } -> true;\n% _ -> false\n% end.\n% \n% test4(Woo, Hoo) ->\n% case Woo of\n% { Hoo, Foo, Foo } -> true;\n% _ -> false\n% end.\n% \n% test5(Woo, Hoo) ->\n% T = {Hoo},\n% case Woo of\n% #{T := true} -> true;\n% _ -> false\n% end.\n" }, { "path": "test_data/maps.abstr", "content": "{attribute,1,file,{\"maps.erl\",1}}.\n{attribute,21,module,maps}.\n{attribute,23,export,\n [{get,3},\n {filter,2},\n {fold,3},\n {map,2},\n {size,1},\n {new,0},\n {update_with,3},\n {update_with,4},\n {without,2},\n {with,2},\n {iterator,1},\n {next,1}]}.\n{attribute,30,export,\n [{get,2},\n {find,2},\n {from_list,1},\n {is_key,2},\n {keys,1},\n {merge,2},\n {put,3},\n {remove,2},\n {take,2},\n {to_list,1},\n {update,3},\n {values,1}]}.\n{attribute,35,opaque,\n {iterator,\n {type,35,union,\n [{type,35,tuple,\n [{var,35,'Key'},\n {var,35,'Value'},\n {user_type,35,iterator,[{var,35,'Key'},{var,35,'Value'}]}]},\n {atom,35,none},\n {type,36,nonempty_improper_list,\n [{type,36,integer,[]},\n {type,36,map,\n [{type,36,map_field_assoc,\n [{var,36,'Key'},{var,36,'Value'}]}]}]}]},\n [{var,35,'Key'},{var,35,'Value'}]}}.\n{attribute,38,type,\n {iterator,{user_type,38,iterator,\n [{type,38,term,[]},{type,38,term,[]}]},\n []}}.\n{attribute,40,export_type,[{iterator,2},{iterator,0}]}.\n{attribute,42,dialyzer,{no_improper_lists,{iterator,1}}}.\n{attribute,47,spec,\n {{get,2},\n [{type,47,bounded_fun,\n [{type,47,'fun',\n [{type,47,product,[{var,47,'Key'},{var,47,'Map'}]},\n {var,47,'Value'}]},\n [{type,48,constraint,\n [{atom,48,is_subtype},\n [{var,48,'Key'},{type,48,term,[]}]]},\n {type,49,constraint,\n [{atom,49,is_subtype},\n [{var,49,'Map'},{type,49,map,any}]]},\n {type,50,constraint,\n [{atom,50,is_subtype},\n [{var,50,'Value'},{type,50,term,[]}]]}]]}]}}.\n{function,52,get,2,\n [{clause,52,\n [{var,52,'_'},{var,52,'_'}],\n [],\n [{call,52,\n {remote,52,{atom,52,erlang},{atom,52,nif_error}},\n [{atom,52,undef}]}]}]}.\n{attribute,54,spec,\n {{find,2},\n [{type,54,bounded_fun,\n [{type,54,'fun',\n [{type,54,product,[{var,54,'Key'},{var,54,'Map'}]},\n {type,54,union,\n [{type,54,tuple,[{atom,54,ok},{var,54,'Value'}]},\n {atom,54,error}]}]},\n [{type,55,constraint,\n [{atom,55,is_subtype},\n [{var,55,'Map'},\n {type,55,map,\n [{type,55,map_field_assoc,\n [{var,55,'Key'},{var,55,'Value'}]},\n {type,55,map_field_assoc,\n [{var,55,'_'},{var,55,'_'}]}]}]]}]]}]}}.\n{function,57,find,2,\n [{clause,57,\n [{var,57,'_'},{var,57,'_'}],\n [],\n [{call,57,\n {remote,57,{atom,57,erlang},{atom,57,nif_error}},\n [{atom,57,undef}]}]}]}.\n{attribute,60,spec,\n {{from_list,1},\n [{type,60,bounded_fun,\n [{type,60,'fun',\n [{type,60,product,[{var,60,'List'}]},{var,60,'Map'}]},\n [{type,61,constraint,\n [{atom,61,is_subtype},\n [{var,61,'List'},\n {type,61,list,\n [{type,61,tuple,[{var,61,'Key'},{var,61,'Value'}]}]}]]},\n {type,62,constraint,\n [{atom,62,is_subtype},[{var,62,'Key'},{type,62,term,[]}]]},\n {type,63,constraint,\n [{atom,63,is_subtype},[{var,63,'Value'},{type,63,term,[]}]]},\n {type,64,constraint,\n [{atom,64,is_subtype},\n [{var,64,'Map'},{type,64,map,any}]]}]]}]}}.\n{function,66,from_list,1,\n [{clause,66,\n [{var,66,'_'}],\n [],\n [{call,66,\n {remote,66,{atom,66,erlang},{atom,66,nif_error}},\n [{atom,66,undef}]}]}]}.\n{attribute,70,spec,\n {{is_key,2},\n [{type,70,bounded_fun,\n [{type,70,'fun',\n [{type,70,product,[{var,70,'Key'},{var,70,'Map'}]},\n {type,70,boolean,[]}]},\n [{type,71,constraint,\n [{atom,71,is_subtype},\n [{var,71,'Key'},{type,71,term,[]}]]},\n {type,72,constraint,\n [{atom,72,is_subtype},\n [{var,72,'Map'},{type,72,map,any}]]}]]}]}}.\n{function,74,is_key,2,\n [{clause,74,\n [{var,74,'_'},{var,74,'_'}],\n [],\n [{call,74,\n {remote,74,{atom,74,erlang},{atom,74,nif_error}},\n [{atom,74,undef}]}]}]}.\n{attribute,77,spec,\n {{keys,1},\n [{type,77,bounded_fun,\n [{type,77,'fun',\n [{type,77,product,[{var,77,'Map'}]},{var,77,'Keys'}]},\n [{type,78,constraint,\n [{atom,78,is_subtype},\n [{var,78,'Map'},\n {type,78,map,\n [{type,78,map_field_assoc,\n [{var,78,'Key'},{var,78,'_'}]}]}]]},\n {type,79,constraint,\n [{atom,79,is_subtype},\n [{var,79,'Keys'},{type,79,list,[{var,79,'Key'}]}]]}]]}]}}.\n{function,81,keys,1,\n [{clause,81,\n [{var,81,'_'}],\n [],\n [{call,81,\n {remote,81,{atom,81,erlang},{atom,81,nif_error}},\n [{atom,81,undef}]}]}]}.\n{attribute,85,spec,\n {{merge,2},\n [{type,85,bounded_fun,\n [{type,85,'fun',\n [{type,85,product,[{var,85,'Map1'},{var,85,'Map2'}]},\n {var,85,'Map3'}]},\n [{type,86,constraint,\n [{atom,86,is_subtype},\n [{var,86,'Map1'},{type,86,map,any}]]},\n {type,87,constraint,\n [{atom,87,is_subtype},\n [{var,87,'Map2'},{type,87,map,any}]]},\n {type,88,constraint,\n [{atom,88,is_subtype},\n [{var,88,'Map3'},{type,88,map,any}]]}]]}]}}.\n{function,90,merge,2,\n [{clause,90,\n [{var,90,'_'},{var,90,'_'}],\n [],\n [{call,90,\n {remote,90,{atom,90,erlang},{atom,90,nif_error}},\n [{atom,90,undef}]}]}]}.\n{attribute,94,spec,\n {{put,3},\n [{type,94,bounded_fun,\n [{type,94,'fun',\n [{type,94,product,\n [{var,94,'Key'},\n {var,94,'Value'},\n {var,94,'Map1'}]},\n {var,94,'Map2'}]},\n [{type,95,constraint,\n [{atom,95,is_subtype},\n [{var,95,'Key'},{type,95,term,[]}]]},\n {type,96,constraint,\n [{atom,96,is_subtype},\n [{var,96,'Value'},{type,96,term,[]}]]},\n {type,97,constraint,\n [{atom,97,is_subtype},\n [{var,97,'Map1'},{type,97,map,any}]]},\n {type,98,constraint,\n [{atom,98,is_subtype},\n [{var,98,'Map2'},{type,98,map,any}]]}]]}]}}.\n{function,100,put,3,\n [{clause,100,\n [{var,100,'_'},{var,100,'_'},{var,100,'_'}],\n [],\n [{call,100,\n {remote,100,{atom,100,erlang},{atom,100,nif_error}},\n [{atom,100,undef}]}]}]}.\n{attribute,104,spec,\n {{remove,2},\n [{type,104,bounded_fun,\n [{type,104,'fun',\n [{type,104,product,\n [{var,104,'Key'},{var,104,'Map1'}]},\n {var,104,'Map2'}]},\n [{type,105,constraint,\n [{atom,105,is_subtype},\n [{var,105,'Key'},{type,105,term,[]}]]},\n {type,106,constraint,\n [{atom,106,is_subtype},\n [{var,106,'Map1'},{type,106,map,any}]]},\n {type,107,constraint,\n [{atom,107,is_subtype},\n [{var,107,'Map2'},{type,107,map,any}]]}]]}]}}.\n{function,109,remove,2,\n [{clause,109,\n [{var,109,'_'},{var,109,'_'}],\n [],\n [{call,109,\n {remote,109,{atom,109,erlang},{atom,109,nif_error}},\n [{atom,109,undef}]}]}]}.\n{attribute,111,spec,\n {{take,2},\n [{type,111,bounded_fun,\n [{type,111,'fun',\n [{type,111,product,[{var,111,'Key'},{var,111,'Map1'}]},\n {type,111,union,\n [{type,111,tuple,[{var,111,'Value'},{var,111,'Map2'}]},\n {atom,111,error}]}]},\n [{type,112,constraint,\n [{atom,112,is_subtype},\n [{var,112,'Map1'},\n {type,112,map,\n [{type,112,map_field_assoc,\n [{var,112,'Key'},{var,112,'Value'}]},\n {type,112,map_field_assoc,\n [{var,112,'_'},{var,112,'_'}]}]}]]},\n {type,113,constraint,\n [{atom,113,is_subtype},\n [{var,113,'Map2'},\n {type,113,map,\n [{type,113,map_field_assoc,\n [{var,113,'_'},{var,113,'_'}]}]}]]}]]}]}}.\n{function,115,take,2,\n [{clause,115,\n [{var,115,'_'},{var,115,'_'}],\n [],\n [{call,115,\n {remote,115,{atom,115,erlang},{atom,115,nif_error}},\n [{atom,115,undef}]}]}]}.\n{attribute,117,spec,\n {{to_list,1},\n [{type,117,bounded_fun,\n [{type,117,'fun',\n [{type,117,product,[{var,117,'Map'}]},\n {type,117,list,\n [{type,117,tuple,[{var,117,'Key'},{var,117,'Value'}]}]}]},\n [{type,118,constraint,\n [{atom,118,is_subtype},\n [{var,118,'Map'},\n {type,118,map,\n [{type,118,map_field_assoc,\n [{var,118,'Key'},{var,118,'Value'}]}]}]]}]]}]}}.\n{function,120,to_list,1,\n [{clause,120,\n [{var,120,'Map'}],\n [[{call,120,{atom,120,is_map},[{var,120,'Map'}]}]],\n [{call,121,\n {atom,121,to_list_internal},\n [{call,121,\n {remote,121,{atom,121,erts_internal},{atom,121,map_next}},\n [{integer,121,0},{var,121,'Map'},{nil,121}]}]}]},\n {clause,122,\n [{var,122,'Map'}],\n [],\n [{call,123,\n {remote,123,{atom,123,erlang},{atom,123,error}},\n [{tuple,123,[{atom,123,badmap},{var,123,'Map'}]},\n {cons,123,{var,123,'Map'},{nil,123}}]}]}]}.\n{function,125,to_list_internal,1,\n [{clause,125,\n [{cons,125,\n {var,125,'Iter'},\n {cons,125,{var,125,'Map'},{var,125,'Acc'}}}],\n [[{call,125,{atom,125,is_integer},[{var,125,'Iter'}]}]],\n [{call,126,\n {atom,126,to_list_internal},\n [{call,126,\n {remote,126,{atom,126,erts_internal},{atom,126,map_next}},\n [{var,126,'Iter'},{var,126,'Map'},{var,126,'Acc'}]}]}]},\n {clause,127,[{var,127,'Acc'}],[],[{var,128,'Acc'}]}]}.\n{attribute,131,spec,\n {{update,3},\n [{type,131,bounded_fun,\n [{type,131,'fun',\n [{type,131,product,\n [{var,131,'Key'},{var,131,'Value'},{var,131,'Map1'}]},\n {var,131,'Map2'}]},\n [{type,132,constraint,\n [{atom,132,is_subtype},\n [{var,132,'Map1'},\n {type,132,map,\n [{type,132,map_field_exact,\n [{var,132,'Key'},{var,132,'_'}]},\n {type,132,map_field_assoc,\n [{var,132,'_'},{var,132,'_'}]}]}]]},\n {type,133,constraint,\n [{atom,133,is_subtype},\n [{var,133,'Map2'},\n {type,133,map,\n [{type,133,map_field_exact,\n [{var,133,'Key'},{var,133,'Value'}]},\n {type,133,map_field_assoc,\n [{var,133,'_'},{var,133,'_'}]}]}]]}]]}]}}.\n{function,135,update,3,\n [{clause,135,\n [{var,135,'_'},{var,135,'_'},{var,135,'_'}],\n [],\n [{call,135,\n {remote,135,{atom,135,erlang},{atom,135,nif_error}},\n [{atom,135,undef}]}]}]}.\n{attribute,138,spec,\n {{values,1},\n [{type,138,bounded_fun,\n [{type,138,'fun',\n [{type,138,product,[{var,138,'Map'}]},{var,138,'Values'}]},\n [{type,139,constraint,\n [{atom,139,is_subtype},\n [{var,139,'Map'},\n {type,139,map,\n [{type,139,map_field_assoc,\n [{var,139,'_'},{var,139,'Value'}]}]}]]},\n {type,140,constraint,\n [{atom,140,is_subtype},\n [{var,140,'Values'},\n {type,140,list,[{var,140,'Value'}]}]]}]]}]}}.\n{function,142,values,1,\n [{clause,142,\n [{var,142,'_'}],\n [],\n [{call,142,\n {remote,142,{atom,142,erlang},{atom,142,nif_error}},\n [{atom,142,undef}]}]}]}.\n{attribute,146,spec,\n {{new,0},\n [{type,146,bounded_fun,\n [{type,146,'fun',[{type,146,product,[]},{var,146,'Map'}]},\n [{type,147,constraint,\n [{atom,147,is_subtype},\n [{var,147,'Map'},{type,147,map,[]}]]}]]}]}}.\n{function,149,new,0,[{clause,149,[],[],[{map,149,[]}]}]}.\n{attribute,151,spec,\n {{update_with,3},\n [{type,151,bounded_fun,\n [{type,151,'fun',\n [{type,151,product,\n [{var,151,'Key'},{var,151,'Fun'},{var,151,'Map1'}]},\n {var,151,'Map2'}]},\n [{type,152,constraint,\n [{atom,152,is_subtype},\n [{var,152,'Map1'},\n {type,152,map,\n [{type,152,map_field_exact,\n [{var,152,'Key'},{var,152,'Value1'}]},\n {type,152,map_field_assoc,\n [{var,152,'_'},{var,152,'_'}]}]}]]},\n {type,153,constraint,\n [{atom,153,is_subtype},\n [{var,153,'Map2'},\n {type,153,map,\n [{type,153,map_field_exact,\n [{var,153,'Key'},{var,153,'Value2'}]},\n {type,153,map_field_assoc,\n [{var,153,'_'},{var,153,'_'}]}]}]]},\n {type,154,constraint,\n [{atom,154,is_subtype},\n [{var,154,'Fun'},\n {type,154,'fun',\n [{type,154,product,[{var,154,'Value1'}]},\n {var,154,'Value2'}]}]]}]]}]}}.\n{function,156,update_with,3,\n [{clause,156,\n [{var,156,'Key'},{var,156,'Fun'},{var,156,'Map'}],\n [[{call,156,{atom,156,is_function},[{var,156,'Fun'},{integer,156,1}]},\n {call,156,{atom,156,is_map},[{var,156,'Map'}]}]],\n [{'case',157,\n {var,157,'Map'},\n [{clause,158,\n [{map,158,\n [{map_field_exact,158,\n {var,158,'Key'},\n {var,158,'Value'}}]}],\n [],\n [{map,158,\n {var,158,'Map'},\n [{map_field_exact,158,\n {var,158,'Key'},\n {call,158,\n {var,158,'Fun'},\n [{var,158,'Value'}]}}]}]},\n {clause,159,\n [{map,159,[]}],\n [],\n [{call,159,\n {remote,159,{atom,159,erlang},{atom,159,error}},\n [{tuple,159,[{atom,159,badkey},{var,159,'Key'}]},\n {cons,159,\n {var,159,'Key'},\n {cons,159,\n {var,159,'Fun'},\n {cons,159,\n {var,159,'Map'},\n {nil,159}}}}]}]}]}]},\n {clause,161,\n [{var,161,'Key'},{var,161,'Fun'},{var,161,'Map'}],\n [],\n [{call,162,\n {remote,162,{atom,162,erlang},{atom,162,error}},\n [{call,162,{atom,162,error_type},[{var,162,'Map'}]},\n {cons,162,\n {var,162,'Key'},\n {cons,162,\n {var,162,'Fun'},\n {cons,162,{var,162,'Map'},{nil,162}}}}]}]}]}.\n{attribute,165,spec,\n {{update_with,4},\n [{type,165,bounded_fun,\n [{type,165,'fun',\n [{type,165,product,\n [{var,165,'Key'},\n {var,165,'Fun'},\n {var,165,'Init'},\n {var,165,'Map1'}]},\n {var,165,'Map2'}]},\n [{type,166,constraint,\n [{atom,166,is_subtype},\n [{var,166,'Map1'},\n {type,166,map,\n [{type,166,map_field_assoc,\n [{var,166,'Key'},{var,166,'Value1'}]},\n {type,166,map_field_assoc,\n [{var,166,'_'},{var,166,'_'}]}]}]]},\n {type,167,constraint,\n [{atom,167,is_subtype},\n [{var,167,'Map2'},\n {type,167,map,\n [{type,167,map_field_exact,\n [{var,167,'Key'},\n {type,167,union,\n [{var,167,'Value2'},{var,167,'Init'}]}]},\n {type,167,map_field_assoc,\n [{var,167,'_'},{var,167,'_'}]}]}]]},\n {type,168,constraint,\n [{atom,168,is_subtype},\n [{var,168,'Fun'},\n {type,168,'fun',\n [{type,168,product,[{var,168,'Value1'}]},\n {var,168,'Value2'}]}]]}]]}]}}.\n{function,170,update_with,4,\n [{clause,170,\n [{var,170,'Key'},{var,170,'Fun'},{var,170,'Init'},{var,170,'Map'}],\n [[{call,170,{atom,170,is_function},[{var,170,'Fun'},{integer,170,1}]},\n {call,170,{atom,170,is_map},[{var,170,'Map'}]}]],\n [{'case',171,\n {var,171,'Map'},\n [{clause,172,\n [{map,172,\n [{map_field_exact,172,\n {var,172,'Key'},\n {var,172,'Value'}}]}],\n [],\n [{map,172,\n {var,172,'Map'},\n [{map_field_exact,172,\n {var,172,'Key'},\n {call,172,\n {var,172,'Fun'},\n [{var,172,'Value'}]}}]}]},\n {clause,173,\n [{map,173,[]}],\n [],\n [{map,173,\n {var,173,'Map'},\n [{map_field_assoc,173,\n {var,173,'Key'},\n {var,173,'Init'}}]}]}]}]},\n {clause,175,\n [{var,175,'Key'},{var,175,'Fun'},{var,175,'Init'},{var,175,'Map'}],\n [],\n [{call,176,\n {remote,176,{atom,176,erlang},{atom,176,error}},\n [{call,176,{atom,176,error_type},[{var,176,'Map'}]},\n {cons,176,\n {var,176,'Key'},\n {cons,176,\n {var,176,'Fun'},\n {cons,176,\n {var,176,'Init'},\n {cons,176,{var,176,'Map'},{nil,176}}}}}]}]}]}.\n{attribute,179,spec,\n {{get,3},\n [{type,179,bounded_fun,\n [{type,179,'fun',\n [{type,179,product,\n [{var,179,'Key'},{var,179,'Map'},{var,179,'Default'}]},\n {type,179,union,[{var,179,'Value'},{var,179,'Default'}]}]},\n [{type,180,constraint,\n [{atom,180,is_subtype},\n [{var,180,'Map'},\n {type,180,map,\n [{type,180,map_field_assoc,\n [{var,180,'Key'},{var,180,'Value'}]},\n {type,180,map_field_assoc,\n [{var,180,'_'},{var,180,'_'}]}]}]]}]]}]}}.\n{function,182,get,3,\n [{clause,182,\n [{var,182,'Key'},{var,182,'Map'},{var,182,'Default'}],\n [[{call,182,{atom,182,is_map},[{var,182,'Map'}]}]],\n [{'case',183,\n {var,183,'Map'},\n [{clause,184,\n [{map,184,\n [{map_field_exact,184,\n {var,184,'Key'},\n {var,184,'Value'}}]}],\n [],\n [{var,184,'Value'}]},\n {clause,185,[{map,185,[]}],[],[{var,185,'Default'}]}]}]},\n {clause,187,\n [{var,187,'Key'},{var,187,'Map'},{var,187,'Default'}],\n [],\n [{call,188,\n {remote,188,{atom,188,erlang},{atom,188,error}},\n [{tuple,188,[{atom,188,badmap},{var,188,'Map'}]},\n {cons,188,\n {var,188,'Key'},\n {cons,188,\n {var,188,'Map'},\n {cons,188,{var,188,'Default'},{nil,188}}}}]}]}]}.\n{attribute,191,spec,\n {{filter,2},\n [{type,191,bounded_fun,\n [{type,191,'fun',\n [{type,191,product,[{var,191,'Pred'},{var,191,'MapOrIter'}]},\n {var,191,'Map'}]},\n [{type,192,constraint,\n [{atom,192,is_subtype},\n [{var,192,'Pred'},\n {type,192,'fun',\n [{type,192,product,[{var,192,'Key'},{var,192,'Value'}]},\n {type,192,boolean,[]}]}]]},\n {type,193,constraint,\n [{atom,193,is_subtype},\n [{var,193,'MapOrIter'},\n {type,193,union,\n [{type,193,map,\n [{type,193,map_field_assoc,\n [{var,193,'Key'},{var,193,'Value'}]}]},\n {user_type,193,iterator,\n [{var,193,'Key'},{var,193,'Value'}]}]}]]},\n {type,194,constraint,\n [{atom,194,is_subtype},\n [{var,194,'Map'},\n {type,194,map,\n [{type,194,map_field_assoc,\n [{var,194,'Key'},{var,194,'Value'}]}]}]]}]]}]}}.\n{function,196,filter,2,\n [{clause,196,\n [{var,196,'Pred'},{var,196,'Map'}],\n [[{call,196,\n {atom,196,is_function},\n [{var,196,'Pred'},{integer,196,2}]},\n {call,196,{atom,196,is_map},[{var,196,'Map'}]}]],\n [{call,197,\n {remote,197,{atom,197,maps},{atom,197,from_list}},\n [{call,197,\n {atom,197,filter_1},\n [{var,197,'Pred'},\n {call,197,{atom,197,iterator},[{var,197,'Map'}]}]}]}]},\n {clause,198,\n [{var,198,'Pred'},{var,198,'Iterator'}],\n [[{call,198,\n {atom,198,is_function},\n [{var,198,'Pred'},{integer,198,2}]},\n {op,198,'andalso',\n {call,198,{atom,198,is_tuple},[{var,198,'Iterator'}]},\n {op,198,'==',\n {call,198,{atom,198,tuple_size},[{var,198,'Iterator'}]},\n {integer,198,3}}}],\n [{op,198,'==',{var,198,'Iterator'},{atom,198,none}}],\n [{op,198,'andalso',\n {call,198,\n {atom,198,is_integer},\n [{call,198,{atom,198,hd},[{var,198,'Iterator'}]}]},\n {call,198,\n {atom,198,is_map},\n [{call,198,{atom,198,tl},[{var,198,'Iterator'}]}]}}]],\n [{call,199,\n {remote,199,{atom,199,maps},{atom,199,from_list}},\n [{call,199,\n {atom,199,filter_1},\n [{var,199,'Pred'},{var,199,'Iterator'}]}]}]},\n {clause,200,\n [{var,200,'Pred'},{var,200,'Map'}],\n [],\n [{call,201,\n {remote,201,{atom,201,erlang},{atom,201,error}},\n [{call,201,{atom,201,error_type},[{var,201,'Map'}]},\n {cons,201,\n {var,201,'Pred'},\n {cons,201,{var,201,'Map'},{nil,201}}}]}]}]}.\n{function,203,filter_1,2,\n [{clause,203,\n [{var,203,'Pred'},{var,203,'Iter'}],\n [],\n [{'case',204,\n {call,204,{atom,204,next},[{var,204,'Iter'}]},\n [{clause,205,\n [{tuple,205,\n [{var,205,'K'},{var,205,'V'},{var,205,'NextIter'}]}],\n [],\n [{'case',206,\n {call,206,\n {var,206,'Pred'},\n [{var,206,'K'},{var,206,'V'}]},\n [{clause,207,\n [{atom,207,true}],\n [],\n [{cons,208,\n {tuple,208,[{var,208,'K'},{var,208,'V'}]},\n {call,208,\n {atom,208,filter_1},\n [{var,208,'Pred'},\n {var,208,'NextIter'}]}}]},\n {clause,209,\n [{atom,209,false}],\n [],\n [{call,210,\n {atom,210,filter_1},\n [{var,210,'Pred'},\n {var,210,'NextIter'}]}]}]}]},\n {clause,212,[{atom,212,none}],[],[{nil,213}]}]}]}]}.\n{attribute,216,spec,\n {{fold,3},\n [{type,216,bounded_fun,\n [{type,216,'fun',\n [{type,216,product,\n [{var,216,'Fun'},{var,216,'Init'},{var,216,'MapOrIter'}]},\n {var,216,'Acc'}]},\n [{type,217,constraint,\n [{atom,217,is_subtype},\n [{var,217,'Fun'},\n {type,217,'fun',\n [{type,217,product,\n [{var,217,'Key'},\n {var,217,'Value'},\n {var,217,'AccIn'}]},\n {var,217,'AccOut'}]}]]},\n {type,218,constraint,\n [{atom,218,is_subtype},[{var,218,'Init'},{type,218,term,[]}]]},\n {type,219,constraint,\n [{atom,219,is_subtype},[{var,219,'Acc'},{var,219,'AccOut'}]]},\n {type,220,constraint,\n [{atom,220,is_subtype},\n [{var,220,'AccIn'},\n {type,220,union,[{var,220,'Init'},{var,220,'AccOut'}]}]]},\n {type,221,constraint,\n [{atom,221,is_subtype},\n [{var,221,'MapOrIter'},\n {type,221,union,\n [{type,221,map,\n [{type,221,map_field_assoc,\n [{var,221,'Key'},{var,221,'Value'}]}]},\n {user_type,221,iterator,\n [{var,221,'Key'},{var,221,'Value'}]}]}]]}]]}]}}.\n{function,223,fold,3,\n [{clause,223,\n [{var,223,'Fun'},{var,223,'Init'},{var,223,'Map'}],\n [[{call,223,{atom,223,is_function},[{var,223,'Fun'},{integer,223,3}]},\n {call,223,{atom,223,is_map},[{var,223,'Map'}]}]],\n [{call,224,\n {atom,224,fold_1},\n [{var,224,'Fun'},\n {var,224,'Init'},\n {call,224,{atom,224,iterator},[{var,224,'Map'}]}]}]},\n {clause,225,\n [{var,225,'Fun'},{var,225,'Init'},{var,225,'Iterator'}],\n [[{call,225,{atom,225,is_function},[{var,225,'Fun'},{integer,225,3}]},\n {op,225,'andalso',\n {call,225,{atom,225,is_tuple},[{var,225,'Iterator'}]},\n {op,225,'==',\n {call,225,{atom,225,tuple_size},[{var,225,'Iterator'}]},\n {integer,225,3}}}],\n [{op,225,'==',{var,225,'Iterator'},{atom,225,none}}],\n [{op,225,'andalso',\n {call,225,\n {atom,225,is_integer},\n [{call,225,{atom,225,hd},[{var,225,'Iterator'}]}]},\n {call,225,\n {atom,225,is_map},\n [{call,225,{atom,225,tl},[{var,225,'Iterator'}]}]}}]],\n [{call,226,\n {atom,226,fold_1},\n [{var,226,'Fun'},{var,226,'Init'},{var,226,'Iterator'}]}]},\n {clause,227,\n [{var,227,'Fun'},{var,227,'Init'},{var,227,'Map'}],\n [],\n [{call,228,\n {remote,228,{atom,228,erlang},{atom,228,error}},\n [{call,228,{atom,228,error_type_iter},[{var,228,'Map'}]},\n {cons,228,\n {var,228,'Fun'},\n {cons,228,\n {var,228,'Init'},\n {cons,228,{var,228,'Map'},{nil,228}}}}]}]}]}.\n{function,230,fold_1,3,\n [{clause,230,\n [{var,230,'Fun'},{var,230,'Acc'},{var,230,'Iter'}],\n [],\n [{'case',231,\n {call,231,{atom,231,next},[{var,231,'Iter'}]},\n [{clause,232,\n [{tuple,232,\n [{var,232,'K'},{var,232,'V'},{var,232,'NextIter'}]}],\n [],\n [{call,233,\n {atom,233,fold_1},\n [{var,233,'Fun'},\n {call,233,\n {var,233,'Fun'},\n [{var,233,'K'},{var,233,'V'},{var,233,'Acc'}]},\n {var,233,'NextIter'}]}]},\n {clause,234,[{atom,234,none}],[],[{var,235,'Acc'}]}]}]}]}.\n{attribute,238,spec,\n {{map,2},\n [{type,238,bounded_fun,\n [{type,238,'fun',\n [{type,238,product,[{var,238,'Fun'},{var,238,'MapOrIter'}]},\n {var,238,'Map'}]},\n [{type,239,constraint,\n [{atom,239,is_subtype},\n [{var,239,'Fun'},\n {type,239,'fun',\n [{type,239,product,[{var,239,'Key'},{var,239,'Value1'}]},\n {var,239,'Value2'}]}]]},\n {type,240,constraint,\n [{atom,240,is_subtype},\n [{var,240,'MapOrIter'},\n {type,240,union,\n [{type,240,map,\n [{type,240,map_field_assoc,\n [{var,240,'Key'},{var,240,'Value1'}]}]},\n {user_type,240,iterator,\n [{var,240,'Key'},{var,240,'Value1'}]}]}]]},\n {type,241,constraint,\n [{atom,241,is_subtype},\n [{var,241,'Map'},\n {type,241,map,\n [{type,241,map_field_assoc,\n [{var,241,'Key'},{var,241,'Value2'}]}]}]]}]]}]}}.\n{function,243,map,2,\n [{clause,243,\n [{var,243,'Fun'},{var,243,'Map'}],\n [[{call,243,{atom,243,is_function},[{var,243,'Fun'},{integer,243,2}]},\n {call,243,{atom,243,is_map},[{var,243,'Map'}]}]],\n [{call,244,\n {remote,244,{atom,244,maps},{atom,244,from_list}},\n [{call,244,\n {atom,244,map_1},\n [{var,244,'Fun'},\n {call,244,{atom,244,iterator},[{var,244,'Map'}]}]}]}]},\n {clause,245,\n [{var,245,'Fun'},{var,245,'Iterator'}],\n [[{call,245,{atom,245,is_function},[{var,245,'Fun'},{integer,245,2}]},\n {op,245,'andalso',\n {call,245,{atom,245,is_tuple},[{var,245,'Iterator'}]},\n {op,245,'==',\n {call,245,{atom,245,tuple_size},[{var,245,'Iterator'}]},\n {integer,245,3}}}],\n [{op,245,'==',{var,245,'Iterator'},{atom,245,none}}],\n [{op,245,'andalso',\n {call,245,\n {atom,245,is_integer},\n [{call,245,{atom,245,hd},[{var,245,'Iterator'}]}]},\n {call,245,\n {atom,245,is_map},\n [{call,245,{atom,245,tl},[{var,245,'Iterator'}]}]}}]],\n [{call,246,\n {remote,246,{atom,246,maps},{atom,246,from_list}},\n [{call,246,\n {atom,246,map_1},\n [{var,246,'Fun'},{var,246,'Iterator'}]}]}]},\n {clause,247,\n [{var,247,'Fun'},{var,247,'Map'}],\n [],\n [{call,248,\n {remote,248,{atom,248,erlang},{atom,248,error}},\n [{call,248,{atom,248,error_type_iter},[{var,248,'Map'}]},\n {cons,248,\n {var,248,'Fun'},\n {cons,248,{var,248,'Map'},{nil,248}}}]}]}]}.\n{function,250,map_1,2,\n [{clause,250,\n [{var,250,'Fun'},{var,250,'Iter'}],\n [],\n [{'case',251,\n {call,251,{atom,251,next},[{var,251,'Iter'}]},\n [{clause,252,\n [{tuple,252,\n [{var,252,'K'},{var,252,'V'},{var,252,'NextIter'}]}],\n [],\n [{cons,253,\n {tuple,253,\n [{var,253,'K'},\n {call,253,\n {var,253,'Fun'},\n [{var,253,'K'},{var,253,'V'}]}]},\n {call,253,\n {atom,253,map_1},\n [{var,253,'Fun'},{var,253,'NextIter'}]}}]},\n {clause,254,[{atom,254,none}],[],[{nil,255}]}]}]}]}.\n{attribute,258,spec,\n {{size,1},\n [{type,258,bounded_fun,\n [{type,258,'fun',\n [{type,258,product,[{var,258,'Map'}]},\n {type,258,non_neg_integer,[]}]},\n [{type,259,constraint,\n [{atom,259,is_subtype},\n [{var,259,'Map'},{type,259,map,any}]]}]]}]}}.\n{function,261,size,1,\n [{clause,261,\n [{var,261,'Map'}],\n [[{call,261,{atom,261,is_map},[{var,261,'Map'}]}]],\n [{call,262,\n {remote,262,{atom,262,erlang},{atom,262,map_size}},\n [{var,262,'Map'}]}]},\n {clause,263,\n [{var,263,'Val'}],\n [],\n [{call,264,\n {remote,264,{atom,264,erlang},{atom,264,error}},\n [{tuple,264,[{atom,264,badmap},{var,264,'Val'}]},\n {cons,264,{var,264,'Val'},{nil,264}}]}]}]}.\n{attribute,266,spec,\n {{iterator,1},\n [{type,266,bounded_fun,\n [{type,266,'fun',\n [{type,266,product,[{var,266,'Map'}]},{var,266,'Iterator'}]},\n [{type,267,constraint,\n [{atom,267,is_subtype},\n [{var,267,'Map'},\n {type,267,map,\n [{type,267,map_field_assoc,\n [{var,267,'Key'},{var,267,'Value'}]}]}]]},\n {type,268,constraint,\n [{atom,268,is_subtype},\n [{var,268,'Iterator'},\n {user_type,268,iterator,\n [{var,268,'Key'},{var,268,'Value'}]}]]}]]}]}}.\n{function,270,iterator,1,\n [{clause,270,\n [{var,270,'M'}],\n [[{call,270,{atom,270,is_map},[{var,270,'M'}]}]],\n [{cons,270,{integer,270,0},{var,270,'M'}}]},\n {clause,271,\n [{var,271,'M'}],\n [],\n [{call,271,\n {remote,271,{atom,271,erlang},{atom,271,error}},\n [{tuple,271,[{atom,271,badmap},{var,271,'M'}]},\n {cons,271,{var,271,'M'},{nil,271}}]}]}]}.\n{attribute,273,spec,\n {{next,1},\n [{type,273,bounded_fun,\n [{type,273,'fun',\n [{type,273,product,[{var,273,'Iterator'}]},\n {type,273,union,\n [{type,273,tuple,\n [{var,273,'Key'},\n {var,273,'Value'},\n {var,273,'NextIterator'}]},\n {atom,273,none}]}]},\n [{type,274,constraint,\n [{atom,274,is_subtype},\n [{var,274,'Iterator'},\n {user_type,274,iterator,\n [{var,274,'Key'},{var,274,'Value'}]}]]},\n {type,275,constraint,\n [{atom,275,is_subtype},\n [{var,275,'NextIterator'},\n {user_type,275,iterator,\n [{var,275,'Key'},{var,275,'Value'}]}]]}]]}]}}.\n{function,276,next,1,\n [{clause,276,\n [{tuple,276,[{var,276,'K'},{var,276,'V'},{var,276,'I'}]}],\n [],\n [{tuple,277,[{var,277,'K'},{var,277,'V'},{var,277,'I'}]}]},\n {clause,278,\n [{cons,278,{var,278,'Path'},{var,278,'Map'}}],\n [[{call,278,{atom,278,is_integer},[{var,278,'Path'}]},\n {call,278,{atom,278,is_map},[{var,278,'Map'}]}]],\n [{call,279,\n {remote,279,\n {atom,279,erts_internal},\n {atom,279,map_next}},\n [{var,279,'Path'},\n {var,279,'Map'},\n {atom,279,iterator}]}]},\n {clause,280,[{atom,280,none}],[],[{atom,281,none}]},\n {clause,282,\n [{var,282,'Iter'}],\n [],\n [{call,283,\n {remote,283,{atom,283,erlang},{atom,283,error}},\n [{atom,283,badarg},\n {cons,283,{var,283,'Iter'},{nil,283}}]}]}]}.\n{attribute,285,spec,\n {{without,2},\n [{type,285,bounded_fun,\n [{type,285,'fun',\n [{type,285,product,\n [{var,285,'Ks'},{var,285,'Map1'}]},\n {var,285,'Map2'}]},\n [{type,286,constraint,\n [{atom,286,is_subtype},\n [{var,286,'Ks'},{type,286,list,[{var,286,'K'}]}]]},\n {type,287,constraint,\n [{atom,287,is_subtype},\n [{var,287,'Map1'},{type,287,map,any}]]},\n {type,288,constraint,\n [{atom,288,is_subtype},\n [{var,288,'Map2'},{type,288,map,any}]]},\n {type,289,constraint,\n [{atom,289,is_subtype},\n [{var,289,'K'},{type,289,term,[]}]]}]]}]}}.\n{function,291,without,2,\n [{clause,291,\n [{var,291,'Ks'},{var,291,'M'}],\n [[{call,291,{atom,291,is_list},[{var,291,'Ks'}]},\n {call,291,{atom,291,is_map},[{var,291,'M'}]}]],\n [{call,292,\n {remote,292,{atom,292,lists},{atom,292,foldl}},\n [{'fun',292,\n {function,\n {atom,292,maps},\n {atom,292,remove},\n {integer,292,2}}},\n {var,292,'M'},\n {var,292,'Ks'}]}]},\n {clause,293,\n [{var,293,'Ks'},{var,293,'M'}],\n [],\n [{call,294,\n {remote,294,{atom,294,erlang},{atom,294,error}},\n [{call,294,{atom,294,error_type},[{var,294,'M'}]},\n {cons,294,\n {var,294,'Ks'},\n {cons,294,{var,294,'M'},{nil,294}}}]}]}]}.\n{attribute,296,spec,\n {{with,2},\n [{type,296,bounded_fun,\n [{type,296,'fun',\n [{type,296,product,[{var,296,'Ks'},{var,296,'Map1'}]},\n {var,296,'Map2'}]},\n [{type,297,constraint,\n [{atom,297,is_subtype},\n [{var,297,'Ks'},{type,297,list,[{var,297,'K'}]}]]},\n {type,298,constraint,\n [{atom,298,is_subtype},\n [{var,298,'Map1'},\n {type,298,map,\n [{type,298,map_field_assoc,\n [{var,298,'K'},{var,298,'V'}]},\n {type,298,map_field_assoc,\n [{var,298,'_'},{var,298,'_'}]}]}]]},\n {type,299,constraint,\n [{atom,299,is_subtype},\n [{var,299,'Map2'},\n {type,299,map,\n [{type,299,map_field_assoc,\n [{var,299,'K'},{var,299,'V'}]}]}]]}]]}]}}.\n{function,301,with,2,\n [{clause,301,\n [{var,301,'Ks'},{var,301,'Map1'}],\n [[{call,301,{atom,301,is_list},[{var,301,'Ks'}]},\n {call,301,{atom,301,is_map},[{var,301,'Map1'}]}]],\n [{call,302,\n {remote,302,{atom,302,maps},{atom,302,from_list}},\n [{call,302,\n {atom,302,with_1},\n [{var,302,'Ks'},{var,302,'Map1'}]}]}]},\n {clause,303,\n [{var,303,'Ks'},{var,303,'M'}],\n [],\n [{call,304,\n {remote,304,{atom,304,erlang},{atom,304,error}},\n [{call,304,{atom,304,error_type},[{var,304,'M'}]},\n {cons,304,\n {var,304,'Ks'},\n {cons,304,{var,304,'M'},{nil,304}}}]}]}]}.\n{function,306,with_1,2,\n [{clause,306,\n [{cons,306,{var,306,'K'},{var,306,'Ks'}},{var,306,'Map'}],\n [],\n [{'case',307,\n {var,307,'Map'},\n [{clause,308,\n [{map,308,\n [{map_field_exact,308,{var,308,'K'},{var,308,'V'}}]}],\n [],\n [{cons,308,\n {tuple,308,[{var,308,'K'},{var,308,'V'}]},\n {call,308,\n {atom,308,with_1},\n [{var,308,'Ks'},{var,308,'Map'}]}}]},\n {clause,309,\n [{map,309,[]}],\n [],\n [{call,309,\n {atom,309,with_1},\n [{var,309,'Ks'},{var,309,'Map'}]}]}]}]},\n {clause,311,[{nil,311},{var,311,'_Map'}],[],[{nil,311}]}]}.\n{function,313,error_type,1,\n [{clause,313,\n [{var,313,'M'}],\n [[{call,313,{atom,313,is_map},[{var,313,'M'}]}]],\n [{atom,313,badarg}]},\n {clause,314,\n [{var,314,'V'}],\n [],\n [{tuple,314,[{atom,314,badmap},{var,314,'V'}]}]}]}.\n{function,316,error_type_iter,1,\n [{clause,316,\n [{var,316,'M'}],\n [[{call,316,{atom,316,is_map},[{var,316,'M'}]}],\n [{op,316,'andalso',\n {call,316,{atom,316,is_tuple},[{var,316,'M'}]},\n {op,316,'==',\n {call,316,{atom,316,tuple_size},[{var,316,'M'}]},\n {integer,316,3}}}],\n [{op,316,'==',{var,316,'M'},{atom,316,none}}],\n [{op,316,'andalso',\n {call,316,\n {atom,316,is_integer},\n [{call,316,{atom,316,hd},[{var,316,'M'}]}]},\n {call,316,\n {atom,316,is_map},\n [{call,316,{atom,316,tl},[{var,316,'M'}]}]}}]],\n [{atom,316,badarg}]},\n {clause,317,\n [{var,317,'V'}],\n [],\n [{tuple,317,[{atom,317,badmap},{var,317,'V'}]}]}]}.\n{eof,318}.\n" }, { "path": "test_data/maps.erl", "content": "%%\n%% %CopyrightBegin%\n%%\n%% Copyright Ericsson AB 2013-2019. All Rights Reserved.\n%%\n%% Licensed under the Apache License, Version 2.0 (the \"License\");\n%% you may not use this file except in compliance with the License.\n%% You may obtain a copy of the License at\n%%\n%% http://www.apache.org/licenses/LICENSE-2.0\n%%\n%% Unless required by applicable law or agreed to in writing, software\n%% distributed under the License is distributed on an \"AS IS\" BASIS,\n%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n%% See the License for the specific language governing permissions and\n%% limitations under the License.\n%%\n%% %CopyrightEnd%\n%%\n\n-module(maps).\n\n-export([get/3, filter/2,fold/3,\n map/2, size/1, new/0,\n update_with/3, update_with/4,\n without/2, with/2,\n iterator/1, next/1]).\n\n%% BIFs\n-export([get/2, find/2, from_list/1,\n is_key/2, keys/1, merge/2,\n put/3, remove/2, take/2,\n to_list/1, update/3, values/1]).\n\n-opaque iterator(Key, Value) :: {Key, Value, iterator(Key, Value)} | none\n | nonempty_improper_list(integer(), #{Key => Value}).\n\n-type iterator() :: iterator(term(), term()).\n\n-export_type([iterator/2, iterator/0]).\n\n-dialyzer({no_improper_lists, iterator/1}).\n\n-define(IS_ITERATOR(I), is_tuple(I) andalso tuple_size(I) == 3; I == none; is_integer(hd(I)) andalso is_map(tl(I))).\n\n%% Shadowed by erl_bif_types: maps:get/2\n-spec get(Key,Map) -> Value when\n Key :: term(),\n Map :: map(),\n Value :: term().\n\nget(_,_) -> erlang:nif_error(undef).\n\n-spec find(Key,Map) -> {ok, Value} | error when\n Map :: #{Key => Value, _ => _}.\n\nfind(_,_) -> erlang:nif_error(undef).\n\n%% Shadowed by erl_bif_types: maps:from_list/1\n-spec from_list(List) -> Map when\n List :: [{Key,Value}],\n Key :: term(),\n Value :: term(),\n Map :: map().\n\nfrom_list(_) -> erlang:nif_error(undef).\n\n\n%% Shadowed by erl_bif_types: maps:is_key/2\n-spec is_key(Key,Map) -> boolean() when\n Key :: term(),\n Map :: map().\n\nis_key(_,_) -> erlang:nif_error(undef).\n\n\n-spec keys(Map) -> Keys when\n Map :: #{Key => _},\n Keys :: [Key].\n\nkeys(_) -> erlang:nif_error(undef).\n\n\n%% Shadowed by erl_bif_types: maps:merge/2\n-spec merge(Map1,Map2) -> Map3 when\n Map1 :: map(),\n Map2 :: map(),\n Map3 :: map().\n\nmerge(_,_) -> erlang:nif_error(undef).\n\n\n%% Shadowed by erl_bif_types: maps:put/3\n-spec put(Key,Value,Map1) -> Map2 when\n Key :: term(),\n Value :: term(),\n Map1 :: map(),\n Map2 :: map().\n\nput(_,_,_) -> erlang:nif_error(undef).\n\n\n%% Shadowed by erl_bif_types: maps:remove/2\n-spec remove(Key,Map1) -> Map2 when\n Key :: term(),\n Map1 :: map(),\n Map2 :: map().\n\nremove(_,_) -> erlang:nif_error(undef).\n\n-spec take(Key,Map1) -> {Value,Map2} | error when\n Map1 :: #{Key => Value, _ => _},\n Map2 :: #{_ => _}.\n\ntake(_,_) -> erlang:nif_error(undef).\n\n-spec to_list(Map) -> [{Key,Value}] when\n Map :: #{Key => Value}.\n\nto_list(Map) when is_map(Map) ->\n to_list_internal(erts_internal:map_next(0, Map, []));\nto_list(Map) ->\n erlang:error({badmap,Map},[Map]).\n\nto_list_internal([Iter, Map | Acc]) when is_integer(Iter) ->\n to_list_internal(erts_internal:map_next(Iter, Map, Acc));\nto_list_internal(Acc) ->\n Acc.\n\n%% Shadowed by erl_bif_types: maps:update/3\n-spec update(Key,Value,Map1) -> Map2 when\n Map1 :: #{Key := _, _ => _},\n Map2 :: #{Key := Value, _ => _}.\n\nupdate(_,_,_) -> erlang:nif_error(undef).\n\n\n-spec values(Map) -> Values when\n Map :: #{_ => Value},\n Values :: [Value].\n\nvalues(_) -> erlang:nif_error(undef).\n\n%% End of BIFs\n\n-spec new() -> Map when\n Map :: #{}.\n\nnew() -> #{}.\n\n-spec update_with(Key,Fun,Map1) -> Map2 when\n Map1 :: #{Key := Value1, _ => _},\n Map2 :: #{Key := Value2, _ => _},\n Fun :: fun((Value1) -> Value2).\n\nupdate_with(Key,Fun,Map) when is_function(Fun,1), is_map(Map) ->\n case Map of\n #{Key := Value} -> Map#{Key := Fun(Value)};\n #{} -> erlang:error({badkey,Key},[Key,Fun,Map])\n end;\nupdate_with(Key,Fun,Map) ->\n erlang:error(error_type(Map),[Key,Fun,Map]).\n\n\n-spec update_with(Key,Fun,Init,Map1) -> Map2 when\n Map1 :: #{Key => Value1, _ => _},\n Map2 :: #{Key := Value2 | Init, _ => _},\n Fun :: fun((Value1) -> Value2).\n\nupdate_with(Key,Fun,Init,Map) when is_function(Fun,1), is_map(Map) ->\n case Map of\n #{Key := Value} -> Map#{Key := Fun(Value)};\n #{} -> Map#{Key => Init}\n end;\nupdate_with(Key,Fun,Init,Map) ->\n erlang:error(error_type(Map),[Key,Fun,Init,Map]).\n\n\n-spec get(Key, Map, Default) -> Value | Default when\n Map :: #{Key => Value, _ => _}.\n\nget(Key,Map,Default) when is_map(Map) ->\n case Map of\n #{Key := Value} -> Value;\n #{} -> Default\n end;\nget(Key,Map,Default) ->\n erlang:error({badmap,Map},[Key,Map,Default]).\n\n\n-spec filter(Pred, MapOrIter) -> Map when\n Pred :: fun((Key, Value) -> boolean()),\n MapOrIter :: #{Key => Value} | iterator(Key, Value),\n Map :: #{Key => Value}.\n\nfilter(Pred,Map) when is_function(Pred,2), is_map(Map) ->\n maps:from_list(filter_1(Pred, iterator(Map)));\nfilter(Pred,Iterator) when is_function(Pred,2), ?IS_ITERATOR(Iterator) ->\n maps:from_list(filter_1(Pred, Iterator));\nfilter(Pred,Map) ->\n erlang:error(error_type(Map),[Pred,Map]).\n\nfilter_1(Pred, Iter) ->\n case next(Iter) of\n {K, V, NextIter} ->\n case Pred(K,V) of\n true ->\n [{K,V} | filter_1(Pred, NextIter)];\n false ->\n filter_1(Pred, NextIter)\n end;\n none ->\n []\n end.\n\n-spec fold(Fun,Init,MapOrIter) -> Acc when\n Fun :: fun((Key, Value, AccIn) -> AccOut),\n Init :: term(),\n Acc :: AccOut,\n AccIn :: Init | AccOut,\n MapOrIter :: #{Key => Value} | iterator(Key, Value).\n\nfold(Fun,Init,Map) when is_function(Fun,3), is_map(Map) ->\n fold_1(Fun,Init,iterator(Map));\nfold(Fun,Init,Iterator) when is_function(Fun,3), ?IS_ITERATOR(Iterator) ->\n fold_1(Fun,Init,Iterator);\nfold(Fun,Init,Map) ->\n erlang:error(error_type_iter(Map),[Fun,Init,Map]).\n\nfold_1(Fun, Acc, Iter) ->\n case next(Iter) of\n {K, V, NextIter} ->\n fold_1(Fun, Fun(K,V,Acc), NextIter);\n none ->\n Acc\n end.\n\n-spec map(Fun,MapOrIter) -> Map when\n Fun :: fun((Key, Value1) -> Value2),\n MapOrIter :: #{Key => Value1} | iterator(Key, Value1),\n Map :: #{Key => Value2}.\n\nmap(Fun,Map) when is_function(Fun, 2), is_map(Map) ->\n maps:from_list(map_1(Fun, iterator(Map)));\nmap(Fun,Iterator) when is_function(Fun, 2), ?IS_ITERATOR(Iterator) ->\n maps:from_list(map_1(Fun, Iterator));\nmap(Fun,Map) ->\n erlang:error(error_type_iter(Map),[Fun,Map]).\n\nmap_1(Fun, Iter) ->\n case next(Iter) of\n {K, V, NextIter} ->\n [{K, Fun(K, V)} | map_1(Fun, NextIter)];\n none ->\n []\n end.\n\n-spec size(Map) -> non_neg_integer() when\n Map :: map().\n\nsize(Map) when is_map(Map) ->\n erlang:map_size(Map);\nsize(Val) ->\n erlang:error({badmap,Val},[Val]).\n\n-spec iterator(Map) -> Iterator when\n Map :: #{Key => Value},\n Iterator :: iterator(Key, Value).\n\niterator(M) when is_map(M) -> [0 | M];\niterator(M) -> erlang:error({badmap, M}, [M]).\n\n-spec next(Iterator) -> {Key, Value, NextIterator} | 'none' when\n Iterator :: iterator(Key, Value),\n NextIterator :: iterator(Key, Value).\nnext({K, V, I}) ->\n {K, V, I};\nnext([Path | Map]) when is_integer(Path), is_map(Map) ->\n erts_internal:map_next(Path, Map, iterator);\nnext(none) ->\n none;\nnext(Iter) ->\n erlang:error(badarg, [Iter]).\n\n-spec without(Ks,Map1) -> Map2 when\n Ks :: [K],\n Map1 :: map(),\n Map2 :: map(),\n K :: term().\n\nwithout(Ks,M) when is_list(Ks), is_map(M) ->\n lists:foldl(fun maps:remove/2, M, Ks);\nwithout(Ks,M) ->\n erlang:error(error_type(M),[Ks,M]).\n\n-spec with(Ks, Map1) -> Map2 when\n Ks :: [K],\n Map1 :: #{K => V, _ => _},\n Map2 :: #{K => V}.\n\nwith(Ks,Map1) when is_list(Ks), is_map(Map1) ->\n maps:from_list(with_1(Ks, Map1));\nwith(Ks,M) ->\n erlang:error(error_type(M),[Ks,M]).\n\nwith_1([K|Ks], Map) ->\n case Map of\n #{K := V} -> [{K,V}|with_1(Ks, Map)];\n #{} -> with_1(Ks, Map)\n end;\nwith_1([], _Map) -> [].\n\nerror_type(M) when is_map(M) -> badarg;\nerror_type(V) -> {badmap, V}.\n\nerror_type_iter(M) when is_map(M); ?IS_ITERATOR(M) -> badarg;\nerror_type_iter(V) -> {badmap, V}.\n" }, { "path": "test_data/match.core", "content": "module 'match' ['hoo'/1,\n\t\t'module_info'/0,\n\t\t'module_info'/1,\n\t\t'woo'/0]\n attributes [%% Line 1\n\t\t'file' =\n\t\t %% Line 1\n\t\t [{[109|[97|[116|[99|[104|[46|[101|[114|[108]]]]]]]]],1}]]\n'woo'/0 =\n %% Line 4\n fun () ->\n\t%% Line 5\n\treceive\n\t %% Line 6\n\t <{'send',Woo,_0 = {_X_Something,_X_Else}}>\n\t when call 'erlang':'=:='\n\t\t (_0,\n\t\t Woo) ->\n\t %% Line 7\n\t Woo\n\t %% Line 8\n\t <{'woo',Hoo}> when 'true' ->\n\t %% Line 9\n\t Hoo\n\tafter 'infinity' ->\n\t 'true'\n'hoo'/1 =\n %% Line 12\n fun (_0) ->\n\t%% Line 13\n\treceive\n\t %% Line 14\n\t <{'send',_2}>\n\t when call 'erlang':'=:='\n\t\t (_2,\n\t\t _0) ->\n\t _0\n\tafter 'infinity' ->\n\t 'true'\n'module_info'/0 =\n fun () ->\n\tcall 'erlang':'get_module_info'\n\t ('match')\n'module_info'/1 =\n fun (_0) ->\n\tcall 'erlang':'get_module_info'\n\t ('match', _0)\nend" }, { "path": "test_data/match.erl", "content": "-module(match).\n-export([woo/0, hoo/1]).\n\nwoo() ->\n receive\n {send, Woo, {_Something, _Else} = Woo} ->\n Woo;\n {woo, Hoo} ->\n Hoo\n end.\n\nhoo(Hoo) ->\n receive\n {send, Hoo} ->\n Hoo\n end.\n\n" }, { "path": "test_data/match_SUITE.abstr", "content": "{attribute,1,file,{\"match_SUITE.erl\",1}}.\n{attribute,20,module,match_SUITE}.\n{attribute,22,export,\n [{all,0},\n {suite,0},\n {groups,0},\n {init_per_suite,1},\n {end_per_suite,1},\n {init_per_group,2},\n {end_per_group,2},\n {pmatch,1},\n {mixed,1},\n {aliases,1},\n {non_matching_aliases,1},\n {match_in_call,1},\n {untuplify,1},\n {shortcut_boolean,1},\n {letify_guard,1},\n {selectify,1},\n {deselectify,1},\n {underscore,1},\n {match_map,1},\n {map_vars_used,1},\n {coverage,1},\n {grab_bag,1},\n {literal_binary,1},\n {unary_op,1},\n {eq_types,1},\n {match_after_return,1},\n {match_right_tuple,1},\n {tuple_size_in_try,1},\n {match_boolean_list,1}]}.\n{attribute,1,file,\n {\"/home/hansihe/.asdf/installs/erlang/21.2.4/lib/common_test-1.16.1/include/ct.hrl\",\n 1}}.\n{attribute,32,file,{\"match_SUITE.erl\",32}}.\n{function,33,suite,0,\n [{clause,33,[],[],\n [{cons,33,\n {tuple,33,\n [{atom,33,ct_hooks},\n {cons,33,{atom,33,ts_install_cth},{nil,33}}]},\n {nil,33}}]}]}.\n{function,35,all,0,\n [{clause,35,[],[],\n [{cons,36,\n {tuple,36,[{atom,36,group},{atom,36,p}]},\n {nil,36}}]}]}.\n{function,38,groups,0,\n [{clause,38,[],[],\n [{cons,39,\n {tuple,39,\n [{atom,39,p},\n {cons,39,{atom,39,parallel},{nil,39}},\n {cons,40,\n {atom,40,pmatch},\n {cons,40,\n {atom,40,mixed},\n {cons,40,\n {atom,40,aliases},\n {cons,40,\n {atom,40,non_matching_aliases},\n {cons,41,\n {atom,41,match_in_call},\n {cons,41,\n {atom,41,untuplify},\n {cons,42,\n {atom,42,shortcut_boolean},\n {cons,42,\n {atom,42,letify_guard},\n {cons,42,\n {atom,42,selectify},\n {cons,42,\n {atom,42,deselectify},\n {cons,43,\n {atom,43,underscore},\n {cons,43,\n {atom,43,match_map},\n {cons,43,\n {atom,43,map_vars_used},\n {cons,43,\n {atom,43,coverage},\n {cons,44,\n {atom,44,grab_bag},\n {cons,44,\n {atom,44,literal_binary},\n {cons,44,\n {atom,44,unary_op},\n {cons,44,\n {atom,44,eq_types},\n {cons,45,\n {atom,45,match_after_return},\n {cons,45,\n {atom,45,match_right_tuple},\n {cons,46,\n {atom,46,tuple_size_in_try},\n {cons,46,\n {atom,46,match_boolean_list},\n {nil,46}}}}}}}}}}}}}}}}}}}}}}}]},\n {nil,46}}]}]}.\n{function,49,init_per_suite,1,\n [{clause,49,\n [{var,49,'Config'}],\n [],\n [{call,50,\n {remote,50,{atom,50,test_lib},{atom,50,recompile}},\n [{atom,50,match_SUITE}]},\n {var,51,'Config'}]}]}.\n{function,53,end_per_suite,1,\n [{clause,53,[{var,53,'_Config'}],[],[{atom,54,ok}]}]}.\n{function,56,init_per_group,2,\n [{clause,56,\n [{var,56,'_GroupName'},{var,56,'Config'}],\n [],\n [{var,57,'Config'}]}]}.\n{function,59,end_per_group,2,\n [{clause,59,\n [{var,59,'_GroupName'},{var,59,'Config'}],\n [],\n [{var,60,'Config'}]}]}.\n{function,63,pmatch,1,\n [{clause,63,\n [{var,63,'Config'}],\n [[{call,63,{atom,63,is_list},[{var,63,'Config'}]}]],\n [{match,64,\n {atom,64,ok},\n {call,64,{atom,64,doit},[{integer,64,1}]}},\n {match,65,\n {atom,65,ok},\n {call,65,{atom,65,doit},[{integer,65,2}]}},\n {match,66,\n {tuple,66,[{atom,66,error},{atom,66,baz}]},\n {call,66,{atom,66,doit},[{integer,66,3}]}},\n {match,67,\n {tuple,67,[{atom,67,error},{atom,67,foobar}]},\n {call,67,{atom,67,doit},[{integer,67,4}]}},\n {atom,68,ok}]}]}.\n{function,79,doit,1,\n [{clause,79,\n [{var,79,'X'}],\n [],\n [{'case',80,\n {'case',80,\n {var,80,'X'},\n [{clause,80,[{integer,80,1}],[],[{atom,80,foo}]},\n {clause,80,[{integer,80,2}],[],[{atom,80,bar}]},\n {clause,80,[{integer,80,3}],[],[{atom,80,baz}]},\n {clause,80,[{integer,80,4}],[],[{atom,80,foobar}]}]},\n [{clause,81,[{atom,81,foo}],[],[{atom,81,ok}]},\n {clause,82,[{atom,82,bar}],[],[{atom,82,ok}]},\n {clause,83,\n [{var,83,'Other'}],\n [],\n [{tuple,83,[{atom,83,error},{var,83,'Other'}]}]}]}]}]}.\n{function,86,mixed,1,\n [{clause,86,\n [{var,86,'Config'}],\n [[{call,86,{atom,86,is_list},[{var,86,'Config'}]}]],\n [{match,87,\n {atom,87,glufs},\n {call,87,{atom,87,mixit},[{integer,87,1}]}},\n {match,88,\n {atom,88,klafs},\n {call,88,{atom,88,mixit},[{integer,88,2}]}},\n {match,89,\n {atom,89,fnurra},\n {call,89,{atom,89,mixit},[{integer,89,3}]}},\n {match,90,{atom,90,usch},{call,90,{atom,90,mixit},[{integer,90,4}]}},\n {match,91,\n {tuple,91,[{atom,91,error},{atom,91,blurf}]},\n {call,91,{atom,91,mixit},[{integer,91,5}]}},\n {match,92,\n {tuple,92,[{atom,92,error},{integer,92,87987987}]},\n {call,92,{atom,92,mixit},[{integer,92,6}]}},\n {match,93,\n {tuple,93,\n [{atom,93,error},\n {tuple,93,[{atom,93,a},{atom,93,b},{atom,93,c}]}]},\n {call,93,{atom,93,mixit},[{integer,93,7}]}},\n {atom,94,ok}]}]}.\n{function,96,mixit,1,\n [{clause,96,\n [{var,96,'X'}],\n [],\n [{'case',97,\n {'case',97,\n {var,97,'X'},\n [{clause,98,[{integer,98,1}],[],[{atom,98,a}]},\n {clause,99,[{integer,99,2}],[],[{atom,99,b}]},\n {clause,100,[{integer,100,3}],[],[{integer,100,42}]},\n {clause,101,[{integer,101,4}],[],[{integer,101,77}]},\n {clause,102,\n [{op,102,'+',{integer,102,4},{integer,102,1}}],\n [],\n [{atom,102,blurf}]},\n {clause,103,\n [{op,103,'+',{integer,103,5},{integer,103,1}}],\n [],\n [{integer,103,87987987}]},\n {clause,104,\n [{op,104,'+',{integer,104,6},{integer,104,1}}],\n [],\n [{tuple,104,\n [{atom,104,a},{atom,104,b},{atom,104,c}]}]}]},\n [{clause,106,[{atom,106,a}],[],[{atom,106,glufs}]},\n {clause,107,[{atom,107,b}],[],[{atom,107,klafs}]},\n {clause,108,[{integer,108,42}],[],[{atom,108,fnurra}]},\n {clause,109,[{integer,109,77}],[],[{atom,109,usch}]},\n {clause,110,\n [{var,110,'Other'}],\n [],\n [{tuple,110,[{atom,110,error},{var,110,'Other'}]}]}]}]}]}.\n{function,113,aliases,1,\n [{clause,113,\n [{var,113,'Config'}],\n [[{call,113,{atom,113,is_list},[{var,113,'Config'}]}]],\n [{match,115,\n {atom,115,ok},\n {call,115,{atom,115,str_alias},[{string,115,\"abc\"}]}},\n {match,116,\n {atom,116,ok},\n {call,116,{atom,116,str_alias},[{string,116,\"def\"}]}},\n {match,117,\n {atom,117,ok},\n {call,117,{atom,117,str_alias},[{string,117,\"ghi\"}]}},\n {match,118,\n {atom,118,ok},\n {call,118,{atom,118,str_alias},[{string,118,\"klm\"}]}},\n {match,119,\n {atom,119,ok},\n {call,119,{atom,119,str_alias},[{string,119,\"qrs\"}]}},\n {match,120,\n {atom,120,ok},\n {call,120,{atom,120,str_alias},[{string,120,\"xy\"}]}},\n {match,121,\n {atom,121,ok},\n {call,121,{atom,121,str_alias},[{string,121,[]}]}},\n {match,122,\n {atom,122,ok},\n {call,122,{atom,122,str_alias},[{nil,122}]}},\n {match,123,\n {atom,123,error},\n {call,123,{atom,123,str_alias},[{string,123,\"blurf\"}]}},\n {match,126,\n {atom,126,ok},\n {call,126,{atom,126,char_alias},[{char,126,118}]}},\n {match,127,\n {atom,127,ok},\n {call,127,{atom,127,char_alias},[{integer,127,118}]}},\n {match,128,\n {atom,128,ok},\n {call,128,{atom,128,char_alias},[{char,128,119}]}},\n {match,129,\n {atom,129,ok},\n {call,129,{atom,129,char_alias},[{integer,129,119}]}},\n {match,130,\n {atom,130,ok},\n {call,130,{atom,130,char_alias},[{integer,130,42}]}},\n {match,131,\n {atom,131,ok},\n {call,131,{atom,131,char_alias},[{float,131,3.0}]}},\n {match,132,\n {atom,132,error},\n {call,132,{atom,132,char_alias},[{char,132,95}]}},\n {match,133,\n {atom,133,error},\n {call,133,{atom,133,char_alias},[{integer,133,0}]}},\n {match,135,\n {tuple,135,[{integer,135,42},{integer,135,42},{integer,135,42}]},\n {call,135,{atom,135,three},[{integer,135,42}]}},\n {match,137,\n {tuple,137,\n [{integer,137,1},\n {integer,137,42},\n {integer,137,99},\n {integer,137,1},\n {integer,137,42},\n {integer,137,99}]},\n {call,137,\n {atom,137,tuple_alias},\n [{tuple,137,\n [{integer,137,1},{integer,137,42},{integer,137,99}]}]}},\n {match,138,\n {tuple,138,\n [{op,138,'-',{integer,138,10}},\n {integer,138,20},\n {op,138,'-',{integer,138,10}},\n {integer,138,20},\n {op,138,'-',{integer,138,10}},\n {integer,138,20}]},\n {call,138,\n {atom,138,tuple_alias},\n [{tuple,138,\n [{op,138,'-',{integer,138,10}},{integer,138,20}]}]}},\n {match,139,\n {integer,139,6},\n {call,139,\n {atom,139,tup_lit_alias},\n [{tuple,139,\n [{integer,139,1},{integer,139,2},{integer,139,3}]}]}},\n {match,140,\n {integer,140,6},\n {call,140,\n {atom,140,tup_lit_alias_rev},\n [{tuple,140,\n [{integer,140,1},{integer,140,2},{integer,140,3}]}]}},\n {match,142,\n {tuple,142,\n [{integer,142,42},\n {integer,142,42},\n {integer,142,42},\n {integer,142,42}]},\n {call,142,{atom,142,multiple_aliases_1},[{integer,142,42}]}},\n {match,143,\n {tuple,143,[{integer,143,7},{integer,143,7},{integer,143,7}]},\n {call,143,{atom,143,multiple_aliases_2},[{integer,143,7}]}},\n {match,144,\n {tuple,144,\n [{tuple,144,[{atom,144,a},{atom,144,b}]},\n {tuple,144,[{atom,144,a},{atom,144,b}]},\n {tuple,144,[{atom,144,a},{atom,144,b}]}]},\n {call,144,\n {atom,144,multiple_aliases_3},\n [{tuple,144,[{atom,144,a},{atom,144,b}]}]}},\n {match,147,\n {tuple,147,[{atom,147,a},{atom,147,b}]},\n {call,147,\n {atom,147,list_alias1},\n [{cons,147,\n {atom,147,a},\n {cons,147,{atom,147,b},{nil,147}}}]}},\n {match,148,\n {tuple,148,[{atom,148,a},{atom,148,b}]},\n {call,148,\n {atom,148,list_alias2},\n [{cons,148,\n {atom,148,a},\n {cons,148,{atom,148,b},{nil,148}}}]}},\n {match,149,\n {tuple,149,[{atom,149,a},{atom,149,b}]},\n {call,149,\n {atom,149,list_alias3},\n [{cons,149,\n {atom,149,a},\n {cons,149,{atom,149,b},{nil,149}}}]}},\n {atom,151,ok}]}]}.\n{function,153,str_alias,1,\n [{clause,153,\n [{var,153,'V'}],\n [],\n [{match,154,\n {var,154,'Res'},\n {call,154,{atom,154,str_alias_1},[{var,154,'V'}]}},\n {match,155,\n {var,155,'Res'},\n {call,155,\n {atom,155,str_alias_2},\n [{var,155,'V'}]}}]}]}.\n{function,157,str_alias_1,1,\n [{clause,157,\n [{match,157,\n {cons,157,\n {char,157,97},\n {cons,157,{char,157,98},{cons,157,{char,157,99},{nil,157}}}},\n {match,157,\n {string,157,\"abc\"},\n {match,157,\n {op,157,'++',\n {string,157,\"a\"},\n {cons,157,\n {char,157,98},\n {cons,157,{char,157,99},{nil,157}}}},\n {cons,157,\n {integer,157,97},\n {cons,157,\n {integer,157,98},\n {cons,157,{integer,157,99},{nil,157}}}}}}}],\n [],\n [{atom,157,ok}]},\n {clause,158,\n [{match,158,\n {cons,158,{char,158,100},{string,158,\"ef\"}},\n {string,158,\"def\"}}],\n [],\n [{atom,158,ok}]},\n {clause,159,\n [{match,159,\n {cons,159,{char,159,103},{string,159,\"hi\"}},\n {match,159,\n {op,159,'++',{string,159,\"g\"},{string,159,\"hi\"}},\n {match,159,\n {op,159,'++',{string,159,\"gh\"},{string,159,\"i\"}},\n {op,159,'++',{string,159,\"ghi\"},{string,159,[]}}}}}],\n [],\n [{atom,159,ok}]},\n {clause,160,\n [{match,160,\n {op,160,'++',{string,160,\"k\"},{string,160,\"lm\"}},\n {cons,160,{char,160,107},{string,160,\"lm\"}}}],\n [],\n [{atom,160,ok}]},\n {clause,161,\n [{match,161,\n {cons,161,\n {integer,161,113},\n {cons,161,\n {integer,161,114},\n {cons,161,{integer,161,115},{nil,161}}}},\n {match,161,\n {string,161,\"qrs\"},\n {match,161,\n {cons,161,\n {char,161,113},\n {cons,161,\n {char,161,114},\n {cons,161,{char,161,115},{nil,161}}}},\n {op,161,'++',\n {string,161,\"q\"},\n {op,161,'++',{string,161,\"r\"},{string,161,\"s\"}}}}}}],\n [],\n [{atom,161,ok}]},\n {clause,162,\n [{match,162,\n {cons,162,{char,162,120},{cons,162,{char,162,121},{nil,162}}},\n {string,162,\"xy\"}}],\n [],\n [{atom,162,ok}]},\n {clause,163,[{match,163,{string,163,[]},{nil,163}}],[],[{atom,163,ok}]},\n {clause,164,[{var,164,'_'}],[],[{atom,164,error}]}]}.\n{function,168,str_alias_2,1,\n [{clause,168,\n [{match,168,\n {cons,168,\n {char,168,97},\n {cons,168,{char,168,98},{cons,168,{char,168,99},{nil,168}}}},\n {match,169,\n {string,169,\"abc\"},\n {match,171,\n {op,170,'++',\n {string,170,\"a\"},\n {cons,170,\n {char,170,98},\n {cons,170,{char,170,99},{nil,171}}}},\n {cons,172,\n {integer,172,97},\n {cons,172,\n {integer,172,98},\n {cons,172,{integer,172,99},{nil,173}}}}}}}],\n [],\n [{atom,173,ok}]},\n {clause,174,\n [{match,174,\n {cons,174,{char,174,100},{string,174,\"ef\"}},\n {string,175,\"def\"}}],\n [],\n [{atom,175,ok}]},\n {clause,176,\n [{match,176,\n {cons,176,{char,176,103},{string,176,\"hi\"}},\n {match,177,\n {op,177,'++',{string,177,\"g\"},{string,177,\"hi\"}},\n {match,178,\n {op,178,'++',{string,178,\"gh\"},{string,178,\"i\"}},\n {op,179,'++',{string,179,\"ghi\"},{string,179,[]}}}}}],\n [],\n [{atom,179,ok}]},\n {clause,180,\n [{match,180,\n {op,180,'++',{string,180,\"k\"},{string,180,\"lm\"}},\n {cons,181,{char,181,107},{string,181,\"lm\"}}}],\n [],\n [{atom,182,ok}]},\n {clause,183,\n [{match,183,\n {cons,183,\n {integer,183,113},\n {cons,183,\n {integer,183,114},\n {cons,183,{integer,183,115},{nil,183}}}},\n {match,184,\n {string,184,\"qrs\"},\n {match,185,\n {cons,184,\n {char,184,113},\n {cons,184,\n {char,184,114},\n {cons,184,{char,184,115},{nil,185}}}},\n {op,186,'++',\n {string,186,\"q\"},\n {op,186,'++',{string,186,\"r\"},{string,186,\"s\"}}}}}}],\n [],\n [{atom,186,ok}]},\n {clause,187,\n [{match,187,\n {cons,187,{char,187,120},{cons,187,{char,187,121},{nil,187}}},\n {string,188,\"xy\"}}],\n [],\n [{atom,188,ok}]},\n {clause,189,[{match,189,{string,189,[]},{nil,190}}],[],[{atom,190,ok}]},\n {clause,191,[{var,191,'_'}],[],[{atom,191,error}]}]}.\n{function,193,char_alias,1,\n [{clause,193,\n [{var,193,'V'}],\n [],\n [{match,194,\n {var,194,'Res'},\n {call,194,{atom,194,char_alias_1},[{var,194,'V'}]}},\n {match,195,\n {var,195,'Res'},\n {call,195,\n {atom,195,char_alias_2},\n [{var,195,'V'}]}}]}]}.\n{function,197,char_alias_1,1,\n [{clause,197,\n [{match,197,{integer,197,118},{char,197,118}}],\n [],\n [{atom,197,ok}]},\n {clause,198,\n [{match,198,{char,198,119},{integer,198,119}}],\n [],\n [{atom,198,ok}]},\n {clause,199,\n [{match,199,{integer,199,42},{integer,199,42}}],\n [],\n [{atom,199,ok}]},\n {clause,200,\n [{match,200,{float,200,3.0},{float,200,3.0}}],\n [],\n [{atom,200,ok}]},\n {clause,201,[{var,201,'_'}],[],[{atom,201,error}]}]}.\n{function,203,char_alias_2,1,\n [{clause,203,\n [{match,203,{integer,203,118},{char,204,118}}],\n [],\n [{atom,204,ok}]},\n {clause,205,\n [{match,205,{char,205,119},{integer,206,119}}],\n [],\n [{atom,206,ok}]},\n {clause,207,\n [{match,207,{integer,207,42},{integer,208,42}}],\n [],\n [{atom,208,ok}]},\n {clause,209,\n [{match,209,{float,209,3.0},{float,210,3.0}}],\n [],\n [{atom,210,ok}]},\n {clause,211,[{var,211,'_'}],[],[{atom,211,error}]}]}.\n{function,213,three,1,\n [{clause,213,\n [{var,213,'V'}],\n [],\n [{match,214,\n {var,214,'Res'},\n {call,214,{atom,214,three_1},[{var,214,'V'}]}},\n {match,215,\n {var,215,'Res'},\n {call,215,{atom,215,three_2},[{var,215,'V'}]}}]}]}.\n{function,217,three_1,1,\n [{clause,217,\n [{match,217,\n {var,217,'A'},\n {match,217,{var,217,'B'},{var,217,'C'}}}],\n [],\n [{tuple,218,\n [{var,218,'A'},{var,218,'B'},{var,218,'C'}]}]}]}.\n{function,220,three_2,1,\n [{clause,220,\n [{match,220,\n {var,220,'A'},\n {match,221,{var,221,'B'},{var,222,'C'}}}],\n [],\n [{tuple,223,\n [{var,223,'A'},{var,223,'B'},{var,223,'C'}]}]}]}.\n{function,225,tuple_alias,1,\n [{clause,225,\n [{match,225,\n {tuple,225,\n [{var,225,'A'},{var,225,'B'},{var,225,'C'}]},\n {tuple,225,\n [{var,225,'X'},\n {var,225,'Y'},\n {var,225,'Z'}]}}],\n [],\n [{tuple,226,\n [{var,226,'A'},\n {var,226,'B'},\n {var,226,'C'},\n {var,226,'X'},\n {var,226,'Y'},\n {var,226,'Z'}]}]},\n {clause,227,\n [{match,227,\n {tuple,227,[{var,227,'A'},{var,227,'B'}]},\n {match,227,\n {tuple,227,[{var,227,'C'},{var,227,'D'}]},\n {tuple,227,[{var,227,'E'},{var,227,'F'}]}}}],\n [],\n [{tuple,228,\n [{var,228,'A'},\n {var,228,'B'},\n {var,228,'C'},\n {var,228,'D'},\n {var,228,'E'},\n {var,228,'F'}]}]}]}.\n{function,230,tup_lit_alias,1,\n [{clause,230,\n [{match,230,\n {tuple,230,\n [{var,230,'A'},{var,230,'B'},{var,230,'C'}]},\n {tuple,230,\n [{integer,230,1},\n {integer,230,2},\n {integer,230,3}]}}],\n [],\n [{op,231,'+',\n {op,231,'+',{var,231,'A'},{var,231,'B'}},\n {var,231,'C'}}]}]}.\n{function,233,tup_lit_alias_rev,1,\n [{clause,233,\n [{match,233,\n {tuple,233,\n [{integer,233,1},\n {integer,233,2},\n {integer,233,3}]},\n {tuple,233,\n [{var,233,'A'},\n {var,233,'B'},\n {var,233,'C'}]}}],\n [],\n [{op,234,'+',\n {op,234,'+',{var,234,'A'},{var,234,'B'}},\n {var,234,'C'}}]}]}.\n{function,236,multiple_aliases_1,1,\n [{clause,236,\n [{match,236,\n {match,236,{var,236,'A'},{var,236,'B'}},\n {match,236,{var,236,'C'},{var,236,'D'}}}],\n [],\n [{tuple,237,\n [{var,237,'A'},\n {var,237,'B'},\n {var,237,'C'},\n {var,237,'D'}]}]}]}.\n{function,239,multiple_aliases_2,1,\n [{clause,239,\n [{match,239,\n {match,239,{var,239,'A'},{var,239,'B'}},\n {match,239,{var,239,'A'},{var,239,'C'}}}],\n [],\n [{tuple,240,\n [{var,240,'A'},{var,240,'B'},{var,240,'C'}]}]}]}.\n{function,242,multiple_aliases_3,1,\n [{clause,242,\n [{match,242,\n {match,242,\n {var,242,'A'},\n {match,242,\n {tuple,242,[{var,242,'_'},{var,242,'_'}]},\n {var,242,'B'}}},\n {match,242,\n {tuple,242,[{var,242,'_'},{var,242,'_'}]},\n {var,242,'C'}}}],\n [],\n [{tuple,243,[{var,243,'A'},{var,243,'B'},{var,243,'C'}]}]}]}.\n{function,245,list_alias1,1,\n [{clause,245,\n [{match,245,\n {cons,245,\n {atom,245,a},\n {cons,245,{atom,245,b},{nil,245}}},\n {cons,245,\n {var,245,'X'},\n {cons,245,{var,245,'Y'},{nil,245}}}}],\n [],\n [{tuple,246,[{var,246,'X'},{var,246,'Y'}]}]}]}.\n{function,248,list_alias2,1,\n [{clause,248,\n [{match,248,\n {cons,248,\n {var,248,'X'},\n {cons,248,{var,248,'Y'},{nil,248}}},\n {cons,248,\n {atom,248,a},\n {cons,248,{atom,248,b},{nil,248}}}}],\n [],\n [{tuple,249,[{var,249,'X'},{var,249,'Y'}]}]}]}.\n{function,251,list_alias3,1,\n [{clause,251,\n [{match,251,\n {cons,251,\n {var,251,'X'},\n {cons,251,{atom,251,b},{nil,251}}},\n {cons,251,\n {atom,251,a},\n {cons,251,{var,251,'Y'},{nil,251}}}}],\n [],\n [{tuple,252,[{var,252,'X'},{var,252,'Y'}]}]}]}.\n{function,254,non_matching_aliases,1,\n [{clause,254,\n [{var,254,'_Config'}],\n [],\n [{match,255,\n {atom,255,none},\n {call,255,\n {atom,255,mixed_aliases},\n [{bin,255,\n [{bin_element,255,\n {integer,255,42},\n default,default}]}]}},\n {match,256,\n {atom,256,none},\n {call,256,\n {atom,256,mixed_aliases},\n [{cons,256,{atom,256,b},{nil,256}}]}},\n {match,257,\n {atom,257,none},\n {call,257,\n {atom,257,mixed_aliases},\n [{cons,257,{atom,257,d},{nil,257}}]}},\n {match,258,\n {atom,258,none},\n {call,258,\n {atom,258,mixed_aliases},\n [{tuple,258,[{atom,258,a},{integer,258,42}]}]}},\n {match,259,\n {atom,259,none},\n {call,259,{atom,259,mixed_aliases},[{integer,259,42}]}},\n {match,260,\n {atom,260,none},\n {call,260,\n {atom,260,mixed_aliases},\n [{bin,260,\n [{bin_element,260,\n {integer,260,6789},\n {integer,260,16},\n default}]}]}},\n {match,261,\n {atom,261,none},\n {call,261,\n {atom,261,mixed_aliases},\n [{map,261,\n [{map_field_assoc,261,\n {atom,261,key},\n {atom,261,value}}]}]}},\n {match,263,\n {tuple,263,\n [{atom,263,'EXIT'},\n {tuple,263,\n [{tuple,263,[{atom,263,badmatch},{integer,263,42}]},\n {var,263,'_'}]}]},\n {'catch',263,\n {call,263,{atom,263,nomatch_alias},[{integer,263,42}]}}},\n {match,264,\n {tuple,264,\n [{atom,264,'EXIT'},\n {tuple,264,\n [{tuple,264,[{atom,264,badmatch},{atom,264,job}]},\n {var,264,'_'}]}]},\n {'catch',264,{call,264,{atom,264,entirely},[]}}},\n {match,265,\n {tuple,265,\n [{atom,265,'EXIT'},\n {tuple,265,\n [{tuple,265,\n [{atom,265,badmatch},{atom,265,associates}]},\n {var,265,'_'}]}]},\n {'catch',265,{call,265,{atom,265,printer},[]}}},\n {match,266,\n {tuple,266,\n [{atom,266,'EXIT'},\n {tuple,266,\n [{tuple,266,[{atom,266,badmatch},{atom,266,borogoves}]},\n {var,266,'_'}]}]},\n {'catch',266,{call,266,{atom,266,tench},[]}}},\n {call,268,{atom,268,put},[{atom,268,perch},{integer,268,0}]},\n {match,269,\n {tuple,269,\n [{atom,269,'EXIT'},\n {tuple,269,\n [{tuple,269,\n [{atom,269,badmatch},\n {tuple,269,[{atom,269,spine},{integer,269,42}]}]},\n {var,269,'_'}]}]},\n {'catch',269,{call,269,{atom,269,perch},[{integer,269,42}]}}},\n {match,270,\n {integer,270,1},\n {call,270,{atom,270,erase},[{atom,270,perch}]}},\n {call,272,{atom,272,put},[{atom,272,salmon},{integer,272,0}]},\n {match,273,\n {tuple,273,\n [{atom,273,'EXIT'},\n {tuple,273,\n [{tuple,273,[{atom,273,badmatch},{atom,273,mimsy}]},\n {var,273,'_'}]}]},\n {'catch',273,{call,273,{atom,273,salmon},[]}}},\n {match,274,\n {integer,274,1},\n {call,274,{atom,274,erase},[{atom,274,salmon}]}},\n {call,276,{atom,276,put},[{atom,276,shark},{integer,276,0}]},\n {match,277,\n {tuple,277,\n [{atom,277,'EXIT'},\n {tuple,277,\n [{tuple,277,[{atom,277,badmatch},{var,277,'_'}]},\n {var,277,'_'}]}]},\n {'catch',277,{call,277,{atom,277,shark},[]}}},\n {match,278,\n {integer,278,1},\n {call,278,{atom,278,erase},[{atom,278,shark}]}},\n {match,280,\n {tuple,280,\n [{atom,280,'EXIT'},\n {tuple,280,\n [{tuple,280,[{atom,280,badmatch},{var,280,'_'}]},\n {var,280,'_'}]}]},\n {'catch',280,{call,280,{atom,280,radio},[{atom,280,research}]}}},\n {atom,281,ok}]}]}.\n{function,283,mixed_aliases,1,\n [{clause,283,\n [{match,283,\n {bin,283,\n [{bin_element,283,{var,283,'X'},{integer,283,8},default}]},\n {atom,283,x}}],\n [],\n [{tuple,283,[{atom,283,a},{var,283,'X'}]}]},\n {clause,284,\n [{match,284,\n {cons,284,{atom,284,b},{nil,284}},\n {bin,284,\n [{bin_element,284,{var,284,'X'},{integer,284,8},default}]}}],\n [],\n [{tuple,284,[{atom,284,b},{var,284,'X'}]}]},\n {clause,285,\n [{match,285,\n {bin,285,\n [{bin_element,285,{var,285,'X'},{integer,285,8},default}]},\n {tuple,285,[{atom,285,a},{var,285,'X'}]}}],\n [],\n [{tuple,285,[{atom,285,c},{var,285,'X'}]}]},\n {clause,286,\n [{match,286,\n {cons,286,{var,286,'X'},{nil,286}},\n {bin,286,\n [{bin_element,286,{var,286,'X'},{integer,286,8},default}]}}],\n [],\n [{tuple,286,[{atom,286,d},{var,286,'X'}]}]},\n {clause,287,\n [{match,287,\n {bin,287,\n [{bin_element,287,{var,287,'X'},{integer,287,16},default}]},\n {var,287,'X'}}],\n [],\n [{tuple,287,[{atom,287,e},{var,287,'X'}]}]},\n {clause,288,\n [{match,288,\n {var,288,'X'},\n {bin,288,\n [{bin_element,288,\n {var,288,'X'},\n {integer,288,16},\n default}]}}],\n [],\n [{tuple,288,[{atom,288,f},{var,288,'X'}]}]},\n {clause,289,\n [{match,289,\n {bin,289,\n [{bin_element,289,{var,289,'X'},{integer,289,16},default},\n {bin_element,289,{var,289,'_'},default,[binary]}]},\n {var,289,'X'}}],\n [],\n [{tuple,289,[{atom,289,g},{var,289,'X'}]}]},\n {clause,290,\n [{match,290,\n {var,290,'X'},\n {bin,290,\n [{bin_element,290,{var,290,'X'},{integer,290,16},default},\n {bin_element,290,{var,290,'_'},default,[binary]}]}}],\n [],\n [{tuple,290,[{atom,290,h},{var,290,'X'}]}]},\n {clause,291,\n [{match,291,\n {var,291,'X'},\n {map,291,[{map_field_exact,291,{atom,291,key},{var,291,'X'}}]}}],\n [],\n [{tuple,291,[{atom,291,i},{var,291,'X'}]}]},\n {clause,292,\n [{match,292,\n {map,292,[{map_field_exact,292,{atom,292,key},{var,292,'X'}}]},\n {var,292,'X'}}],\n [],\n [{tuple,292,[{atom,292,j},{var,292,'X'}]}]},\n {clause,293,\n [{match,293,\n {cons,293,{var,293,'X'},{nil,293}},\n {map,293,[{map_field_exact,293,{atom,293,key},{var,293,'X'}}]}}],\n [],\n [{tuple,293,[{atom,293,k},{var,293,'X'}]}]},\n {clause,294,\n [{match,294,\n {map,294,[{map_field_exact,294,{atom,294,key},{var,294,'X'}}]},\n {cons,294,{var,294,'X'},{nil,294}}}],\n [],\n [{tuple,294,[{atom,294,l},{var,294,'X'}]}]},\n {clause,295,\n [{match,295,\n {tuple,295,[{atom,295,a},{var,295,'X'}]},\n {map,295,[{map_field_exact,295,{atom,295,key},{var,295,'X'}}]}}],\n [],\n [{tuple,295,[{atom,295,m},{var,295,'X'}]}]},\n {clause,296,\n [{match,296,\n {map,296,[{map_field_exact,296,{atom,296,key},{var,296,'X'}}]},\n {tuple,296,[{atom,296,a},{var,296,'X'}]}}],\n [],\n [{tuple,296,[{atom,296,n},{var,296,'X'}]}]},\n {clause,297,[{var,297,'_'}],[],[{atom,297,none}]}]}.\n{function,299,nomatch_alias,1,\n [{clause,299,\n [{var,299,'I'}],\n [],\n [{match,300,\n {tuple,300,\n [{match,300,\n {atom,300,ok},\n {tuple,300,[{var,300,'A'},{var,300,'B'}]}}]},\n {call,300,{atom,300,id},[{var,300,'I'}]}},\n {tuple,301,[{var,301,'A'},{var,301,'B'}]}]}]}.\n{function,303,entirely,0,\n [{clause,303,[],[],\n [{call,304,\n {integer,304,0},\n [{match,304,\n {match,304,\n {match,304,{var,304,'Voice'},{atom,304,true}},\n {atom,304,cool}},\n {atom,304,job}}]},\n {lc,305,\n {'receive',305,\n [{clause,305,[{var,305,'_'}],[],[{var,305,'Voice'}]}]},\n [{generate,305,{atom,305,banking},{atom,305,printer}}]}]}]}.\n{function,307,printer,0,\n [{clause,307,[],[],\n [{tuple,308,\n [{match,308,\n {cons,308,{var,308,'Indoor'},{nil,308}},\n {match,308,{nil,308},{atom,308,associates}}}]},\n {lc,309,\n {atom,309,ireland},\n [{generate,309,{var,309,'Indoor'},{var,309,'Indoor'}}]}]}]}.\n{function,311,tench,0,\n [{clause,311,[],[],\n [{match,312,\n {var,312,'E'},\n {block,312,\n [{match,313,\n {cons,313,{var,313,'A'},{nil,313}},\n {match,313,{nil,313},{atom,313,borogoves}}},\n {op,314,'+',{var,314,'A'},{integer,314,1}}]}},\n {op,316,'+',\n {var,316,'E'},\n {op,316,'*',{integer,316,7},{var,316,'A'}}}]}]}.\n{function,318,perch,1,\n [{clause,318,\n [{var,318,'X'}],\n [],\n [{block,319,\n [{call,320,\n {atom,320,put},\n [{atom,320,perch},\n {op,320,'+',\n {call,320,{atom,320,get},[{atom,320,perch}]},\n {integer,320,1}}]},\n {match,321,\n {cons,321,{var,321,'A'},{nil,321}},\n {match,321,\n {nil,321},\n {tuple,321,[{atom,321,spine},{var,321,'X'}]}}}]}]}]}.\n{function,324,salmon,0,\n [{clause,324,[],[],\n [{tuple,325,\n [{call,325,\n {atom,325,put},\n [{atom,325,salmon},\n {op,325,'+',\n {call,325,{atom,325,get},[{atom,325,salmon}]},\n {integer,325,1}}]},\n {match,325,\n {map,325,\n [{map_field_exact,325,\n {atom,325,key},\n {match,325,\n {cons,325,{var,325,'A'},{nil,325}},\n {nil,325}}}]},\n {atom,325,mimsy}},\n {call,325,{atom,325,exit},[{atom,325,fail}]}]},\n {op,326,'+',{var,326,'A'},{integer,326,10}}]}]}.\n{function,328,shark,0,\n [{clause,328,[],[],\n [{match,329,\n {match,329,{atom,329,hello},{atom,329,there}},\n {'catch',329,\n {call,329,\n {atom,329,shark},\n [{call,329,\n {atom,329,put},\n [{atom,329,shark},\n {op,329,'+',\n {call,329,{atom,329,get},[{atom,329,shark}]},\n {integer,329,1}}]},\n {match,329,{atom,329,a},{atom,329,b}}]}}}]}]}.\n{function,331,shark,2,\n [{clause,331,[{var,331,'_'},{var,331,'_'}],[],[{atom,332,ok}]}]}.\n{function,334,radio,1,\n [{clause,334,\n [{atom,334,research}],\n [],\n [{match,335,\n {match,335,{atom,335,connection},{atom,335,proof}},\n {'catch',336,\n {call,336,\n {remote,336,{atom,336,erlang},{atom,336,trace_pattern}},\n [{'catch',336,\n {op,336,'+',\n {atom,336,mechanisms},\n {atom,336,assist}}},\n {match,337,\n {atom,337,summary},\n {atom,337,mechanisms}}]}}}]}]}.\n{function,341,match_in_call,1,\n [{clause,341,\n [{var,341,'Config'}],\n [[{call,341,{atom,341,is_list},[{var,341,'Config'}]}]],\n [{call,342,{atom,342,mac_a},[{integer,342,0}]},\n {call,343,{atom,343,mac_b},[{integer,343,1}]},\n {call,344,{atom,344,mac_c},[{integer,344,42}]},\n {call,345,{atom,345,mac_d},[{integer,345,42}]},\n {call,346,\n {atom,346,mac_e},\n [{tuple,346,[{atom,346,gurka},{integer,346,42}]}]},\n {match,348,\n {cons,348,\n {tuple,348,[{integer,348,2},{integer,348,2}]},\n {cons,348,\n {tuple,348,[{integer,348,2},{integer,348,2}]},\n {nil,348}}},\n {call,348,\n {atom,348,mac_lc},\n [{cons,348,\n {tuple,348,[{integer,348,2},{atom,348,any}]},\n {cons,348,\n {tuple,348,[{integer,348,2},{integer,348,2}]},\n {nil,348}}}]}},\n {match,349,\n {tuple,349,[{atom,349,'EXIT'},{var,349,'_'}]},\n {'catch',349,\n {call,349,\n {atom,349,mac_lc},\n [{cons,349,\n {tuple,349,[{integer,349,1},{integer,349,1}]},\n {nil,349}}]}}},\n {atom,351,ok}]}]}.\n{function,353,mac_a,1,\n [{clause,353,\n [{var,353,'X'}],\n [],\n [{call,354,\n {atom,354,id},\n [{match,354,\n {var,354,'_Gurka'},\n {tuple,354,[{atom,354,gurka},{var,354,'X'}]}}]},\n {atom,355,ok}]}]}.\n{function,357,mac_b,1,\n [{clause,357,\n [{var,357,'X'}],\n [],\n [{call,358,\n {atom,358,id},\n [{match,358,\n {var,358,'Gurka'},\n {tuple,358,[{atom,358,gurka},{var,358,'X'}]}}]},\n {call,359,{atom,359,gurka},[{var,359,'Gurka'},{var,359,'X'}]},\n {atom,360,ok}]}]}.\n{function,362,mac_c,1,\n [{clause,362,\n [{var,362,'X'}],\n [],\n [{call,363,\n {atom,363,id},\n [{match,363,\n {var,363,'Gurka'},\n {match,363,\n {var,363,'Yxa'},\n {tuple,363,[{atom,363,gurka},{var,363,'X'}]}}}]},\n {call,364,\n {atom,364,id},\n [{tuple,364,[{var,364,'Gurka'},{var,364,'Yxa'}]}]},\n {atom,365,ok}]}]}.\n{function,367,mac_d,1,\n [{clause,367,\n [{var,367,'X'}],\n [],\n [{call,368,\n {atom,368,id},\n [{match,368,\n {tuple,368,[{atom,368,gurka},{integer,368,42}]},\n {tuple,368,[{atom,368,gurka},{var,368,'X'}]}}]},\n {atom,369,ok}]}]}.\n{function,371,mac_e,1,\n [{clause,371,\n [{var,371,'X'}],\n [],\n [{call,372,\n {atom,372,id},\n [{match,372,\n {tuple,372,[{atom,372,gurka},{integer,372,42}]},\n {var,372,'X'}}]},\n {atom,373,ok}]}]}.\n{function,375,mac_lc,1,\n [{clause,375,\n [{var,375,'E'}],\n [],\n [{match,376,\n {var,376,'Res'},\n {call,376,{atom,376,mac_lc1},[{var,376,'E'}]}},\n {match,377,\n {var,377,'Res'},\n {call,377,{atom,377,mac_lc2},[{var,377,'E'}]}}]}]}.\n{function,379,mac_lc1,1,\n [{clause,379,\n [{var,379,'E'}],\n [],\n [{lc,380,\n {tuple,380,[{var,380,'X'},{var,380,'Y'}]},\n [{generate,381,\n {tuple,381,[{var,381,'X'},{var,381,'_'}]},\n {var,381,'E'}},\n {op,382,'=:=',\n {match,382,{var,382,'Y'},{var,382,'X'}},\n {match,382,\n {var,382,'Y'},\n {op,382,'+',{integer,382,1},{integer,382,1}}}}]}]}]}.\n{function,384,mac_lc2,1,\n [{clause,384,\n [{var,384,'E'}],\n [],\n [{lc,385,\n {tuple,385,[{var,385,'X'},{var,385,'Y'}]},\n [{generate,386,\n {tuple,386,[{var,386,'X'},{var,386,'_'}]},\n {var,386,'E'}},\n {op,387,'=:=',\n {match,387,{var,387,'Y'},{var,387,'X'}},\n {match,387,{var,387,'Y'},{integer,387,2}}}]}]}]}.\n{function,389,gurka,2,\n [{clause,389,\n [{tuple,389,[{atom,389,gurka},{var,389,'X'}]},\n {var,389,'X'}],\n [],\n [{atom,389,ok}]}]}.\n{function,392,untuplify,1,\n [{clause,392,\n [{var,392,'Config'}],\n [[{call,392,{atom,392,is_list},[{var,392,'Config'}]}]],\n [{match,394,\n {tuple,394,\n [{integer,394,1},\n {integer,394,2},\n {integer,394,3},\n {integer,394,4},\n {atom,394,alias},\n {tuple,394,\n [{cons,394,\n {integer,394,1},\n {cons,394,{integer,394,2},{nil,394}}},\n {tuple,394,[{integer,394,3},{integer,394,4}]},\n {atom,394,alias}]}]},\n {call,394,\n {atom,394,untuplify_1},\n [{cons,394,\n {integer,394,1},\n {cons,394,{integer,394,2},{nil,394}}},\n {tuple,394,[{integer,394,3},{integer,394,4}]},\n {atom,394,alias}]}},\n {match,395,\n {atom,395,error},\n {call,395,\n {atom,395,untuplify_1},\n [{cons,395,\n {integer,395,1},\n {cons,395,{integer,395,2},{nil,395}}},\n {tuple,395,[{integer,395,3},{integer,395,4}]},\n {integer,395,42}]}},\n {match,400,\n {cons,400,\n {integer,400,33},\n {cons,400,\n {op,400,'-',{integer,400,1}},\n {cons,400,\n {op,400,'-',{integer,400,33}},\n {cons,400,{integer,400,1},{nil,400}}}}},\n {call,400,\n {atom,400,untuplify_2},\n [{integer,400,32},{integer,400,65}]}},\n {match,401,\n {tuple,401,\n [{integer,401,33},\n {integer,401,1},\n {op,401,'-',{integer,401,33}},\n {op,401,'-',{integer,401,1}}]},\n {call,401,\n {atom,401,untuplify_2},\n [{integer,401,65},{integer,401,32}]}},\n {atom,403,ok}]}]}.\n{function,405,untuplify_1,3,\n [{clause,405,\n [{var,405,'A'},{var,405,'B'},{var,405,'C'}],\n [],\n [{'case',406,\n {tuple,406,[{var,406,'A'},{var,406,'B'},{var,406,'C'}]},\n [{clause,407,\n [{match,407,\n {tuple,407,\n [{cons,407,\n {var,407,'X'},\n {cons,407,{var,407,'Y'},{nil,407}}},\n {tuple,407,[{var,407,'Z'},{var,407,'W'}]},\n {match,407,{atom,407,alias},{var,407,'Alias'}}]},\n {var,407,'Top'}}],\n [],\n [{tuple,408,\n [{var,408,'X'},\n {var,408,'Y'},\n {var,408,'Z'},\n {var,408,'W'},\n {var,408,'Alias'},\n {var,408,'Top'}]}]},\n {clause,409,\n [{match,409,\n {cons,409,\n {var,409,'_'},\n {cons,409,{var,409,'_'},{nil,409}}},\n {var,409,'CantMatch'}}],\n [],\n [{var,410,'CantMatch'}]},\n {clause,411,[{var,411,'_'}],[],[{atom,412,error}]}]}]}]}.\n{function,415,untuplify_2,2,\n [{clause,415,\n [{var,415,'V1'},{var,415,'V2'}],\n [],\n [{match,416,\n {tuple,416,\n [{var,416,'D1'},\n {var,416,'D2'},\n {var,416,'D3'},\n {var,416,'D4'}]},\n {'if',417,\n [{clause,417,[],\n [[{op,417,'>',{var,417,'V1'},{var,417,'V2'}}]],\n [{tuple,419,\n [{op,419,'-',{var,419,'V1'},{var,419,'V2'}},\n {integer,419,1},\n {op,419,'-',{var,419,'V2'},{var,419,'V1'}},\n {op,419,'-',{integer,419,1}}]}]},\n {clause,420,[],\n [[{atom,420,true}]],\n [{tuple,421,\n [{op,421,'-',{var,421,'V2'},{var,421,'V1'}},\n {op,421,'-',{integer,421,1}},\n {op,421,'-',{var,421,'V1'},{var,421,'V2'}},\n {integer,421,1}]}]}]}},\n {'if',423,\n [{clause,424,[],\n [[{op,424,'>',{var,424,'D2'},{var,424,'D4'}}]],\n [{tuple,425,\n [{var,425,'D1'},\n {var,425,'D2'},\n {var,425,'D3'},\n {var,425,'D4'}]}]},\n {clause,426,[],\n [[{atom,426,true}]],\n [{cons,427,\n {var,427,'D1'},\n {cons,427,\n {var,427,'D2'},\n {cons,427,\n {var,427,'D3'},\n {cons,427,{var,427,'D4'},{nil,427}}}}}]}]}]}]}.\n{function,431,shortcut_boolean,1,\n [{clause,431,\n [{var,431,'Config'}],\n [[{call,431,{atom,431,is_list},[{var,431,'Config'}]}]],\n [{match,432,\n {atom,432,false},\n {call,432,\n {atom,432,shortcut_boolean_1},\n [{cons,432,{integer,432,0},{nil,432}}]}},\n {match,433,\n {atom,433,true},\n {call,433,\n {atom,433,shortcut_boolean_1},\n [{tuple,433,[{integer,433,42}]}]}},\n {match,434,\n {atom,434,maybe},\n {call,434,\n {atom,434,shortcut_boolean_1},\n [{call,434,{atom,434,self},[]}]}},\n {match,435,\n {tuple,435,[{atom,435,'EXIT'},{var,435,'_'}]},\n {'catch',435,\n {call,435,\n {atom,435,shortcut_boolean_1},\n [{cons,435,\n {atom,435,a},\n {cons,435,{atom,435,b},{nil,435}}}]}}},\n {match,436,\n {tuple,436,[{atom,436,'EXIT'},{var,436,'_'}]},\n {'catch',436,\n {call,436,\n {atom,436,shortcut_boolean_1},\n [{tuple,436,[{atom,436,a},{atom,436,b}]}]}}},\n {atom,437,ok}]}]}.\n{function,439,shortcut_boolean_1,1,\n [{clause,439,\n [{var,439,'X'}],\n [],\n [{match,440,\n {var,440,'Outer'},\n {'case',440,\n {op,440,'not',{call,440,{atom,440,is_pid},[{var,440,'X'}]}},\n [{clause,441,\n [{atom,441,true}],\n [],\n [{match,442,\n {var,442,'V'},\n {'case',442,\n {var,442,'X'},\n [{clause,443,\n [{cons,443,{var,443,'_'},{nil,443}}],\n [],\n [{atom,443,true}]},\n {clause,444,\n [{tuple,444,[{var,444,'_'}]}],\n [],\n [{atom,444,false}]}]}},\n {op,446,'not',{var,446,'V'}}]},\n {clause,447,[{atom,447,false}],[],[{atom,448,maybe}]}]}},\n {call,450,{atom,450,id},[{var,450,'Outer'}]}]}]}.\n{function,454,letify_guard,1,\n [{clause,454,\n [{var,454,'Config'}],\n [[{call,454,{atom,454,is_list},[{var,454,'Config'}]}]],\n [{match,455,\n {tuple,455,\n [{op,455,'-',{integer,455,15}},\n {atom,455,a}]},\n {call,455,\n {atom,455,letify_guard},\n [{op,455,'-',{integer,455,15}},\n {atom,455,a}]}},\n {match,456,\n {integer,456,5},\n {call,456,\n {atom,456,letify_guard},\n [{integer,456,2},{integer,456,3}]}},\n {atom,457,ok}]}]}.\n{function,459,letify_guard,2,\n [{clause,459,\n [{var,459,'A'},{var,459,'B'}],\n [],\n [{'case',460,\n {tuple,460,[{var,460,'A'},{var,460,'B'}]},\n [{clause,462,\n [{var,462,'Z'}],\n [[{op,462,'=:=',\n {call,462,{atom,462,tuple_size},[{var,462,'Z'}]},\n {integer,462,2}},\n {op,462,'<',\n {call,462,\n {atom,462,element},\n [{integer,462,1},{var,462,'Z'}]},\n {integer,462,0}}]],\n [{var,464,'Z'}]},\n {clause,465,\n [{tuple,465,[{var,465,'X'},{var,465,'Y'}]}],\n [],\n [{op,465,'+',{var,465,'X'},{var,465,'Y'}}]}]}]}]}.\n{function,471,selectify,1,\n [{clause,471,\n [{var,471,'Config'}],\n [[{call,471,{atom,471,is_list},[{var,471,'Config'}]}]],\n [{match,472,\n {atom,472,integer},\n {call,472,\n {atom,472,sel_different_types},\n [{tuple,472,[{atom,472,r},{integer,472,42}]}]}},\n {match,473,\n {atom,473,atom},\n {call,473,\n {atom,473,sel_different_types},\n [{tuple,473,[{atom,473,r},{atom,473,forty_two}]}]}},\n {match,474,\n {atom,474,float},\n {call,474,\n {atom,474,sel_different_types},\n [{tuple,474,[{atom,474,r},{float,474,100.0}]}]}},\n {match,475,\n {atom,475,none},\n {call,475,\n {atom,475,sel_different_types},\n [{tuple,475,[{atom,475,r},{integer,475,18}]}]}},\n {match,476,\n {tuple,476,[{atom,476,'EXIT'},{var,476,'_'}]},\n {'catch',476,\n {call,476,\n {atom,476,sel_different_types},\n [{cons,476,\n {atom,476,a},\n {cons,476,\n {atom,476,b},\n {cons,476,{atom,476,c},{nil,476}}}}]}}},\n {match,478,\n {atom,478,integer},\n {call,478,\n {atom,478,sel_same_value},\n [{tuple,478,[{atom,478,r},{integer,478,42}]}]}},\n {match,479,\n {atom,479,error},\n {call,479,\n {atom,479,sel_same_value},\n [{tuple,479,[{atom,479,r},{integer,479,100}]}]}},\n {match,480,\n {atom,480,error},\n {call,480,{atom,480,sel_same_value},[{atom,480,a}]}},\n {match,482,\n {atom,482,integer42},\n {call,482,{atom,482,sel_same_value2},[{integer,482,42}]}},\n {match,483,\n {atom,483,integer43},\n {call,483,{atom,483,sel_same_value2},[{integer,483,43}]}},\n {match,484,\n {atom,484,error},\n {call,484,{atom,484,sel_same_value2},[{integer,484,44}]}},\n {atom,486,ok}]}]}.\n{function,488,sel_different_types,1,\n [{clause,488,\n [{match,488,\n {tuple,488,[{atom,488,r},{var,488,'_'}]},\n {var,488,'T'}}],\n [[{op,488,'=:=',\n {call,488,\n {atom,488,element},\n [{integer,488,2},{var,488,'T'}]},\n {atom,488,forty_two}}]],\n [{atom,489,atom}]},\n {clause,490,\n [{match,490,\n {tuple,490,[{atom,490,r},{var,490,'_'}]},\n {var,490,'T'}}],\n [[{op,490,'=:=',\n {call,490,\n {atom,490,element},\n [{integer,490,2},{var,490,'T'}]},\n {integer,490,42}}]],\n [{atom,491,integer}]},\n {clause,492,\n [{match,492,\n {tuple,492,[{atom,492,r},{var,492,'_'}]},\n {var,492,'T'}}],\n [[{op,492,'=:=',\n {call,492,\n {atom,492,element},\n [{integer,492,2},{var,492,'T'}]},\n {float,492,100.0}}]],\n [{atom,493,float}]},\n {clause,494,\n [{tuple,494,[{atom,494,r},{var,494,'_'}]}],\n [],\n [{atom,495,none}]}]}.\n{function,497,sel_same_value,1,\n [{clause,497,\n [{tuple,497,[{atom,497,r},{var,497,'V'}]}],\n [[{op,497,'=:=',{var,497,'V'},{integer,497,42}}]],\n [{atom,498,integer}]},\n {clause,499,\n [{tuple,499,[{atom,499,r},{var,499,'V'}]}],\n [[{op,499,'=:=',{var,499,'V'},{integer,499,42}}]],\n [{atom,500,integer42}]},\n {clause,501,[{var,501,'_'}],[],[{atom,502,error}]}]}.\n{function,504,sel_same_value2,1,\n [{clause,504,\n [{var,504,'V'}],\n [[{op,504,'=:=',{var,504,'V'},{integer,504,42}}]],\n [{atom,505,integer42}]},\n {clause,506,\n [{var,506,'V'}],\n [[{op,506,'=:=',{var,506,'V'},{integer,506,42}}],\n [{op,506,'=:=',{var,506,'V'},{integer,506,43}}]],\n [{atom,507,integer43}]},\n {clause,508,[{var,508,'_'}],[],[{atom,509,error}]}]}.\n{function,514,deselectify,1,\n [{clause,514,\n [{var,514,'Config'}],\n [[{call,514,{atom,514,is_list},[{var,514,'Config'}]}]],\n [{match,515,\n {atom,515,one_or_other},\n {call,515,\n {atom,515,desel_tuple_arity},\n [{tuple,515,[{integer,515,1}]}]}},\n {match,516,\n {atom,516,two},\n {call,516,\n {atom,516,desel_tuple_arity},\n [{tuple,516,[{integer,516,1},{integer,516,1}]}]}},\n {match,517,\n {atom,517,one_or_other},\n {call,517,\n {atom,517,desel_tuple_arity},\n [{tuple,517,\n [{integer,517,1},{integer,517,1},{integer,517,1}]}]}},\n {match,519,\n {atom,519,one_or_other},\n {call,519,{atom,519,dsel_integer},[{integer,519,1}]}},\n {match,520,\n {atom,520,two},\n {call,520,{atom,520,dsel_integer},[{integer,520,2}]}},\n {match,521,\n {atom,521,one_or_other},\n {call,521,{atom,521,dsel_integer},[{integer,521,3}]}},\n {match,523,\n {atom,523,one_or_other},\n {call,523,{atom,523,dsel_integer_typecheck},[{integer,523,1}]}},\n {match,524,\n {atom,524,two},\n {call,524,{atom,524,dsel_integer_typecheck},[{integer,524,2}]}},\n {match,525,\n {atom,525,one_or_other},\n {call,525,{atom,525,dsel_integer_typecheck},[{integer,525,3}]}},\n {match,527,\n {atom,527,one_or_other},\n {call,527,{atom,527,dsel_atom},[{atom,527,one}]}},\n {match,528,\n {atom,528,two},\n {call,528,{atom,528,dsel_atom},[{atom,528,two}]}},\n {match,529,\n {atom,529,one_or_other},\n {call,529,{atom,529,dsel_atom},[{atom,529,three}]}},\n {match,531,\n {atom,531,one_or_other},\n {call,531,{atom,531,dsel_atom_typecheck},[{atom,531,one}]}},\n {match,532,\n {atom,532,two},\n {call,532,{atom,532,dsel_atom_typecheck},[{atom,532,two}]}},\n {match,533,\n {atom,533,one_or_other},\n {call,533,{atom,533,dsel_atom_typecheck},[{atom,533,three}]}},\n {match,538,\n {atom,538,stop},\n {call,538,{atom,538,dsel_peek_0},[{atom,538,stop}]}},\n {match,539,\n {atom,539,ignore},\n {call,539,{atom,539,dsel_peek_0},[{atom,539,ignore}]}},\n {match,540,\n {var,540,'Config'},\n {call,540,{atom,540,dsel_peek_0},[{var,540,'Config'}]}},\n {match,542,\n {atom,542,stop},\n {call,542,\n {atom,542,dsel_peek_1},\n [{atom,542,stop},{atom,542,any}]}},\n {match,543,\n {var,543,'Config'},\n {call,543,\n {atom,543,dsel_peek_1},\n [{atom,543,ignore},{var,543,'Config'}]}},\n {match,544,\n {atom,544,other},\n {call,544,\n {atom,544,dsel_peek_1},\n [{atom,544,other},{atom,544,ignored}]}},\n {match,546,\n {integer,546,0},\n {call,546,\n {atom,546,dsel_peek_2},\n [{integer,546,0},{atom,546,any}]}},\n {match,547,\n {var,547,'Config'},\n {call,547,\n {atom,547,dsel_peek_2},\n [{integer,547,1},{var,547,'Config'}]}},\n {match,548,\n {integer,548,2},\n {call,548,\n {atom,548,dsel_peek_2},\n [{integer,548,2},{atom,548,ignored}]}},\n {match,550,\n {atom,550,true},\n {call,550,{atom,550,dsel_peek_3},[{atom,550,true}]}},\n {match,551,\n {atom,551,false},\n {call,551,{atom,551,dsel_peek_3},[{atom,551,false}]}},\n {match,552,\n {tuple,552,[{atom,552,error},{var,552,'Config'}]},\n {call,552,{atom,552,dsel_peek_3},[{var,552,'Config'}]}},\n {atom,554,ok}]}]}.\n{function,559,desel_tuple_arity,1,\n [{clause,559,\n [{var,559,'Tuple'}],\n [[{call,559,{atom,559,is_tuple},[{var,559,'Tuple'}]}]],\n [{'case',560,\n {var,560,'Tuple'},\n [{clause,561,\n [{tuple,561,[{var,561,'_'}]}],\n [],\n [{atom,561,one_or_other}]},\n {clause,562,\n [{tuple,562,[{var,562,'_'},{var,562,'_'}]}],\n [],\n [{atom,562,two}]},\n {clause,563,[{var,563,'_'}],[],[{atom,563,one_or_other}]}]}]}]}.\n{function,566,dsel_integer,1,\n [{clause,566,\n [{var,566,'Val'}],\n [],\n [{'case',567,\n {var,567,'Val'},\n [{clause,568,\n [{integer,568,1}],\n [],\n [{atom,568,one_or_other}]},\n {clause,569,\n [{integer,569,2}],\n [],\n [{atom,569,two}]},\n {clause,570,\n [{var,570,'_'}],\n [],\n [{atom,570,one_or_other}]}]}]}]}.\n{function,573,dsel_integer_typecheck,1,\n [{clause,573,\n [{var,573,'Val'}],\n [[{call,573,{atom,573,is_integer},[{var,573,'Val'}]}]],\n [{'case',574,\n {var,574,'Val'},\n [{clause,575,\n [{integer,575,1}],\n [],\n [{atom,575,one_or_other}]},\n {clause,576,\n [{integer,576,2}],\n [],\n [{atom,576,two}]},\n {clause,577,\n [{var,577,'_'}],\n [],\n [{atom,577,one_or_other}]}]}]}]}.\n{function,580,dsel_atom,1,\n [{clause,580,\n [{var,580,'Val'}],\n [],\n [{'case',581,\n {var,581,'Val'},\n [{clause,582,\n [{atom,582,one}],\n [],\n [{atom,582,one_or_other}]},\n {clause,583,[{atom,583,two}],[],[{atom,583,two}]},\n {clause,584,\n [{var,584,'_'}],\n [],\n [{atom,584,one_or_other}]}]}]}]}.\n{function,587,dsel_atom_typecheck,1,\n [{clause,587,\n [{var,587,'Val'}],\n [[{call,587,{atom,587,is_atom},[{var,587,'Val'}]}]],\n [{'case',588,\n {var,588,'Val'},\n [{clause,589,\n [{atom,589,one}],\n [],\n [{atom,589,one_or_other}]},\n {clause,590,[{atom,590,two}],[],[{atom,590,two}]},\n {clause,591,\n [{var,591,'_'}],\n [],\n [{atom,591,one_or_other}]}]}]}]}.\n{function,599,dsel_peek_0,1,\n [{clause,599,\n [{var,599,'A0'}],\n [],\n [{'case',600,\n {call,600,{atom,600,id},[{var,600,'A0'}]},\n [{clause,601,\n [{atom,601,stop}],\n [],\n [{atom,601,stop}]},\n {clause,602,\n [{atom,602,ignore}],\n [],\n [{atom,602,ignore}]},\n {clause,603,\n [{var,603,'A'}],\n [],\n [{var,603,'A'}]}]}]}]}.\n{function,606,dsel_peek_1,2,\n [{clause,606,\n [{var,606,'A0'},{var,606,'B'}],\n [],\n [{'case',607,\n {call,607,{atom,607,id},[{var,607,'A0'}]},\n [{clause,608,\n [{atom,608,stop}],\n [],\n [{atom,608,stop}]},\n {clause,609,\n [{atom,609,ignore}],\n [],\n [{var,609,'B'}]},\n {clause,610,\n [{var,610,'A'}],\n [],\n [{var,610,'A'}]}]}]}]}.\n{function,613,dsel_peek_2,2,\n [{clause,613,\n [{var,613,'A0'},{var,613,'B'}],\n [],\n [{'case',614,\n {call,614,{atom,614,id},[{var,614,'A0'}]},\n [{clause,615,\n [{integer,615,0}],\n [],\n [{integer,615,0}]},\n {clause,616,[{integer,616,1}],[],[{var,616,'B'}]},\n {clause,617,\n [{var,617,'A'}],\n [],\n [{var,617,'A'}]}]}]}]}.\n{function,620,dsel_peek_3,1,\n [{clause,620,\n [{var,620,'A0'}],\n [],\n [{'case',621,\n {call,621,{atom,621,id},[{var,621,'A0'}]},\n [{clause,622,[{atom,622,true}],[],[{atom,622,true}]},\n {clause,623,[{atom,623,false}],[],[{atom,623,false}]},\n {clause,624,\n [{var,624,'Other'}],\n [],\n [{tuple,624,[{atom,624,error},{var,624,'Other'}]}]}]}]}]}.\n{function,627,underscore,1,\n [{clause,627,\n [{var,627,'Config'}],\n [[{call,627,{atom,627,is_list},[{var,627,'Config'}]}]],\n [{'case',628,\n {var,628,'Config'},\n [{clause,629,\n [{nil,629}],\n [],\n [{match,631,\n {var,631,'_'},\n {call,631,{atom,631,length},[{var,631,'Config'}]}}]},\n {clause,632,\n [{cons,632,{var,632,'_'},{var,632,'_'}}],\n [],\n [{match,634,\n {var,634,'_'},\n {call,634,\n {atom,634,list_to_tuple},\n [{var,634,'Config'}]}}]}]},\n {match,636,\n {var,636,'_'},\n {call,636,{atom,636,is_list},[{var,636,'Config'}]}},\n {atom,637,ok}]}]}.\n{attribute,639,record,\n {s,[{record_field,639,{atom,639,map}},\n {record_field,639,{atom,639,t}}]}}.\n{function,641,match_map,1,\n [{clause,641,\n [{var,641,'Config'}],\n [[{call,641,{atom,641,is_list},[{var,641,'Config'}]}]],\n [{match,642,\n {var,642,'Map'},\n {map,642,\n [{map_field_assoc,642,\n {atom,642,key},\n {tuple,642,[{atom,642,x},{atom,642,y}]}},\n {map_field_assoc,642,\n {atom,642,ignore},\n {atom,642,anything}}]}},\n {match,643,\n {record,643,s,\n [{record_field,643,{atom,643,map},{var,643,'Map'}},\n {record_field,643,\n {atom,643,t},\n {tuple,643,[{atom,643,x},{atom,643,y}]}}]},\n {call,643,\n {atom,643,do_match_map},\n [{record,643,s,\n [{record_field,643,{atom,643,map},{var,643,'Map'}}]}]}},\n {match,644,\n {tuple,644,\n [{atom,644,a},\n {map,644,\n [{map_field_exact,644,\n {atom,644,k},\n {tuple,644,\n [{atom,644,a},{atom,644,b},{atom,644,c}]}}]}]},\n {call,644,\n {atom,644,do_match_map_2},\n [{map,644,\n [{map_field_assoc,644,\n {atom,644,k},\n {tuple,644,\n [{atom,644,a},\n {atom,644,b},\n {atom,644,c}]}}]}]}},\n {atom,645,ok}]}]}.\n{function,647,do_match_map,1,\n [{clause,647,\n [{match,647,\n {record,647,s,\n [{record_field,647,\n {atom,647,map},\n {map,647,\n [{map_field_exact,647,\n {atom,647,key},\n {var,647,'Val'}}]}}]},\n {var,647,'S'}}],\n [],\n [{record,649,\n {var,649,'S'},\n s,\n [{record_field,649,{atom,649,t},{var,649,'Val'}}]}]}]}.\n{function,651,do_match_map_2,1,\n [{clause,651,\n [{var,651,'Map'}],\n [],\n [{'case',652,\n {tuple,652,[{atom,652,a},{var,652,'Map'}]},\n [{clause,653,\n [{match,653,\n {tuple,653,\n [{atom,653,a},\n {map,653,\n [{map_field_exact,653,\n {atom,653,k},\n {var,653,'_'}}]}]},\n {var,653,'Tuple'}}],\n [],\n [{var,654,'Tuple'}]}]}]}]}.\n{function,657,map_vars_used,1,\n [{clause,657,\n [{var,657,'Config'}],\n [[{call,657,{atom,657,is_list},[{var,657,'Config'}]}]],\n [{match,658,\n {tuple,658,[{atom,658,some},{atom,658,value}]},\n {call,658,\n {atom,658,do_map_vars_used},\n [{atom,658,a},\n {atom,658,b},\n {map,658,\n [{map_field_assoc,658,\n {tuple,658,[{atom,658,a},{atom,658,b}]},\n {integer,658,42}},\n {map_field_assoc,658,\n {atom,658,v},\n {tuple,658,\n [{atom,658,some},{atom,658,value}]}}]}]}},\n {atom,659,ok}]}]}.\n{function,661,do_map_vars_used,3,\n [{clause,661,\n [{var,661,'X'},{var,661,'Y'},{var,661,'Map'}],\n [],\n [{'case',662,\n {tuple,662,[{var,662,'X'},{var,662,'Y'}]},\n [{clause,663,\n [{var,663,'T'}],\n [],\n [{match,665,\n {map,665,\n [{map_field_exact,665,\n {var,665,'T'},\n {integer,665,42}},\n {map_field_exact,665,\n {atom,665,v},\n {var,665,'Val'}}]},\n {var,665,'Map'}},\n {var,666,'Val'}]}]}]}]}.\n{attribute,669,record,\n {coverage_id,[{record_field,669,{atom,669,bool},{atom,669,false}},\n {record_field,669,{atom,669,id}}]}}.\n{function,670,coverage,1,\n [{clause,670,\n [{var,670,'Config'}],\n [[{call,670,{atom,670,is_list},[{var,670,'Config'}]}]],\n [{match,672,\n {atom,672,ok},\n {call,672,{atom,672,coverage_1},[{atom,672,x},{atom,672,a}]}},\n {match,673,\n {atom,673,ok},\n {call,673,{atom,673,coverage_1},[{atom,673,x},{atom,673,b}]}},\n {match,676,\n {atom,676,ok},\n {call,676,{atom,676,coverage_3},[{string,676,\"abc\"}]}},\n {match,679,\n {tuple,679,[{atom,679,expr},{atom,679,key}]},\n {call,679,\n {atom,679,coverage_4},\n [{cons,679,\n {atom,679,literal},\n {cons,679,{atom,679,get},{nil,679}}},\n {cons,679,\n {cons,679,\n {atom,679,expr},\n {cons,679,{atom,679,key},{nil,679}}},\n {nil,679}}]}},\n {match,680,\n {tuple,680,[{atom,680,expr},{atom,680,key}]},\n {call,680,\n {atom,680,coverage_4},\n [{cons,680,\n {atom,680,expr},\n {cons,680,{atom,680,key},{nil,680}}},\n {nil,680}]}},\n {match,682,\n {atom,682,a},\n {call,682,\n {atom,682,coverage_5},\n [{cons,682,\n {integer,682,8},\n {cons,682,\n {integer,682,8},\n {cons,682,{integer,682,8},{nil,682}}}},\n {record,682,coverage_id,\n [{record_field,682,\n {atom,682,bool},\n {atom,682,true}}]}]}},\n {match,683,\n {atom,683,b},\n {call,683,\n {atom,683,coverage_5},\n [{nil,683},\n {record,683,coverage_id,\n [{record_field,683,\n {atom,683,bool},\n {atom,683,true}}]}]}},\n {match,686,{atom,686,ok},{call,686,{atom,686,coverage_6},[]}},\n {atom,688,ok}]}]}.\n{function,690,coverage_1,2,\n [{clause,690,\n [{var,690,'B'},{var,690,'Tag'}],\n [],\n [{'case',691,\n {var,691,'Tag'},\n [{clause,692,\n [{atom,692,a}],\n [],\n [{call,692,\n {atom,692,coverage_2},\n [{integer,692,1},{atom,692,a},{var,692,'B'}]}]},\n {clause,693,\n [{atom,693,b}],\n [],\n [{call,693,\n {atom,693,coverage_2},\n [{integer,693,2},{atom,693,b},{var,693,'B'}]}]}]}]}]}.\n{function,696,coverage_2,3,\n [{clause,696,\n [{integer,696,1},{atom,696,a},{atom,696,x}],\n [],\n [{atom,696,ok}]},\n {clause,697,\n [{integer,697,2},{atom,697,b},{atom,697,x}],\n [],\n [{atom,697,ok}]}]}.\n{function,699,coverage_3,1,\n [{clause,699,\n [{op,699,'++',\n {cons,699,{char,699,97},{nil,699}},\n {op,699,'++',{nil,699},{string,699,\"bc\"}}}],\n [],\n [{atom,699,ok}]}]}.\n{function,702,coverage_4,2,\n [{clause,702,\n [{cons,702,\n {atom,702,literal},\n {cons,702,{atom,702,get},{nil,702}}},\n {cons,702,{var,702,'Expr'},{nil,702}}],\n [],\n [{call,703,\n {atom,703,coverage_4},\n [{var,703,'Expr'},{nil,703}]}]},\n {clause,704,\n [{cons,704,\n {var,704,'Expr'},\n {cons,704,{var,704,'Key'},{nil,704}}},\n {nil,704}],\n [],\n [{tuple,705,[{var,705,'Expr'},{var,705,'Key'}]}]}]}.\n{function,708,coverage_5,2,\n [{clause,708,\n [{var,708,'Config'},{var,708,'TermId'}],\n [[{op,709,'=:=',\n {var,709,'TermId'},\n {record,709,coverage_id,\n [{record_field,709,{atom,709,bool},{atom,709,true}}]}},\n {op,710,'=:=',\n {var,710,'Config'},\n {cons,710,\n {integer,710,8},\n {cons,710,\n {integer,710,8},\n {cons,710,{integer,710,8},{nil,710}}}}}]],\n [{atom,711,a}]},\n {clause,712,\n [{var,712,'_Config'},\n {record,712,coverage_id,\n [{record_field,712,{atom,712,bool},{atom,712,true}}]}],\n [],\n [{atom,713,b}]}]}.\n{function,715,coverage_6,0,\n [{clause,715,[],[],\n [{match,716,{var,716,'X'},{integer,716,17}},\n {'case',717,\n {'case',718,\n {op,718,'>',\n {call,718,{atom,718,id},[{integer,718,1}]},\n {integer,718,0}},\n [{clause,719,[{atom,719,true}],[],[{integer,720,17}]},\n {clause,721,[{atom,721,false}],[],[{integer,722,42}]}]},\n [{clause,725,[{var,725,'X'}],[],[{atom,726,ok}]},\n {clause,727,\n [{var,727,'V'}],\n [],\n [{call,729,\n {atom,729,error},\n [{cons,729,\n {atom,729,error},\n {cons,729,\n {var,729,'X'},\n {cons,729,\n {var,729,'V'},\n {nil,729}}}}]}]}]}]}]}.\n{function,732,grab_bag,1,\n [{clause,732,\n [{var,732,'_Config'}],\n [],\n [{match,733,\n {cons,733,{var,733,'_'},{var,733,'T'}},\n {call,733,\n {atom,733,id},\n [{cons,733,\n {atom,733,a},\n {cons,733,{atom,733,b},{cons,733,{atom,733,c},{nil,733}}}}]}},\n {match,734,\n {cons,734,{atom,734,b},{cons,734,{atom,734,c},{nil,734}}},\n {call,734,{atom,734,id},[{var,734,'T'}]}},\n {match,736,\n {var,736,'T1'},\n {'fun',736,\n {clauses,\n [{clause,736,[],[],\n [{match,737,\n {cons,737,{var,737,'_'},{var,737,'_'}},\n {atom,737,x}}]}]}}},\n {match,739,\n {tuple,739,[{atom,739,'EXIT'},{var,739,'_'}]},\n {'catch',739,{call,739,{var,739,'T1'},[]}}},\n {match,741,\n {var,741,'T2'},\n {'fun',741,\n {clauses,\n [{clause,741,\n [{var,741,'A'},{var,741,'B'}],\n [],\n [{'case',742,\n {tuple,742,\n [{tuple,742,\n [{call,742,{atom,742,element},[{integer,742,1},{var,742,'A'}]},\n {call,742,{atom,742,element},[{integer,742,2},{var,742,'B'}]}]},\n {tuple,743,\n [{call,743,{atom,743,element},[{integer,743,2},{var,743,'A'}]},\n {call,743,\n {atom,743,element},\n [{integer,743,2},{var,743,'B'}]}]}]},\n [{clause,744,\n [{tuple,744,[{var,744,'Same'},{var,744,'Same'}]}],\n [],\n [{atom,744,ok}]},\n {clause,745,\n [{tuple,745,\n [{tuple,745,[{integer,745,0},{integer,745,1}]},\n {tuple,745,[{atom,745,up},{var,745,'X'}]}]}],\n [],\n [{call,745,{atom,745,id},[{var,745,'X'}]}]},\n {clause,746,\n [{tuple,746,\n [{var,746,'_'},{tuple,746,[{var,746,'X'},{var,746,'_'}]}]}],\n [],\n [{call,746,{atom,746,id},[{var,746,'X'}]}]}]}]}]}}},\n {match,749,\n {atom,749,ok},\n {call,749,\n {var,749,'T2'},\n [{tuple,749,[{atom,749,a},{atom,749,a},{atom,749,z},{atom,749,z}]},\n {tuple,749,[{atom,749,z},{atom,749,a},{atom,749,z}]}]}},\n {match,750,\n {integer,750,1},\n {call,750,\n {var,750,'T2'},\n [{tuple,750,[{integer,750,0},{atom,750,up}]},\n {tuple,750,[{atom,750,zzz},{integer,750,1}]}]}},\n {match,751,\n {atom,751,y},\n {call,751,\n {var,751,'T2'},\n [{tuple,751,[{atom,751,x},{atom,751,y}]},\n {tuple,751,[{atom,751,a},{atom,751,z},{atom,751,z}]}]}},\n {match,754,\n {var,754,'L'},\n {cons,754,\n {tuple,754,[{atom,754,stretch},{integer,754,0},{integer,754,0}]},\n {cons,755,\n {tuple,755,[{atom,755,bad},{nil,755}]},\n {cons,756,\n {tuple,756,[{atom,756,bad},{atom,756,atom}]},\n {cons,757,\n {tuple,757,[{atom,757,bad},{integer,757,0}]},\n {cons,758,\n {tuple,758,\n [{atom,758,bad},\n {integer,758,\n 17140672472095896272447595651639067760236831933683123576548010}]},\n {cons,759,\n {tuple,759,\n [{atom,759,bad},\n {integer,759,\n 8570336236047948136223797825819533880118415966841561788274005}]},\n {nil,759}}}}}}}},\n {match,760,\n {atom,760,ok},\n {call,760,\n {atom,760,grab_bag_remove_failure},\n [{var,760,'L'},{atom,760,unit},{integer,760,0}]}},\n {match,762,\n {tuple,762,\n [{integer,762,42},\n {bin,762,\n [{bin_element,762,{integer,762,43},default,default},\n {bin_element,762,{integer,762,44},default,default}]}]},\n {call,762,\n {atom,762,grab_bag_single_valued},\n [{bin,762,\n [{bin_element,762,{integer,762,42},default,default},\n {bin_element,762,{integer,762,43},default,default},\n {bin_element,762,{integer,762,44},default,default}]}]}},\n {match,763,\n {atom,763,empty_list},\n {call,763,{atom,763,grab_bag_single_valued},[{nil,763}]}},\n {match,764,\n {atom,764,empty_tuple},\n {call,764,{atom,764,grab_bag_single_valued},[{tuple,764,[]}]}},\n {atom,766,ok}]}]}.\n{function,768,grab_bag_remove_failure,3,\n [{clause,768,\n [{nil,768},{var,768,'_Unit'},{var,768,'_MaxFailure'}],\n [],\n [{atom,769,ok}]},\n {clause,770,\n [{cons,770,\n {tuple,770,[{atom,770,bad},{var,770,'Bad'}]},\n {var,770,'_'}},\n {var,770,'_Unit'},\n {var,770,'_MaxFailure'}],\n [],\n [{var,771,'Bad'}]},\n {clause,772,\n [{cons,772,\n {match,772,\n {tuple,772,\n [{atom,772,stretch},{var,772,'_'},{var,772,'Mi'}]},\n {var,772,'Stretch'}},\n {var,772,'Specs'}},\n {var,772,'Unit'},\n {var,772,'_MaxFailure'}],\n [],\n [{match,773,\n {tuple,773,[{var,773,'MinMax'},{var,773,'NewMaxFailure'}]},\n {call,773,\n {atom,773,id},\n [{tuple,773,[{atom,773,min},{integer,773,1}]}]}},\n {'case',774,\n {tuple,774,\n [{var,774,'MinMax'},\n {call,774,\n {atom,774,grab_bag_remove_failure},\n [{var,774,'Specs'},\n {var,774,'Unit'},\n {var,774,'NewMaxFailure'}]}]},\n [{clause,775,\n [{tuple,775,\n [{atom,775,min},\n {tuple,775,\n [{var,775,'NewMaxFailure'},{var,775,'Rest'}]}]}],\n [],\n [{tuple,776,\n [{atom,776,done},\n {cons,776,\n {tuple,776,[{atom,776,fixed},{var,776,'Mi'}]},\n {var,776,'Rest'}}]}]},\n {clause,777,\n [{tuple,777,[{atom,777,min},{var,777,'_'}]}],\n [[{op,777,'=/=',{var,777,'Specs'},{nil,777}}]],\n [{call,778,\n {atom,778,grab_bag_remove_failure},\n [{cons,778,\n {var,778,'Stretch'},\n {call,778,{atom,778,tl},[{var,778,'Specs'}]}},\n {var,778,'Unit'},\n {var,778,'NewMaxFailure'}]}]},\n {clause,779,\n [{tuple,779,[{atom,779,min},{var,779,'_'}]}],\n [],\n [{atom,780,ok}]}]}]}]}.\n{function,784,grab_bag_single_valued,1,\n [{clause,784,\n [{bin,784,\n [{bin_element,784,{var,784,'H'},default,default},\n {bin_element,784,{var,784,'T'},default,[bytes]}]}],\n [],\n [{tuple,784,[{var,784,'H'},{var,784,'T'}]}]},\n {clause,785,[{nil,785}],[],[{atom,785,empty_list}]},\n {clause,786,[{tuple,786,[]}],[],[{atom,786,empty_tuple}]}]}.\n{function,790,literal_binary,1,\n [{clause,790,\n [{var,790,'_Config'}],\n [],\n [{match,791,\n {integer,791,3},\n {call,791,\n {atom,791,literal_binary_match},\n [{atom,791,bar},\n {bin,791,\n [{bin_element,791,\n {string,791,\"y\"},\n default,default}]}]}},\n {match,795,\n {integer,795,1},\n {call,795,\n {atom,795,literal_binary_match},\n [{atom,795,bar},\n {bin,795,\n [{bin_element,795,\n {string,795,\"x\"},\n default,default}]}]}},\n {match,796,\n {integer,796,2},\n {call,796,\n {atom,796,literal_binary_match},\n [{atom,796,foo},\n {bin,796,\n [{bin_element,796,\n {string,796,\"x\"},\n default,default}]}]}},\n {match,797,\n {integer,797,3},\n {call,797,\n {atom,797,literal_binary_match},\n [{atom,797,foo},\n {bin,797,\n [{bin_element,797,\n {string,797,\"y\"},\n default,default}]}]}},\n {match,798,\n {atom,798,fail},\n {call,798,\n {atom,798,literal_binary_match},\n [{atom,798,bar},\n {bin,798,\n [{bin_element,798,\n {string,798,\"z\"},\n default,default}]}]}},\n {match,799,\n {atom,799,fail},\n {call,799,\n {atom,799,literal_binary_match},\n [{atom,799,foo},\n {bin,799,\n [{bin_element,799,\n {string,799,\"z\"},\n default,default}]}]}},\n {atom,800,ok}]}]}.\n{function,802,literal_binary_match,2,\n [{clause,802,\n [{atom,802,bar},\n {bin,802,[{bin_element,802,{string,802,\"x\"},default,default}]}],\n [],\n [{integer,802,1}]},\n {clause,803,\n [{var,803,'_'},\n {bin,803,[{bin_element,803,{string,803,\"x\"},default,default}]}],\n [],\n [{integer,803,2}]},\n {clause,804,\n [{var,804,'_'},\n {bin,804,[{bin_element,804,{string,804,\"y\"},default,default}]}],\n [],\n [{integer,804,3}]},\n {clause,805,[{var,805,'_'},{var,805,'_'}],[],[{atom,805,fail}]}]}.\n{function,807,unary_op,1,\n [{clause,807,\n [{var,807,'Config'}],\n [],\n [{match,812,\n {tuple,812,\n [{atom,812,non_associative},\n {integer,812,30}]},\n {call,812,{atom,812,unary_op_1},[{atom,812,'&'}]}},\n {match,813,\n {tuple,813,\n [{atom,813,non_associative},\n {integer,813,300}]},\n {call,813,{atom,813,unary_op_1},[{atom,813,'^'}]}},\n {match,814,\n {tuple,814,\n [{atom,814,non_associative},\n {integer,814,300}]},\n {call,814,\n {atom,814,unary_op_1},\n [{atom,814,'not'}]}},\n {match,815,\n {tuple,815,\n [{atom,815,non_associative},\n {integer,815,300}]},\n {call,815,{atom,815,unary_op_1},[{atom,815,'+'}]}},\n {match,816,\n {tuple,816,\n [{atom,816,non_associative},\n {integer,816,300}]},\n {call,816,{atom,816,unary_op_1},[{atom,816,'-'}]}},\n {match,817,\n {tuple,817,\n [{atom,817,non_associative},\n {integer,817,300}]},\n {call,817,\n {atom,817,unary_op_1},\n [{atom,817,'~~~'}]}},\n {match,818,\n {tuple,818,\n [{atom,818,non_associative},\n {integer,818,300}]},\n {call,818,{atom,818,unary_op_1},[{atom,818,'!'}]}},\n {match,819,\n {tuple,819,\n [{atom,819,non_associative},\n {integer,819,320}]},\n {call,819,{atom,819,unary_op_1},[{atom,819,'@'}]}},\n {match,821,\n {atom,821,error},\n {call,821,\n {atom,821,unary_op_1},\n [{var,821,'Config'}]}},\n {match,822,\n {atom,822,error},\n {call,822,{atom,822,unary_op_1},[{atom,822,abc}]}},\n {match,823,\n {atom,823,error},\n {call,823,\n {atom,823,unary_op_1},\n [{integer,823,42}]}},\n {atom,825,ok}]}]}.\n{function,827,unary_op_1,1,\n [{clause,827,\n [{var,827,'Vop@1'}],\n [],\n [{'case',832,\n {op,832,'=:=',{var,832,'Vop@1'},{atom,832,'&'}},\n [{clause,833,\n [{atom,833,true}],\n [],\n [{tuple,834,[{atom,834,non_associative},{integer,834,30}]}]},\n {clause,835,\n [{atom,835,false}],\n [],\n [{'case',836,\n {'case',837,\n {op,837,'=:=',{var,837,'Vop@1'},{atom,837,'^'}},\n [{clause,838,[{atom,838,true}],[],[{atom,839,true}]},\n {clause,840,\n [{atom,840,false}],\n [],\n [{'case',841,\n {op,841,'=:=',{var,841,'Vop@1'},{atom,841,'not'}},\n [{clause,842,[{atom,842,true}],[],[{atom,843,true}]},\n {clause,844,\n [{atom,844,false}],\n [],\n [{'case',845,\n {op,845,'=:=',{var,845,'Vop@1'},{atom,845,'+'}},\n [{clause,846,[{atom,846,true}],[],[{atom,847,true}]},\n {clause,848,\n [{atom,848,false}],\n [],\n [{'case',849,\n {op,849,'=:=',{var,849,'Vop@1'},{atom,849,'-'}},\n [{clause,850,[{atom,850,true}],[],[{atom,851,true}]},\n {clause,852,\n [{atom,852,false}],\n [],\n [{'case',853,\n {op,853,'=:=',{var,853,'Vop@1'},{atom,853,'~~~'}},\n [{clause,854,[{atom,854,true}],[],[{atom,855,true}]},\n {clause,856,\n [{atom,856,false}],\n [],\n [{op,857,'=:=',\n {var,857,'Vop@1'},\n {atom,857,'!'}}]}]}]}]}]}]}]}]}]}]},\n [{clause,864,\n [{atom,864,true}],\n [],\n [{tuple,865,[{atom,865,non_associative},{integer,865,300}]}]},\n {clause,866,\n [{atom,866,false}],\n [],\n [{'case',867,\n {op,867,'=:=',{var,867,'Vop@1'},{atom,867,'@'}},\n [{clause,868,\n [{atom,868,true}],\n [],\n [{tuple,869,[{atom,869,non_associative},{integer,869,320}]}]},\n {clause,870,\n [{atom,870,false}],\n [],\n [{atom,871,error}]}]}]}]}]}]}]}]}.\n{function,876,eq_types,1,\n [{clause,876,\n [{var,876,'_Config'}],\n [],\n [{match,877,\n {var,877,'Ref'},\n {call,877,{atom,877,make_ref},[]}},\n {match,878,\n {var,878,'Ref'},\n {call,878,\n {atom,878,eq_types},\n [{var,878,'Ref'},{atom,878,any}]}},\n {atom,879,ok}]}]}.\n{function,881,eq_types,2,\n [{clause,881,\n [{var,881,'A'},{var,881,'B'}],\n [],\n [{match,883,\n {var,883,'Term0'},\n {tuple,883,[{var,883,'A'},{var,883,'B'}]}},\n {match,884,\n {var,884,'Term'},\n {call,884,{atom,884,id},[{var,884,'Term0'}]}},\n {match,889,{var,889,'Term'},{var,889,'Term0'}},\n {match,892,\n {tuple,892,[{var,892,'Ref22'},{var,892,'_'}]},\n {var,892,'Term'}},\n {var,894,'Ref22'}]}]}.\n{function,896,match_after_return,1,\n [{clause,896,\n [{var,896,'Config'}],\n [[{call,896,{atom,896,is_list},[{var,896,'Config'}]}]],\n [{match,900,\n {atom,900,ok},\n {'case',900,\n {call,900,\n {atom,900,mar_test_tuple},\n [{call,900,\n {remote,900,\n {atom,900,erlang},\n {atom,900,unique_integer}},\n []}]},\n [{clause,901,\n [{tuple,901,\n [{atom,901,gurka},\n {atom,901,never_matches},\n {var,901,'A'}]}],\n [],\n [{tuple,901,[{atom,901,wont_happen},{var,901,'A'}]}]},\n {clause,902,[{var,902,'_'}],[],[{atom,902,ok}]}]}}]}]}.\n{function,905,mar_test_tuple,1,\n [{clause,905,\n [{var,905,'I'}],\n [],\n [{tuple,905,[{atom,905,gurka},{var,905,'I'}]}]}]}.\n{function,907,match_right_tuple,1,\n [{clause,907,\n [{var,907,'Config'}],\n [[{call,907,{atom,907,is_list},[{var,907,'Config'}]}]],\n [{match,915,\n {var,915,'Inner'},\n {tuple,915,\n [{call,915,{atom,915,id},[{atom,915,wrong_element}]},\n {call,915,{atom,915,id},[{atom,915,ok}]}]}},\n {match,916,\n {var,916,'Outer'},\n {tuple,916,\n [{var,916,'Inner'},\n {call,916,{atom,916,id},[{atom,916,wrong_tuple}]}]}},\n {match,917,\n {atom,917,ok},\n {call,917,\n {atom,917,match_right_tuple_1},\n [{var,917,'Outer'}]}}]}]}.\n{function,919,match_right_tuple_1,1,\n [{clause,919,\n [{var,919,'T'}],\n [],\n [{match,920,\n {tuple,920,[{var,920,'A'},{var,920,'_'}]},\n {var,920,'T'}},\n {match,921,\n {tuple,921,[{var,921,'_'},{var,921,'B'}]},\n {var,921,'A'}},\n {call,923,\n {atom,923,id},\n [{call,923,\n {atom,923,force_succ_regs},\n [{var,923,'A'},{var,923,'B'}]}]}]}]}.\n{function,925,force_succ_regs,2,\n [{clause,925,[{var,925,'_A'},{var,925,'B'}],[],[{var,925,'B'}]}]}.\n{function,927,tuple_size_in_try,1,\n [{clause,927,\n [{var,927,'Config'}],\n [[{call,927,{atom,927,is_list},[{var,927,'Config'}]}]],\n [{match,930,\n {atom,930,ok},\n {call,930,{atom,930,tsit},[{atom,930,gurka}]}},\n {match,931,\n {atom,931,ok},\n {call,931,{atom,931,tsit},[{atom,931,gaffel}]}}]}]}.\n{function,933,tsit,1,\n [{clause,933,\n [{var,933,'A'}],\n [],\n [{'try',934,\n [{call,935,{atom,935,id},[{atom,935,ignored}]},\n {match,936,\n {integer,936,1},\n {call,936,{atom,936,tuple_size},[{var,936,'A'}]}},\n {atom,937,error}],\n [],\n [{clause,939,\n [{tuple,939,[{var,939,'_'},{var,939,'_'},{var,939,'_'}]}],\n [],\n [{atom,939,ok}]}],\n []}]}]}.\n{function,942,match_boolean_list,1,\n [{clause,942,\n [{var,942,'Config'}],\n [[{call,942,{atom,942,is_list},[{var,942,'Config'}]}]],\n [{match,943,\n {var,943,'BoolList'},\n {lc,943,\n {op,943,'=:=',\n {op,943,'rem',{var,943,'N'},{integer,943,2}},\n {integer,943,0}},\n [{generate,943,\n {var,943,'N'},\n {call,943,\n {remote,943,{atom,943,lists},{atom,943,seq}},\n [{integer,943,1},{integer,943,8}]}}]}},\n {match,950,\n {atom,950,ok},\n {'case',950,\n {var,950,'BoolList'},\n [{clause,951,\n [{cons,951,{atom,951,true},{var,951,'_'}}],\n [],\n [{atom,951,error}]},\n {clause,952,\n [{cons,952,{atom,952,false},{var,952,'_'}}],\n [],\n [{atom,952,ok}]}]}}]}]}.\n{function,955,id,1,[{clause,955,[{var,955,'I'}],[],[{var,955,'I'}]}]}.\n{eof,956}.\n" }, { "path": "test_data/match_SUITE.erl", "content": "%%\n%% %CopyrightBegin%\n%%\n%% Copyright Ericsson AB 2004-2019. All Rights Reserved.\n%%\n%% Licensed under the Apache License, Version 2.0 (the \"License\");\n%% you may not use this file except in compliance with the License.\n%% You may obtain a copy of the License at\n%%\n%% http://www.apache.org/licenses/LICENSE-2.0\n%%\n%% Unless required by applicable law or agreed to in writing, software\n%% distributed under the License is distributed on an \"AS IS\" BASIS,\n%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n%% See the License for the specific language governing permissions and\n%% limitations under the License.\n%%\n%% %CopyrightEnd%\n%%\n-module(match_SUITE).\n\n-export([all/0, suite/0,groups/0,init_per_suite/1, end_per_suite/1, \n\t init_per_group/2,end_per_group/2,\n\t pmatch/1,mixed/1,aliases/1,non_matching_aliases/1,\n\t match_in_call/1,untuplify/1,shortcut_boolean/1,letify_guard/1,\n\t selectify/1,deselectify/1,underscore/1,match_map/1,map_vars_used/1,\n\t coverage/1,grab_bag/1,literal_binary/1,\n unary_op/1,eq_types/1,match_after_return/1,match_right_tuple/1,\n tuple_size_in_try/1,match_boolean_list/1]).\n\t \n-include_lib(\"common_test/include/ct.hrl\").\n\nsuite() -> [{ct_hooks,[ts_install_cth]}].\n\nall() -> \n [{group,p}].\n\ngroups() -> \n [{p,[parallel],\n [pmatch,mixed,aliases,non_matching_aliases,\n match_in_call,untuplify,\n shortcut_boolean,letify_guard,selectify,deselectify,\n underscore,match_map,map_vars_used,coverage,\n grab_bag,literal_binary,unary_op,eq_types,\n match_after_return,match_right_tuple,\n tuple_size_in_try,match_boolean_list]}].\n\n\ninit_per_suite(Config) ->\n test_lib:recompile(?MODULE),\n Config.\n\nend_per_suite(_Config) ->\n ok.\n\ninit_per_group(_GroupName, Config) ->\n Config.\n\nend_per_group(_GroupName, Config) ->\n Config.\n\n\npmatch(Config) when is_list(Config) ->\n ok = doit(1),\n ok = doit(2),\n {error,baz} = doit(3),\n {error,foobar} = doit(4),\n ok.\n\n%% Thanks to Tobias Lindahl (HiPE).\n-define(FOO(X),\n\tcase X of\n\t 1 -> foo;\n\t 2 -> bar;\n\t 3 -> baz;\n\t 4 -> foobar\n\tend).\n\ndoit(X) ->\n case ?FOO(X) of\n\tfoo -> ok;\n\tbar -> ok;\n\tOther -> {error, Other}\n end.\n\nmixed(Config) when is_list(Config) ->\n glufs = mixit(1),\n klafs = mixit(2),\n fnurra = mixit(3),\n usch = mixit(4),\n {error,blurf} = mixit(5),\n {error,87987987} = mixit(6),\n {error,{a,b,c}} = mixit(7),\n ok.\n\nmixit(X) ->\n case case X of\n\t 1 -> a;\n\t 2 -> b;\n\t 3 -> 42;\n\t 4 -> 77;\n\t 4+1 -> blurf;\n\t 5+1 -> 87987987;\n\t 6+1 -> {a,b,c}\n\t end of\n\ta -> glufs;\n\tb -> klafs;\n\t42 -> fnurra;\n\t77 -> usch;\n\tOther -> {error,Other}\n end.\n\naliases(Config) when is_list(Config) ->\n %% Lists/strings.\n ok = str_alias(\"abc\"),\n ok = str_alias(\"def\"),\n ok = str_alias(\"ghi\"),\n ok = str_alias(\"klm\"),\n ok = str_alias(\"qrs\"),\n ok = str_alias(\"xy\"),\n ok = str_alias(\"\"),\n ok = str_alias([]),\n error = str_alias(\"blurf\"),\n\n %% Characters/integers.\n ok = char_alias($v),\n ok = char_alias(118),\n ok = char_alias($w),\n ok = char_alias(119),\n ok = char_alias(42),\n ok = char_alias(3.0),\n error = char_alias($_),\n error = char_alias(0),\n\n {42,42,42} = three(42),\n\n {1,42,99,1,42,99} = tuple_alias({1,42,99}),\n {-10,20,-10,20,-10,20} = tuple_alias({-10,20}),\n 6 = tup_lit_alias({1,2,3}),\n 6 = tup_lit_alias_rev({1,2,3}),\n\n {42,42,42,42} = multiple_aliases_1(42),\n {7,7,7} = multiple_aliases_2(7),\n {{a,b},{a,b},{a,b}} = multiple_aliases_3({a,b}),\n\n %% Lists/literals.\n {a,b} = list_alias1([a,b]),\n {a,b} = list_alias2([a,b]),\n {a,b} = list_alias3([a,b]),\n\n ok.\n\nstr_alias(V) ->\n Res = str_alias_1(V),\n Res = str_alias_2(V).\n\nstr_alias_1([$a,$b,$c]=\"abc\"=\"a\"++[$b,$c]=[97,98,99]) -> ok;\nstr_alias_1([$d|\"ef\"]=\"def\") -> ok;\nstr_alias_1([$g|\"hi\"]=\"g\"++\"hi\"=\"gh\"++\"i\"=\"ghi\"++\"\") -> ok;\nstr_alias_1(\"k\"++\"lm\"=[$k|\"lm\"]) -> ok;\nstr_alias_1([113,114,115]=\"qrs\"=[$q,$r,$s]=\"q\"++\"r\"++\"s\") -> ok;\nstr_alias_1([$x,$y]=\"xy\") -> ok;\nstr_alias_1(\"\"=[]) -> ok;\nstr_alias_1(_) -> error.\n\n%% Make sure that different line numbers do not matter.\n\nstr_alias_2([$a,$b,$c]=\n\t \"abc\"=\n\t \"a\"++[$b,$c\n\t ]=\n\t [97,98,99\n\t ]) -> ok;\nstr_alias_2([$d|\"ef\"]=\n\t \"def\") -> ok;\nstr_alias_2([$g|\"hi\"]=\n\t \"g\"++\"hi\"=\n\t \"gh\"++\"i\"=\n\t \"ghi\"++\"\") -> ok;\nstr_alias_2(\"k\"++\"lm\"=\n\t [$k|\"lm\"\n\t ]) -> ok;\nstr_alias_2([113,114,115]=\n\t \"qrs\"=[$q,$r,$s\n\t\t]=\n\t \"q\"++\"r\"++\"s\") -> ok;\nstr_alias_2([$x,$y]=\n\t \"xy\") -> ok;\nstr_alias_2(\"\"=\n\t []) -> ok;\nstr_alias_2(_) -> error.\n\nchar_alias(V) ->\n Res = char_alias_1(V),\n Res = char_alias_2(V).\n\nchar_alias_1(118=$v) -> ok;\nchar_alias_1($w=119) -> ok;\nchar_alias_1(42=42) -> ok;\nchar_alias_1(3.0=3.0) -> ok;\nchar_alias_1(_) -> error.\n\nchar_alias_2(118=\n\t $v) -> ok;\nchar_alias_2($w=\n\t 119) -> ok;\nchar_alias_2(42=\n\t 42) -> ok;\nchar_alias_2(3.0=\n\t 3.0) -> ok;\nchar_alias_2(_) -> error.\n\nthree(V) ->\n Res = three_1(V),\n Res = three_2(V).\n\nthree_1(A=B=C) ->\n {A,B,C}.\n\nthree_2(A=\n\tB=\n\tC) ->\n {A,B,C}.\n\ntuple_alias({A,B,C}={X,Y,Z}) ->\n {A,B,C,X,Y,Z};\ntuple_alias({A,B}={C,D}={E,F}) ->\n {A,B,C,D,E,F}.\n\ntup_lit_alias({A,B,C}={1,2,3}) ->\n A+B+C.\n\ntup_lit_alias_rev({1,2,3}={A,B,C}) ->\n A+B+C.\n\nmultiple_aliases_1((A=B)=(C=D)) ->\n {A,B,C,D}.\n\nmultiple_aliases_2((A=B)=(A=C)) ->\n {A,B,C}.\n\nmultiple_aliases_3((A={_,_}=B)={_,_}=C) ->\n {A,B,C}.\n\nlist_alias1([a,b]=[X,Y]) ->\n {X,Y}.\n\nlist_alias2([X,Y]=[a,b]) ->\n {X,Y}.\n\nlist_alias3([X,b]=[a,Y]) ->\n {X,Y}.\n\nnon_matching_aliases(_Config) ->\n none = mixed_aliases(<<42>>),\n none = mixed_aliases([b]),\n none = mixed_aliases([d]),\n none = mixed_aliases({a,42}),\n none = mixed_aliases(42),\n none = mixed_aliases(<<6789:16>>),\n none = mixed_aliases(#{key=>value}),\n\n {'EXIT',{{badmatch,42},_}} = (catch nomatch_alias(42)),\n {'EXIT',{{badmatch,job},_}} = (catch entirely()),\n {'EXIT',{{badmatch,associates},_}} = (catch printer()),\n {'EXIT',{{badmatch,borogoves},_}} = (catch tench()),\n\n put(perch, 0),\n {'EXIT',{{badmatch,{spine,42}},_}} = (catch perch(42)),\n 1 = erase(perch),\n\n put(salmon, 0),\n {'EXIT',{{badmatch,mimsy},_}} = (catch salmon()),\n 1 = erase(salmon),\n\n put(shark, 0),\n {'EXIT',{{badmatch,_},_}} = (catch shark()),\n 1 = erase(shark),\n\n {'EXIT',{{badmatch,_},_}} = (catch radio(research)),\n ok.\n\nmixed_aliases(<> = x) -> {a,X};\nmixed_aliases([b] = <>) -> {b,X};\nmixed_aliases(<> = {a,X}) -> {c,X};\nmixed_aliases([X] = <>) -> {d,X};\nmixed_aliases(<> = X) -> {e,X};\nmixed_aliases(X = <>) -> {f,X};\nmixed_aliases(<> = X) -> {g,X};\nmixed_aliases(X = <>) -> {h,X};\nmixed_aliases(X = #{key:=X}) -> {i,X};\nmixed_aliases(#{key:=X} = X) -> {j,X};\nmixed_aliases([X] = #{key:=X}) -> {k,X};\nmixed_aliases(#{key:=X} = [X]) -> {l,X};\nmixed_aliases({a,X} = #{key:=X}) -> {m,X};\nmixed_aliases(#{key:=X} = {a,X}) -> {n,X};\nmixed_aliases(_) -> none.\n\nnomatch_alias(I) ->\n {ok={A,B}} = id(I),\n {A,B}.\n\nentirely() ->\n 0(((Voice = true) = cool) = job),\n [receive _ -> Voice end || banking <- printer].\n\nprinter() ->\n {[Indoor] = [] = associates},\n [ireland || Indoor <- Indoor].\n\ntench() ->\n E = begin\n\t [A] = [] = borogoves,\n\t A + 1\n\tend,\n E + 7 * A.\n\nperch(X) ->\n begin\n\tput(perch, get(perch)+1),\n\t[A] = [] = {spine,X}\n end.\n\nsalmon() ->\n {put(salmon, get(salmon)+1),#{key:=([A]=[])}=mimsy,exit(fail)},\n A + 10.\n\nshark() ->\n (hello = there) = (catch shark(put(shark, get(shark)+1), a = b)).\n\nshark(_, _) ->\n ok.\n\nradio(research) ->\n (connection = proof) =\n\t(catch erlang:trace_pattern(catch mechanisms + assist,\n\t\t\t\t summary = mechanisms)).\n\n%% OTP-7018.\n\nmatch_in_call(Config) when is_list(Config) ->\n mac_a(0),\n mac_b(1),\n mac_c(42),\n mac_d(42),\n mac_e({gurka,42}),\n\n [{2,2},{2,2}] = mac_lc([{2,any},{2,2}]),\n {'EXIT',_} = (catch mac_lc([{1,1}])),\n\n ok.\n\nmac_a(X) ->\n id(_Gurka = {gurka,X}),\n ok.\n\nmac_b(X) ->\n id(Gurka = {gurka,X}),\n gurka(Gurka, X),\n ok.\n\nmac_c(X) ->\n id(Gurka = Yxa = {gurka,X}),\n id({Gurka,Yxa}),\n ok.\n\nmac_d(X) ->\n id({gurka,42} = {gurka,X}),\n ok.\n\nmac_e(X) ->\n id({gurka,42} = X),\n ok.\n\nmac_lc(E) ->\n Res = mac_lc1(E),\n Res = mac_lc2(E).\n\nmac_lc1(E) ->\n [{X,Y} ||\n\t{X,_} <- E,\n\t(Y = X) =:= (Y = 1 + 1)].\n\nmac_lc2(E) ->\n [{X,Y} ||\n\t{X,_} <- E,\n\t(Y = X) =:= (Y = 2)].\n\ngurka({gurka,X}, X) -> ok.\n\n\nuntuplify(Config) when is_list(Config) ->\n %% We do this to cover sys_core_fold:unalias_pat/1.\n {1,2,3,4,alias,{[1,2],{3,4},alias}} = untuplify_1([1,2], {3,4}, alias),\n error = untuplify_1([1,2], {3,4}, 42),\n\n %% Test that a previous bug in v3_codegen is gone. (The sinking of\n %% stack frames into only the case arms that needed them was not always\n %% safe.)\n [33, -1, -33, 1] = untuplify_2(32, 65),\n {33, 1, -33, -1} = untuplify_2(65, 32),\n\n ok.\n\nuntuplify_1(A, B, C) ->\n case {A,B,C} of\n\t{[X,Y],{Z,W},alias=Alias}=Top ->\n\t {X,Y,Z,W,Alias,Top};\n\t[_,_]=CantMatch ->\n\t CantMatch;\n\t_ ->\n\t error\n end.\n\nuntuplify_2(V1, V2) ->\n {D1,D2,D3,D4} =\n if V1 > V2 ->\n %% The 1 value was overwritten by the value of V2-V1.\n {V1-V2, 1, V2-V1, -1};\n true ->\n {V2-V1, -1, V1-V2, 1}\n end,\n if\n D2 > D4 ->\n {D1, D2, D3, D4};\n true ->\n [D1, D2, D3, D4]\n end.\n\n%% Coverage of beam_dead:shortcut_boolean_label/4.\nshortcut_boolean(Config) when is_list(Config) ->\n false = shortcut_boolean_1([0]),\n true = shortcut_boolean_1({42}),\n maybe = shortcut_boolean_1(self()),\n {'EXIT',_} = (catch shortcut_boolean_1([a,b])),\n {'EXIT',_} = (catch shortcut_boolean_1({a,b})),\n ok.\n\nshortcut_boolean_1(X) ->\n Outer = case not is_pid(X) of\n\t\ttrue ->\n\t\t V = case X of\n\t\t\t [_] -> true;\n\t\t\t {_} -> false\n\t\t\tend,\n\t\t not V;\n\t\tfalse ->\n\t\t maybe\n\t end,\n id(Outer).\n\n\n%% Test sys_core_fold:letify_guard/3.\nletify_guard(Config) when is_list(Config) ->\n {-15,a} = letify_guard(-15, a),\n 5 = letify_guard(2, 3),\n ok.\n\nletify_guard(A, B) ->\n case {A,B} of\n\t%% The tuple will be built in the guard...\n\tZ when tuple_size(Z) =:= 2, element(1, Z) < 0 ->\n\t %% ... and again here.\n\t Z;\n\t{X,Y} -> X+Y\n end.\n\n%% Test combining of is_eq_exact instructions to select_val\n%% instructions in beam_dead and beam_peep.\n\nselectify(Config) when is_list(Config) ->\n integer = sel_different_types({r,42}),\n atom = sel_different_types({r,forty_two}),\n float = sel_different_types({r,100.0}),\n none = sel_different_types({r,18}),\n {'EXIT',_} = (catch sel_different_types([a,b,c])),\n\n integer = sel_same_value({r,42}),\n error = sel_same_value({r,100}),\n error = sel_same_value(a),\n\n integer42 = sel_same_value2(42),\n integer43 = sel_same_value2(43),\n error = sel_same_value2(44),\n\n ok.\n\nsel_different_types({r,_}=T) when element(2, T) =:= forty_two ->\n atom;\nsel_different_types({r,_}=T) when element(2, T) =:= 42 ->\n integer;\nsel_different_types({r,_}=T) when element(2, T) =:= 100.0 ->\n float;\nsel_different_types({r,_}) ->\n none.\n\nsel_same_value({r,V}) when V =:= 42 ->\n integer;\nsel_same_value({r,V}) when V =:= 42 ->\n integer42;\nsel_same_value(_) ->\n error.\n\nsel_same_value2(V) when V =:= 42 ->\n integer42;\nsel_same_value2(V) when V =:= 42; V =:= 43 ->\n integer43;\nsel_same_value2(_) ->\n error.\n\n%% Test deconstruction of select_val instructions to regular tests\n%% with zero or one values left.\n\ndeselectify(Config) when is_list(Config) ->\n one_or_other = desel_tuple_arity({1}),\n two = desel_tuple_arity({1,1}),\n one_or_other = desel_tuple_arity({1,1,1}),\n\n one_or_other = dsel_integer(1),\n two = dsel_integer(2),\n one_or_other = dsel_integer(3),\n\n one_or_other = dsel_integer_typecheck(1),\n two = dsel_integer_typecheck(2),\n one_or_other = dsel_integer_typecheck(3),\n\n one_or_other = dsel_atom(one),\n two = dsel_atom(two),\n one_or_other = dsel_atom(three),\n\n one_or_other = dsel_atom_typecheck(one),\n two = dsel_atom_typecheck(two),\n one_or_other = dsel_atom_typecheck(three),\n\n %% Cover deconstruction of select_val instructions in\n %% beam_peep.\n\n stop = dsel_peek_0(stop),\n ignore = dsel_peek_0(ignore),\n Config = dsel_peek_0(Config),\n\n stop = dsel_peek_1(stop, any),\n Config = dsel_peek_1(ignore, Config),\n other = dsel_peek_1(other, ignored),\n\n 0 = dsel_peek_2(0, any),\n Config = dsel_peek_2(1, Config),\n 2 = dsel_peek_2(2, ignored),\n\n true = dsel_peek_3(true),\n false = dsel_peek_3(false),\n {error,Config} = dsel_peek_3(Config),\n\n ok.\n\n%% The following will be optimized by the sharing optimizations\n%% in beam_ssa_opt.\n\ndesel_tuple_arity(Tuple) when is_tuple(Tuple) ->\n case Tuple of\n {_} -> one_or_other;\n {_,_} -> two;\n _ -> one_or_other\n end.\n\ndsel_integer(Val) ->\n case Val of\n 1 -> one_or_other;\n 2 -> two;\n _ -> one_or_other\n end.\n\ndsel_integer_typecheck(Val) when is_integer(Val) ->\n case Val of\n 1 -> one_or_other;\n 2 -> two;\n _ -> one_or_other\n end.\n\ndsel_atom(Val) ->\n case Val of\n one -> one_or_other;\n two -> two;\n _ -> one_or_other\n end.\n\ndsel_atom_typecheck(Val) when is_atom(Val) ->\n case Val of\n one -> one_or_other;\n two -> two;\n _ -> one_or_other\n end.\n\n%% The following functions are carefully crafted so that the sharing\n%% optimizations in beam_ssa_opt can't be applied. After applying the\n%% beam_jump:eliminate_moves/1 optimization and beam_clean:clean_labels/1\n%% has unified labels, beam_peep is able to optimize these functions.\n\ndsel_peek_0(A0) ->\n case id(A0) of\n stop -> stop;\n ignore -> ignore;\n A -> A\n end.\n\ndsel_peek_1(A0, B) ->\n case id(A0) of\n stop -> stop;\n ignore -> B;\n A -> A\n end.\n\ndsel_peek_2(A0, B) ->\n case id(A0) of\n 0 -> 0;\n 1 -> B;\n A -> A\n end.\n\ndsel_peek_3(A0) ->\n case id(A0) of\n true -> true;\n false -> false;\n Other -> {error,Other}\n end.\n\nunderscore(Config) when is_list(Config) ->\n case Config of\n\t[] ->\n\t %% Assignment to _ at the end of a construct.\n\t _ = length(Config);\n\t[_|_] ->\n\t %% Assignment to _ at the end of a construct.\n\t _ = list_to_tuple(Config)\n end,\n _ = is_list(Config),\n ok.\n\n-record(s, {map,t}).\n\nmatch_map(Config) when is_list(Config) ->\n Map = #{key=>{x,y},ignore=>anything},\n #s{map=Map,t={x,y}} = do_match_map(#s{map=Map}),\n {a,#{k:={a,b,c}}} = do_match_map_2(#{k=>{a,b,c}}),\n ok.\n\ndo_match_map(#s{map=#{key:=Val}}=S) ->\n %% Would crash with a 'badarg' exception.\n S#s{t=Val}.\n\ndo_match_map_2(Map) ->\n case {a,Map} of\n\t{a,#{k:=_}}=Tuple ->\n\t Tuple\n end.\n\nmap_vars_used(Config) when is_list(Config) ->\n {some,value} = do_map_vars_used(a, b, #{{a,b}=>42,v=>{some,value}}),\n ok.\n\ndo_map_vars_used(X, Y, Map) ->\n case {X,Y} of\n\tT ->\n\t %% core_lib:is_var_used/2 would not consider T used.\n\t #{T:=42,v:=Val} = Map,\n\t Val\n end.\n\n-record(coverage_id, {bool=false,id}).\ncoverage(Config) when is_list(Config) ->\n %% Cover beam_dead.\n ok = coverage_1(x, a),\n ok = coverage_1(x, b),\n\n %% Cover sys_pre_expand.\n ok = coverage_3(\"abc\"),\n\n %% Cover beam_ssa_dead.\n {expr,key} = coverage_4([literal,get], [[expr,key]]),\n {expr,key} = coverage_4([expr,key], []),\n\n a = coverage_5([8,8,8], #coverage_id{bool=true}),\n b = coverage_5([], #coverage_id{bool=true}),\n\n %% Cover beam_ssa_opt.\n ok = coverage_6(),\n\n ok.\n\ncoverage_1(B, Tag) ->\n case Tag of\n\ta -> coverage_2(1, a, B);\n\tb -> coverage_2(2, b, B)\n end.\n\ncoverage_2(1, a, x) -> ok;\ncoverage_2(2, b, x) -> ok.\n\ncoverage_3([$a]++[]++\"bc\") -> ok.\n\n%% Cover beam_ssa_dead:eval_type_test_1(is_nonempty_list, Arg).\ncoverage_4([literal,get], [Expr]) ->\n coverage_4(Expr, []);\ncoverage_4([Expr,Key], []) ->\n {Expr,Key}.\n\n%% Cover beam_ssa_dead:eval_type_test_1(is_tagged_tuple, Arg).\ncoverage_5(Config, TermId)\n when TermId =:= #coverage_id{bool=true},\n Config =:= [8,8,8] ->\n a;\ncoverage_5(_Config, #coverage_id{bool=true}) ->\n b.\n\ncoverage_6() ->\n X = 17,\n case\n case id(1) > 0 of\n true ->\n 17;\n false ->\n 42\n end\n of\n X ->\n ok;\n V ->\n %% Cover beam_ssa_opt:make_literal/2.\n error([error,X,V])\n end.\n\ngrab_bag(_Config) ->\n [_|T] = id([a,b,c]),\n [b,c] = id(T),\n\n T1 = fun() ->\n\t\t [_|_] = x\n\t end,\n {'EXIT',_} = (catch T1()),\n\n T2 = fun(A, B) ->\n\t\t case {{element(1, A),element(2, B)},\n\t\t {element(2, A),element(2, B)}} of\n\t\t {Same,Same} -> ok;\n\t\t {{0,1},{up,X}} -> id(X);\n\t\t {_,{X,_}} -> id(X)\n\t\t end\n\t end,\n ok = T2({a,a,z,z}, {z,a,z}),\n 1 = T2({0,up}, {zzz,1}),\n y = T2({x,y}, {a,z,z}),\n\n %% OTP-5244.\n L = [{stretch,0,0},\n\t {bad,[]},\n\t {bad,atom},\n\t {bad,0},\n\t {bad,16#AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA},\n\t {bad,16#555555555555555555555555555555555555555555555555555}],\n ok = grab_bag_remove_failure(L, unit, 0),\n\n {42,<<43,44>>} = grab_bag_single_valued(<<42,43,44>>),\n empty_list = grab_bag_single_valued([]),\n empty_tuple = grab_bag_single_valued({}),\n\n ok.\n\ngrab_bag_remove_failure([], _Unit, _MaxFailure) ->\n ok;\ngrab_bag_remove_failure([{bad,Bad}|_], _Unit, _MaxFailure) ->\n Bad;\ngrab_bag_remove_failure([{stretch,_,Mi}=Stretch | Specs], Unit, _MaxFailure) ->\n {MinMax,NewMaxFailure} = id({min,1}),\n case {MinMax,grab_bag_remove_failure(Specs, Unit, NewMaxFailure)} of\n\t{min,{NewMaxFailure,Rest}} ->\n\t {done,[{fixed,Mi} | Rest]};\n\t{min,_} when Specs =/= [] ->\n\t grab_bag_remove_failure([Stretch|tl(Specs)], Unit, NewMaxFailure);\n\t{min,_} ->\n\t ok\n end.\n\n%% Cover a line v3_kernel that places binary matching first.\ngrab_bag_single_valued(<>) -> {H,T};\ngrab_bag_single_valued([]) -> empty_list;\ngrab_bag_single_valued({}) -> empty_tuple.\n\n\n%% Regression in 19.0, reported by Alexei Sholik\nliteral_binary(_Config) ->\n 3 = literal_binary_match(bar, <<\"y\">>),\n\n %% While we are at it, also test the remaining code paths\n %% in literal_binary_match/2.\n 1 = literal_binary_match(bar, <<\"x\">>),\n 2 = literal_binary_match(foo, <<\"x\">>),\n 3 = literal_binary_match(foo, <<\"y\">>),\n fail = literal_binary_match(bar, <<\"z\">>),\n fail = literal_binary_match(foo, <<\"z\">>),\n ok.\n\nliteral_binary_match(bar, <<\"x\">>) -> 1;\nliteral_binary_match(_, <<\"x\">>) -> 2;\nliteral_binary_match(_, <<\"y\">>) -> 3;\nliteral_binary_match(_, _) -> fail.\n\nunary_op(Config) ->\n %% ERL-514. This test case only verifies that the code\n %% calculates the correct result, not that the generated\n %% code is optimial.\n\n {non_associative,30} = unary_op_1('&'),\n {non_associative,300} = unary_op_1('^'),\n {non_associative,300} = unary_op_1('not'),\n {non_associative,300} = unary_op_1('+'),\n {non_associative,300} = unary_op_1('-'),\n {non_associative,300} = unary_op_1('~~~'),\n {non_associative,300} = unary_op_1('!'),\n {non_associative,320} = unary_op_1('@'),\n\n error = unary_op_1(Config),\n error = unary_op_1(abc),\n error = unary_op_1(42),\n\n ok.\n\nunary_op_1(Vop@1) ->\n %% If all optimizations are working as they should, there should\n %% be no stack frame and all '=:=' tests should be coalesced into\n %% a single select_val instruction.\n\n case Vop@1 =:= '&' of\n true ->\n {non_associative,30};\n false ->\n case\n case Vop@1 =:= '^' of\n true ->\n true;\n false ->\n case Vop@1 =:= 'not' of\n true ->\n true;\n false ->\n case Vop@1 =:= '+' of\n true ->\n true;\n false ->\n case Vop@1 =:= '-' of\n true ->\n true;\n false ->\n case Vop@1 =:= '~~~' of\n true ->\n true;\n false ->\n Vop@1 =:= '!'\n end\n end\n end\n end\n end\n of\n true ->\n {non_associative,300};\n false ->\n case Vop@1 =:= '@' of\n true ->\n {non_associative,320};\n false ->\n error\n end\n end\n end.\n\neq_types(_Config) ->\n Ref = make_ref(),\n Ref = eq_types(Ref, any),\n ok.\n\neq_types(A, B) ->\n %% {put_tuple2,{y,0},{list,[{x,0},{x,1}]}}.\n Term0 = {A, B},\n Term = id(Term0),\n\n %% {test,is_eq_exact,{f,3},[{y,0},{x,0}]}.\n %% Here beam_validator must infer that {x,0} has the\n %% same type as {y,0}.\n Term = Term0,\n\n %% {get_tuple_element,{x,0},0,{x,0}}.\n {Ref22,_} = Term,\n\n Ref22.\n\nmatch_after_return(Config) when is_list(Config) ->\n %% The return type of the following call will never match the 'wont_happen'\n %% clauses below, and the beam_ssa_type was clever enough to see that but\n %% didn't remove the blocks, so it crashed when trying to extract A.\n ok = case mar_test_tuple(erlang:unique_integer()) of\n {gurka, never_matches, A} -> {wont_happen, A};\n _ -> ok\n end.\n\nmar_test_tuple(I) -> {gurka, I}.\n\nmatch_right_tuple(Config) when is_list(Config) ->\n %% The loader wrongly coalesced certain get_tuple_element sequences, fusing\n %% the code below into a single i_get_tuple_element2 operating on {x,0}\n %% even though the first one overwrites it.\n %%\n %% {get_tuple_element,{x,0},0,{x,0}}.\n %% {get_tuple_element,{x,0},1,{x,1}}.\n\n Inner = {id(wrong_element), id(ok)},\n Outer = {Inner, id(wrong_tuple)},\n ok = match_right_tuple_1(Outer).\n\nmatch_right_tuple_1(T) ->\n {A, _} = T,\n {_, B} = A,\n %% The call ensures that A is in {x,0} and B is in {x,1}\n id(force_succ_regs(A, B)).\n\nforce_succ_regs(_A, B) -> B.\n\ntuple_size_in_try(Config) when is_list(Config) ->\n %% The tuple_size optimization was applied outside of guards, causing\n %% either the emulator or compiler to crash.\n ok = tsit(gurka),\n ok = tsit(gaffel).\n\ntsit(A) ->\n try\n id(ignored),\n 1 = tuple_size(A),\n error\n catch\n _:_ -> ok\n end.\n\nmatch_boolean_list(Config) when is_list(Config) ->\n BoolList = [N rem 2 =:= 0 || N <- lists:seq(1, 8)],\n %% The compiler knows that all list elements are booleans, so it translates\n %% the expression below to a #b_br{} on the list head.\n %%\n %% This is fine, but since the value was only used in that branch,\n %% reserve_zregs/3 (pre_codegen) would place the variable in a z register,\n %% crashing the compiler in a later pass.\n ok = case BoolList of\n [true | _] -> error;\n [false | _] -> ok\n end.\n\nid(I) -> I.\n" }, { "path": "test_data/test.core", "content": "module 'test' ['add'/2,\n\t 'add_two'/3,\n\t 'module_info'/0,\n\t 'module_info'/1,\n\t 'return_closure'/1]\n attributes [%% Line 1\n\t\t'file' =\n\t\t %% Line 1\n\t\t [{[116|[101|[115|[116|[46|[101|[114|[108]]]]]]]],1}]]\n'add'/2 =\n %% Line 4\n fun (_@c1,_@c0) ->\n\t%% Line 5\n\tcall 'erlang':'+'\n\t (_@c1, _@c0)\n'add_two'/3 =\n %% Line 7\n fun (_@c2,_@c1,_@c0) ->\n\tlet =\n\t apply %% Line 8\n\t\t 'add'/2\n\t\t(_@c2, _@c1)\n\tin %% Line 9\n\t apply 'add'/2\n\t\t(I, _@c0)\n'return_closure'/1 =\n %% Line 11\n fun (_@c0) ->\n\t%% Line 12\n\t( fun (_@c1) ->\n\t %% Line 13\n\t apply 'add'/2\n\t\t (_@c0, _@c1)\n\t -| [{'id',{0,0,'-return_closure/1-fun-0-'}}] )\n'module_info'/0 =\n fun () ->\n\tcall 'erlang':'get_module_info'\n\t ('test')\n'module_info'/1 =\n fun (_@c0) ->\n\tcall 'erlang':'get_module_info'\n\t ('test', _@c0)\nend" }, { "path": "test_data/test.erl", "content": "-module(test).\n-export([add/2, add_two/3, return_closure/1]).\n\nadd(A, B) ->\n A + B.\n\nadd_two(A, B, C) ->\n I = add(A, B),\n add(I, C).\n\nreturn_closure(I) ->\n fun(A) ->\n add(I, A)\n end.\n" }, { "path": "test_data/testing.core", "content": "module 'test' ['add'/2,\n\t 'add_two'/3,\n\t 'module_info'/0,\n\t 'module_info'/1,\n\t 'return_closure'/1]\n attributes [%% Line 1\n\t\t'file' =\n\t\t %% Line 1\n\t\t [{[116|[101|[115|[116|[105|[110|[103|[46|[101|[114|[108]]]]]]]]]]],1}]]\n'add'/2 =\n %% Line 4\n fun (_1,_0) ->\n\t%% Line 5\n\tcall 'erlang':'+'\n\t (_1, _0)\n'add_two'/3 =\n %% Line 7\n fun (_2,_1,_0) ->\n\tlet =\n\t apply %% Line 8\n\t\t 'add'/2\n\t\t(_2, _1)\n\tin %% Line 9\n\t apply 'add'/2\n\t\t(I, _0)\n'return_closure'/1 =\n %% Line 11\n fun (_0) ->\n\t%% Line 12\n\t( fun (_1) ->\n\t %% Line 13\n\t apply 'add'/2\n\t\t (_0, _1)\n\t -| [{'id',{0,0,'-return_closure/1-fun-0-'}}] )\n'add_with_closure'/2 =\n %% Line 16\n fun (_1,_0) ->\n\tlet =\n\t apply %% Line 17\n\t\t 'return_closure'/1\n\t\t(_1)\n\tin %% Line 18\n\t apply F\n\t\t(_0)\n'matching'/2 =\n %% Line 20\n fun (_1,_0) ->\n\tcase <_1,_0> of\n\t <[],[]> when 'true' ->\n\t %% Line 21\n\t 'one'\n\t %% Line 22\n\t <[],_4> when 'true' ->\n\t %% Line 23\n\t 'two'\n\t %% Line 24\n\t <_5,[]> when 'true' ->\n\t %% Line 25\n\t 'three'\n\t %% Line 26\n\t when 'true' ->\n\t %% Line 27\n\t {A,B}\n\tend\n'module_info'/0 =\n fun () ->\n\tcall 'erlang':'get_module_info'\n\t ('test')\n'module_info'/1 =\n fun (_0) ->\n\tcall 'erlang':'get_module_info'\n\t ('test', _0)\nend" }, { "path": "test_data/testing.erl", "content": "-module(test).\n-export([add/2, add_two/3, return_closure/1]).\n\nadd(A, B) ->\n A + B.\n\nadd_two(A, B, C) ->\n I = add(A, B),\n add(I, C).\n\nreturn_closure(I) ->\n fun(A) ->\n add(I, A)\n end.\n\nadd_with_closure(A, B) ->\n F = return_closure(A),\n F(B).\n\nmatching([], []) ->\n one;\nmatching([], _) ->\n two;\nmatching(_, []) ->\n three;\nmatching(A, B) ->\n {A, B}.\n\n" }, { "path": "tools/Cargo.toml", "content": "[package]\nname = \"tools\"\nversion = \"0.1.0\"\nauthors = [\"Hans Elias B. Josephsen \"]\nedition = \"2018\"\nlicense = \"MIT OR Apache-2.0\"\n\n[[bin]]\nname = \"eir_compile\"\npath = \"src/compile.rs\"\n\n[dependencies]\nlibeir_diagnostics = { path = \"../libeir_diagnostics\" }\nlibeir_syntax_erl = { path = \"../libeir_syntax_erl\" }\nlibeir_passes = { path = \"../libeir_passes\" }\nlibeir_ir = { path = \"../libeir_ir\" }\nlibeir_util_parse = { path = \"../util/libeir_util_parse\" }\nlibeir_util_parse_listing = { path = \"../util/libeir_util_parse_listing\" }\n\nlibeir_frontend = { path = \"../libeir_frontend\" }\n\nclap = \"2.33.0\"\nlog = \"0.4\"\nfern = \"0.5\"\n" }, { "path": "tools/src/compile.rs", "content": "use std::io::Write;\nuse std::path::{Path, PathBuf};\nuse std::sync::Arc;\n\nuse clap::{arg_enum, value_t, values_t, App, Arg, ArgMatches};\n\nuse libeir_diagnostics::term::{\n self,\n termcolor::{ColorChoice, StandardStream},\n};\nuse libeir_diagnostics::CodeMap;\nuse libeir_frontend::{\n abstr_erlang::AbstrErlangFrontend, eir::EirFrontend, erlang::ErlangFrontend, AnyFrontend,\n DynFrontend,\n};\nuse libeir_ir::FunctionIdent;\nuse libeir_passes::PassManager;\n\narg_enum! {\n #[derive(Debug, PartialEq, Eq)]\n pub enum OutputType {\n Eir,\n Dot,\n }\n}\n\narg_enum! {\n #[derive(Debug, PartialEq, Eq)]\n pub enum InputType {\n Eir,\n Abstr,\n Erl,\n }\n}\n\narg_enum! {\n #[derive(Debug)]\n pub enum CompileLevel {\n High,\n Normal,\n Custom,\n }\n}\n\narg_enum! {\n #[derive(Debug)]\n pub enum CompilePass {\n CompilePatterns,\n SimplifyCfg,\n NaiveInlineClosures,\n Validate,\n }\n}\n\narg_enum! {\n #[derive(Debug, Copy, Clone)]\n pub enum LogLevel {\n Error,\n Warn,\n Info,\n Debug,\n Trace,\n }\n}\nimpl LogLevel {\n pub fn to_filter(self) -> log::LevelFilter {\n match self {\n LogLevel::Error => log::LevelFilter::Error,\n LogLevel::Warn => log::LevelFilter::Warn,\n LogLevel::Info => log::LevelFilter::Info,\n LogLevel::Debug => log::LevelFilter::Debug,\n LogLevel::Trace => log::LevelFilter::Trace,\n }\n }\n}\n\nfn make_erlang_frontend(codemap: Arc, matches: &ArgMatches) -> ErlangFrontend {\n use libeir_syntax_erl::ParseConfig;\n\n let mut config = ParseConfig::default();\n\n if let Some(includes) = matches.values_of(\"INCLUDE_PATHS\") {\n for include in includes {\n config.include_paths.push_front(PathBuf::from(include));\n }\n }\n if let Some(includes) = matches.values_of(\"CODE_PATHS\") {\n for include in includes {\n config.code_paths.push_front(PathBuf::from(include));\n }\n }\n\n ErlangFrontend::new(config, codemap)\n}\n\nfn make_frontend(codemap: Arc, matches: &ArgMatches) -> AnyFrontend {\n match value_t!(matches, \"IN_FORMAT\", InputType).unwrap() {\n InputType::Erl => make_erlang_frontend(codemap, matches).into(),\n InputType::Abstr => AbstrErlangFrontend::new(codemap).into(),\n InputType::Eir => EirFrontend::new(codemap).into(),\n }\n}\n\nfn setup_logger(level: log::LevelFilter) {\n fern::Dispatch::new()\n .format(|out, message, record| {\n out.finish(format_args!(\n \"[{}][{}] {}\",\n record.target(),\n record.level(),\n message\n ))\n })\n .level(level)\n .chain(std::io::stdout())\n .apply()\n .unwrap();\n}\n\nfn main() {\n let matches = App::new(\"Eir Compiler CLI\")\n .version(\"alpha\")\n .author(\"Hans Elias B. Josephsen\")\n .about(\"CLI interface to various Eir compiler functionality\")\n .arg(\n Arg::with_name(\"IN_FILE\")\n .help(\"Input file for compiler\")\n .required(true),\n )\n .arg(\n Arg::from_usage(\" -f,--in-format 'input format'\")\n .default_value(\"erl\")\n .required(true)\n .case_insensitive(true)\n .possible_values(&InputType::variants()),\n )\n .arg(\n Arg::from_usage(\" -p,--out-format 'output format'\")\n .default_value(\"eir\")\n .required(true)\n .case_insensitive(true)\n .possible_values(&OutputType::variants()),\n )\n .arg(\n Arg::from_usage(\" -i,--ident 'select single function'\")\n .required(false),\n )\n .arg(Arg::from_usage(\" -o,--output 'output file'\").required(false))\n .arg(Arg::from_usage(\"-s,--to-stdout 'outputs to stdout'\"))\n .arg(Arg::from_usage(\" --run-dot \").required(false))\n .arg(\n Arg::from_usage(\n \" -l,--compile-level 'compilation level'\",\n )\n .default_value(\"normal\")\n .required(false)\n .case_insensitive(true)\n .possible_values(&CompileLevel::variants()),\n )\n .arg(Arg::from_usage(\n \"[ANNOTATE_LIVE] --annotate-live 'annotate calculated live variables in ir\",\n ))\n .arg(\n Arg::from_usage(\n \" -I 'add include path for the erlang preprocessor'\",\n )\n .required(false)\n .multiple(true),\n )\n .arg(\n Arg::from_usage(\n \" -C 'add code path for the erlang preprocessor'\",\n )\n .required(false)\n .multiple(true),\n )\n .arg(\n Arg::from_usage(\" --pass 'run the given compilation pass'\")\n .required(false)\n .multiple(true)\n .number_of_values(1)\n .possible_values(&CompilePass::variants()),\n )\n .arg(\n Arg::from_usage(\" -L,--log-level 'log level'\")\n .default_value(\"info\")\n .required(false)\n .case_insensitive(true)\n .possible_values(&LogLevel::variants()),\n )\n .get_matches();\n\n setup_logger(\n value_t!(matches, \"LOG_LEVEL\", LogLevel)\n .unwrap()\n .to_filter(),\n );\n\n let codemap = Arc::new(CodeMap::new());\n let frontend = make_frontend(codemap.clone(), &matches);\n\n let in_file_name = matches.value_of(\"IN_FILE\").unwrap();\n let in_file_path = Path::new(in_file_name);\n\n let (eir_res, diagnostics) = frontend.parse_file_dyn(&in_file_path);\n {\n let term_config = term::Config::default();\n let mut out = StandardStream::stderr(ColorChoice::Auto);\n for diag in diagnostics.iter() {\n term::emit(&mut out, &term_config, &*codemap, diag).unwrap();\n }\n }\n\n if eir_res.is_err() {\n return;\n }\n let mut eir = eir_res.unwrap();\n\n match value_t!(matches, \"COMPILE_LEVEL\", CompileLevel).unwrap() {\n CompileLevel::High => {}\n CompileLevel::Normal => {\n let mut pass_manager = PassManager::default();\n pass_manager.run(&mut eir);\n }\n CompileLevel::Custom => {\n let mut pass_manager = PassManager::new();\n if matches.is_present(\"PASSES\") {\n for pass_type in values_t!(matches.values_of(\"PASSES\"), CompilePass).unwrap() {\n match pass_type {\n CompilePass::CompilePatterns => {\n pass_manager\n .push_function_pass(libeir_passes::CompilePatternPass::new());\n }\n CompilePass::SimplifyCfg => {\n pass_manager.push_function_pass(libeir_passes::SimplifyCfgPass::new());\n }\n CompilePass::NaiveInlineClosures => {\n pass_manager\n .push_function_pass(libeir_passes::NaiveInlineClosuresPass::new());\n }\n CompilePass::Validate => {\n pass_manager.push_function_pass(libeir_passes::ValidatePass::new());\n }\n }\n }\n }\n pass_manager.run(&mut eir);\n }\n }\n\n let selected_function = matches\n .value_of(\"FUN_IDENT\")\n .map(|val| FunctionIdent::parse_with_module(val, eir.name().clone()).unwrap());\n\n //if matches.is_present(\"ANNOTATE_LIVE\") {\n // print_ctx.add_annotator(EirLiveValuesAnnotator::new());\n //}\n\n let out_data;\n let out_ext;\n let out_type = value_t!(matches, \"OUT_FORMAT\", OutputType).unwrap();\n match out_type {\n OutputType::Eir => {\n if let Some(selected) = selected_function {\n out_data = eir[&selected].function().to_text_standard();\n } else {\n out_data = eir.to_text_standard();\n }\n out_ext = \"eir\";\n }\n OutputType::Dot => {\n let selected_function =\n selected_function.expect(\"Expected function ident with -i \");\n let fun_def = &eir[&selected_function];\n let fun = fun_def.function();\n\n out_data = ::libeir_ir::text::function_to_dot(&fun);\n\n out_ext = \"dot\";\n }\n }\n\n let out_file_name = matches\n .value_of(\"OUT_FILE\")\n .map(|s| s.to_string())\n .unwrap_or_else(|| format!(\"{}.{}\", in_file_name, out_ext));\n\n println!(\"Writing to {}\", out_file_name);\n let mut out = ::std::fs::File::create(&out_file_name).unwrap();\n out.write(out_data.as_bytes()).unwrap();\n\n if let Some(dot_format) = matches.value_of(\"DOT_FORMAT\") {\n assert!(out_type == OutputType::Dot);\n println!(\"Running dot...\");\n\n let format_str = format!(\"-T{}\", dot_format);\n let res = std::process::Command::new(\"dot\")\n .arg(&format_str)\n .arg(\"-O\")\n .arg(&out_file_name)\n .output()\n .expect(\"Failed to run dot\");\n assert!(res.status.success(), \"Failed to run dot\");\n }\n}\n" }, { "path": "util/any_map/Cargo.toml", "content": "[package]\nname = \"any_map\"\nversion = \"0.1.0\"\nauthors = [\"Hans Elias B. Josephsen \"]\nedition = \"2018\"\n\n# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html\n\n[dependencies]\nfnv = \"1.0.3\"\nhashbrown = { git = \"https://github.com/rust-lang/hashbrown.git\", features = [\"raw\", \"nightly\"] }\n" }, { "path": "util/any_map/src/any_any_map.rs", "content": "use crate::{AnyMap, DefaultBuildHasher};\nuse std::alloc::{Allocator, Global};\nuse std::any::Any;\nuse std::hash::{BuildHasher, Hash};\n\npub trait AnyKey: Clone + Hash + Eq + 'static {\n type Value: Clone + 'static;\n}\n\ntrait AnyValueTrait {\n fn clone(&self) -> Box;\n}\nimpl AnyValueTrait for T\nwhere\n T: Clone + Any,\n{\n fn clone(&self) -> Box {\n Box::new(Clone::clone(self))\n }\n}\n\npub struct AnyAnyMap\nwhere\n A: Allocator + Clone,\n{\n inner: AnyMap, S, A>,\n}\n\nimpl Default for AnyAnyMap\nwhere\n S: Default,\n A: Default + Allocator + Clone,\n{\n fn default() -> Self {\n AnyAnyMap {\n inner: Default::default(),\n }\n }\n}\n\nimpl AnyAnyMap {\n pub fn new() -> Self {\n Default::default()\n }\n}\n\nimpl AnyAnyMap\nwhere\n A: Allocator + Clone,\n S: BuildHasher,\n{\n pub fn insert(&mut self, k: K, v: K::Value) -> Option\n where\n K: AnyKey,\n {\n let ret = self.inner.insert(k, Box::new(v));\n ret.map(|v| *v.downcast().unwrap())\n }\n\n pub fn get(&self, k: &K) -> Option<&K::Value> {\n self.inner.get(k).map(|v| v.downcast_ref().unwrap())\n }\n\n pub fn get_mut(&mut self, k: &K) -> Option<&mut K::Value> {\n self.inner.get_mut(k).map(|v| v.downcast_mut().unwrap())\n }\n}\n" }, { "path": "util/any_map/src/any_map.rs", "content": "use fnv::FnvBuildHasher;\nuse hashbrown::raw::RawTable;\nuse std::alloc::{Allocator, Global};\nuse std::any::{Any, TypeId};\nuse std::hash::{BuildHasher, Hash, Hasher};\nuse std::mem;\n\npub type DefaultBuildHasher = FnvBuildHasher;\n\ntrait AnyKeyTrait: 'static {\n fn clone(&self) -> Box;\n fn type_id(&self) -> TypeId;\n}\nimpl AnyKeyTrait for T\nwhere\n T: Clone + Any,\n{\n fn clone(&self) -> Box {\n Box::new(Clone::clone(self))\n }\n fn type_id(&self) -> TypeId {\n Any::type_id(self)\n }\n}\nimpl dyn AnyKeyTrait {\n fn is(&self) -> bool {\n let t = TypeId::of::();\n let st = self.type_id();\n t == st\n }\n fn downcast_ref<'a, T: Any>(&'a self) -> Option<&'a T> {\n if self.is::() {\n unsafe { Some(&*(self as *const dyn AnyKeyTrait as *const T)) }\n } else {\n None\n }\n }\n}\n\nfn make_hash(hash_builder: &impl BuildHasher, val: &K) -> u64 {\n let mut state = hash_builder.build_hasher();\n val.hash(&mut state);\n state.finish()\n}\n\nfn make_eq(k: &Q) -> impl Fn(&(AnyKey, V)) -> bool + '_\nwhere\n Q: Eq + 'static,\n{\n move |x| x.0.eq_k(k)\n}\n\nstruct AnyKey {\n key: Box,\n hash: u64,\n}\nimpl Clone for AnyKey {\n fn clone(&self) -> Self {\n AnyKey {\n key: AnyKeyTrait::clone(&*self.key),\n hash: self.hash,\n }\n }\n}\n\nimpl AnyKey {\n pub fn new(k: K, hb: &S) -> Self\n where\n K: AnyKeyTrait + Hash + 'static,\n S: BuildHasher,\n {\n AnyKey {\n hash: make_hash(hb, &k),\n key: Box::new(k),\n }\n }\n\n pub fn eq_k(&self, k: &K) -> bool\n where\n K: Eq + 'static,\n {\n if let Some(inner) = self.key.downcast_ref::() {\n inner == k\n } else {\n false\n }\n }\n}\n\npub struct AnyMap\nwhere\n A: Allocator + Clone,\n{\n hash_builder: S,\n table: RawTable<(AnyKey, V), A>,\n}\n\nimpl Default for AnyMap\nwhere\n S: Default,\n A: Default + Allocator + Clone,\n{\n fn default() -> Self {\n AnyMap {\n hash_builder: S::default(),\n table: RawTable::new_in(A::default()),\n }\n }\n}\n\nfn get_hash(data: &(AnyKey, V)) -> u64 {\n data.0.hash\n}\n\nimpl AnyMap {\n pub fn new() -> Self {\n Default::default()\n }\n}\n\nimpl AnyMap\nwhere\n S: BuildHasher,\n A: Allocator + Clone,\n{\n pub fn insert(&mut self, k: K, v: V) -> Option\n where\n K: Clone + Eq + Hash + 'static,\n {\n let hash = make_hash(&self.hash_builder, &k);\n if let Some((_, item)) = self.table.get_mut(hash, make_eq(&k)) {\n Some(mem::replace(item, v))\n } else {\n let key = AnyKey::new(k, &self.hash_builder);\n self.table.insert(hash, (key, v), get_hash);\n None\n }\n }\n\n pub fn get(&self, k: &K) -> Option<&V>\n where\n K: Eq + Hash + 'static,\n {\n let hash = make_hash(&self.hash_builder, k);\n match self.table.get(hash, make_eq(k)) {\n Some(&(_, ref v)) => Some(v),\n None => None,\n }\n }\n\n pub fn get_mut(&mut self, k: &K) -> Option<&mut V>\n where\n K: Eq + Hash + 'static,\n {\n let hash = make_hash(&self.hash_builder, k);\n match self.table.get_mut(hash, make_eq(k)) {\n Some(&mut (_, ref mut v)) => Some(v),\n None => None,\n }\n }\n}\n\n#[cfg(test)]\nmod tests {\n use super::AnyMap;\n\n #[test]\n fn simple_usage() {\n let mut map = AnyMap::new();\n\n map.insert(12, 5);\n assert!(*map.get(&12).unwrap() == 5);\n\n #[derive(Clone, Hash, PartialEq, Eq)]\n struct MyKey;\n map.insert(MyKey, 55);\n assert!(*map.get(&MyKey).unwrap() == 55);\n\n assert!(*map.get(&12).unwrap() == 5);\n\n for n in 0..1000 {\n map.insert(n, n);\n }\n for n in 0..1000 {\n assert!(*map.get(&n).unwrap() == n);\n }\n\n assert!(*map.get(&MyKey).unwrap() == 55);\n\n #[derive(Clone, Hash, PartialEq, Eq)]\n struct MyKeyI(usize);\n\n map.insert(MyKeyI(12), 15);\n assert!(*map.get(&MyKeyI(12)).unwrap() == 15);\n assert!(*map.get(&12).unwrap() == 12);\n\n assert!(map.get(&&12).is_none());\n }\n}\n" }, { "path": "util/any_map/src/lib.rs", "content": "#![feature(allocator_api)]\n\nmod any_map;\npub use crate::any_map::{AnyMap, DefaultBuildHasher};\n\nmod any_any_map;\npub use crate::any_any_map::{AnyAnyMap, AnyKey};\n" }, { "path": "util/libeir_etf/Cargo.toml", "content": "[package]\nname = \"libeir_etf\"\nversion = \"0.1.0\"\nauthors = [\"Hans Elias B. Josephsen \"]\nedition = \"2018\"\n\n# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html\n\n[dependencies]\nbyteorder = \"1.3\"\nnum-bigint = { git = \"https://github.com/hansihe/num-bigint.git\" }\nsnafu = \"0.5\"\nlibeir_intern = { path = \"../../libeir_intern\" }\n" }, { "path": "util/libeir_etf/src/constants.rs", "content": "#[allow(dead_code)]\npub mod tag {\n pub const ATOM_CACHE_REF: u8 = 82;\n /// Unsigned 8-bit integer\n pub const SMALL_INTEGER_EXT: u8 = 97;\n /// Signed 32-bit integer in big-endian format\n pub const INTEGER_EXT: u8 = 98;\n /// DEPRECATED\n /// Float stored as string\n pub const FLOAT_EXT: u8 = 99;\n /// (node:atom), (id:u32be as u28) (creation:u8 as u2)\n pub const PORT_EXT: u8 = 102;\n /// (node:atom), (id:u32be as u28) (creation:u32be)\n pub const NEW_PORT_EXT: u8 = 89;\n /// (node:atom), (id:u32be as u15) (serial:u32be as u13) (creation:u8 as u2)\n pub const PID_EXT: u8 = 103;\n /// (node:atom), (id:u32be as u15) (serial:u32be as u13) (creation:u32be)\n pub const NEW_PID_EXT: u8 = 88;\n /// (arity:u8), elements..\n pub const SMALL_TUPLE_EXT: u8 = 104;\n /// (arity:u32be), elements..\n pub const LARGE_TUPLE_EXT: u8 = 105;\n /// (arity:u32be), (key, value)..\n /// Duplicate keys not allowed.\n pub const MAP_EXT: u8 = 116;\n /// only tag\n pub const NIL_EXT: u8 = 106;\n /// (length:u16be), (chars:u8)..\n pub const STRING_EXT: u8 = 107;\n /// (length:u32be), (elements).., (tail)\n pub const LIST_EXT: u8 = 108;\n /// (length:u32be), (data)..\n pub const BINARY_EXT: u8 = 109;\n /// (data_len:u8), (is_neg:u8 as bool), (u8)..\n /// B = 256\n /// (d0*B^0 + d1*B^1 + d2*B^2 + ... d(N-1)*B^(n-1))\n pub const SMALL_BIG_EXT: u8 = 110;\n /// (data_len:u32be), (is_neg:u8 as bool), (u8)..\n /// Otherwise same as small\n pub const LARGE_BIG_EXT: u8 = 111;\n /// (id_len:u16be <= 3) (node:atom) (creation:u32be) (id:u32be)..\n pub const NEWER_REFERENCE_EXT: u8 = 90;\n /// (num_free:u32be) (pid:pid) (module:atom) (index:integer) (uniq:integer) (free)..\n /// uniq is parse hash\n pub const FUN_EXT: u8 = 117;\n /// (size:u32be) (arity:u8) (uniq:u128be) (index:u32be) (num_free:u32be) (module:atom)\n /// (old_index:integer) (old_uniq:integer) (pid:pid) (free)..\n /// size including itself\n pub const NEW_FUN_EXT: u8 = 112;\n /// (module:atom) (function:atom) (arity:small_integer_ext)\n pub const EXPORT_EXT: u8 = 113;\n /// (len:u32be) (bits:u8 <= 7) bytes..\n pub const BIT_BINARY_EXT: u8 = 77;\n /// (num:f32)\n pub const NEW_FLOAT_EXT: u8 = 70;\n /// (len:u16be) name_bytes..\n /// latin1\n pub const ATOM_EXT: u8 = 100;\n /// (len:u8) name_bytes..\n /// latin1\n pub const SMALL_ATOM_EXT: u8 = 115;\n /// (len:u16be) name_bytes..\n pub const ATOM_UTF8_EXT: u8 = 118;\n /// (len:u8) name_bytes..\n pub const SMALL_ATOM_UTF8_EXT: u8 = 119;\n}\n" }, { "path": "util/libeir_etf/src/decoder.rs", "content": "use crate::{RawTag, Reader};\nuse std::io::Read;\n\nuse snafu::{ResultExt, Snafu};\n\n#[derive(Debug, Snafu)]\npub enum DecodeError {\n #[snafu(display(\"error from source: {}\", source))]\n Source { source: std::io::Error },\n\n #[snafu(display(\"tried to decode bad data\"))]\n BadData,\n}\n\npub trait Decoder: Sized {\n fn decode(reader: &mut Reader) -> Result;\n}\n\nmacro_rules! impl_tuple_decoder {\n ($count:expr, ($($typ:ident),*)) => {\n impl<$($typ: Decoder, )*> Decoder for ($($typ, )*) {\n fn decode(reader: &mut Reader) -> Result {\n if let RawTag::Tuple { arity } = reader.raw_tag().context(Source)? {\n if arity == $count {\n return Ok((\n $(<$typ as Decoder>::decode(reader)?,)*\n ));\n }\n }\n Err(DecodeError::BadData)\n }\n }\n };\n}\n\nimpl_tuple_decoder!(0, ());\nimpl_tuple_decoder!(1, (A));\nimpl_tuple_decoder!(2, (A, B));\nimpl_tuple_decoder!(3, (A, B, C));\nimpl_tuple_decoder!(4, (A, B, C, D));\nimpl_tuple_decoder!(5, (A, B, C, D, E));\nimpl_tuple_decoder!(6, (A, B, C, D, E, F));\nimpl_tuple_decoder!(7, (A, B, C, D, E, F, G));\nimpl_tuple_decoder!(8, (A, B, C, D, E, F, G, H));\nimpl_tuple_decoder!(9, (A, B, C, D, E, F, G, H, I));\nimpl_tuple_decoder!(10, (A, B, C, D, E, F, G, H, I, J));\n\nmacro_rules! ignore {\n {$a:tt} => {};\n}\n\n#[macro_export]\nmacro_rules! impl_record {\n ($struct:ident, $name:expr, {$($field:ident),*}) => {\n impl Decoder for $name {\n fn decode(reader: &mut Reader) -> Result {\n let num_fields = 1 $(+ 1 ignore!($field))*;\n if let RawTag::Tuple { arity } = reader.raw_tag().context(Source)? {\n if arity == num_fields {\n }\n }\n Err(DecodeError::BadData)\n }\n }\n };\n}\n" }, { "path": "util/libeir_etf/src/encoder.rs", "content": "use crate::{Term, Writer};\nuse num_bigint::BigInt;\nuse std::collections::{BTreeMap, HashMap};\nuse std::convert::TryInto;\nuse std::io::{Result, Write};\n\npub trait Encoder {\n fn encode(&self, writer: &mut Writer) -> Result<()>;\n}\n\nimpl Encoder for Term {\n fn encode(&self, writer: &mut Writer) -> Result<()> {\n writer.term(self)\n }\n}\n\nimpl Encoder for libeir_intern::Symbol {\n fn encode(&self, writer: &mut Writer) -> Result<()> {\n writer.atom(&self.as_str())\n }\n}\n\nimpl Encoder for &T {\n fn encode(&self, writer: &mut Writer) -> Result<()> {\n ::encode(*self, writer)\n }\n}\n\n#[derive(Debug, Copy, Clone)]\npub struct A<'a>(pub &'a str);\nimpl Encoder for A<'_> {\n fn encode(&self, writer: &mut Writer) -> Result<()> {\n writer.atom(self.0)\n }\n}\n\nmacro_rules! impl_tuple_encoder {\n\t($count:expr, ($(($typ:ident, $name:ident)),*)) => {\n impl<$($typ: Encoder, )*> Encoder for ($($typ, )*) {\n fn encode(&self, writer: &mut Writer) -> Result<()> {\n writer.tuple($count)?;\n\n let ($($name,)*) = self;\n $(\n $name.encode(writer)?;\n )*\n\n writer.pop();\n Ok(())\n }\n }\n\t};\n}\n\nimpl_tuple_encoder!(0, ());\nimpl_tuple_encoder!(1, ((A, a)));\nimpl_tuple_encoder!(2, ((A, a), (B, b)));\nimpl_tuple_encoder!(3, ((A, a), (B, b), (C, c)));\nimpl_tuple_encoder!(4, ((A, a), (B, b), (C, c), (D, d)));\nimpl_tuple_encoder!(5, ((A, a), (B, b), (C, c), (D, d), (E, e)));\nimpl_tuple_encoder!(6, ((A, a), (B, b), (C, c), (D, d), (E, e), (F, f)));\nimpl_tuple_encoder!(7, ((A, a), (B, b), (C, c), (D, d), (E, e), (F, f), (G, g)));\nimpl_tuple_encoder!(\n 8,\n (\n (A, a),\n (B, b),\n (C, c),\n (D, d),\n (E, e),\n (F, f),\n (G, g),\n (H, h)\n )\n);\nimpl_tuple_encoder!(\n 9,\n (\n (A, a),\n (B, b),\n (C, c),\n (D, d),\n (E, e),\n (F, f),\n (G, g),\n (H, h),\n (I, i)\n )\n);\nimpl_tuple_encoder!(\n 10,\n (\n (A, a),\n (B, b),\n (C, c),\n (D, d),\n (E, e),\n (F, f),\n (G, g),\n (H, h),\n (I, i),\n (J, j)\n )\n);\n\n//impl Encoder for T\n//where\n// T: crate::writer::WritableInteger,\n//{\n// fn encode(&self, writer: &mut Writer) -> Result<()> {\n// writer.integer(self)\n// }\n//}\n\nimpl Encoder for HashMap {\n fn encode(&self, writer: &mut Writer) -> Result<()> {\n let len = self.len();\n writer.map(len)?;\n\n for (k, v) in self.iter() {\n k.encode(writer)?;\n v.encode(writer)?;\n writer.next_kv();\n }\n\n writer.pop();\n Ok(())\n }\n}\nimpl Encoder for BTreeMap {\n fn encode(&self, writer: &mut Writer) -> Result<()> {\n let len = self.len();\n writer.map(len)?;\n\n for (k, v) in self.iter() {\n k.encode(writer)?;\n v.encode(writer)?;\n writer.next_kv();\n }\n\n writer.pop();\n Ok(())\n }\n}\n\nimpl Encoder for BigInt {\n fn encode(&self, writer: &mut Writer) -> Result<()> {\n writer.integer_big(self)\n }\n}\nimpl Encoder for u8 {\n fn encode(&self, writer: &mut Writer) -> Result<()> {\n writer.raw_small_integer_ext(*self)\n }\n}\nimpl Encoder for i8 {\n fn encode(&self, writer: &mut Writer) -> Result<()> {\n writer.raw_integer_ext(*self as i32)\n }\n}\nimpl Encoder for u16 {\n fn encode(&self, writer: &mut Writer) -> Result<()> {\n writer.raw_integer_ext(*self as i32)\n }\n}\nimpl Encoder for i16 {\n fn encode(&self, writer: &mut Writer) -> Result<()> {\n writer.raw_integer_ext(*self as i32)\n }\n}\nimpl Encoder for u32 {\n fn encode(&self, writer: &mut Writer) -> Result<()> {\n if let Ok(num) = (*self).try_into() {\n writer.raw_integer_ext(num)\n } else {\n unimplemented!()\n }\n }\n}\nimpl Encoder for i32 {\n fn encode(&self, writer: &mut Writer) -> Result<()> {\n writer.raw_integer_ext(*self)\n }\n}\nimpl Encoder for u64 {\n fn encode(&self, writer: &mut Writer) -> Result<()> {\n if let Ok(num) = (*self).try_into() {\n writer.raw_integer_ext(num)\n } else {\n unimplemented!()\n }\n }\n}\nimpl Encoder for i64 {\n fn encode(&self, writer: &mut Writer) -> Result<()> {\n if let Ok(num) = (*self).try_into() {\n writer.raw_integer_ext(num)\n } else {\n unimplemented!()\n }\n }\n}\nimpl Encoder for usize {\n fn encode(&self, writer: &mut Writer) -> Result<()> {\n if let Ok(num) = (*self).try_into() {\n writer.raw_integer_ext(num)\n } else {\n unimplemented!()\n }\n }\n}\nimpl Encoder for isize {\n fn encode(&self, writer: &mut Writer) -> Result<()> {\n if let Ok(num) = (*self).try_into() {\n writer.raw_integer_ext(num)\n } else {\n unimplemented!()\n }\n }\n}\n\npub struct List + Copy, I: Encoder, T: Encoder>(pub H, pub usize, pub T);\nimpl + Copy, I: Encoder, T: Encoder> Encoder for List {\n fn encode(&self, writer: &mut Writer) -> Result<()> {\n writer.list(self.1)?;\n\n for entry in self.0.into_iter() {\n entry.encode(writer)?;\n }\n\n writer.next_tail();\n self.2.encode(writer)?;\n\n writer.pop();\n Ok(())\n }\n}\n" }, { "path": "util/libeir_etf/src/lib.rs", "content": "mod constants;\n\nmod writer;\npub use writer::Writer;\n\nmod reader;\npub use reader::{RawTag, Reader};\n\nmod term;\npub use term::Term;\n\nmod encoder;\npub use encoder::{Encoder, List, A};\n\nmod decoder;\npub use decoder::Decoder;\n\n#[cfg(test)]\nmod test;\n" }, { "path": "util/libeir_etf/src/reader.rs", "content": "use crate::term::Term;\nuse byteorder::{BigEndian, ReadBytesExt};\nuse std::io::{Read, Result, Seek};\n\nuse super::constants::tag;\n\npub struct Reader {\n source: S,\n}\n\nimpl Reader {\n pub fn new(source: S) -> Self {\n Reader { source }\n }\n}\n\npub enum RawTag {\n AtomCacheRef {\n index: u8,\n },\n SmallIntegerExt {\n int: u8,\n },\n IntegerExt {\n int: i32,\n },\n FloatExt,\n PortExt,\n NewPortExt,\n PidExt,\n NewPidExt,\n Tuple {\n arity: u32,\n },\n MapExt {\n arity: u32,\n },\n NilExt,\n StringExt {\n length: u16,\n },\n ListExt {\n length: u32,\n },\n BinaryExt {\n length: u32,\n },\n SmallBigExt {\n data_len: u8,\n is_neg: bool,\n },\n LargeBigExt {\n data_len: u32,\n is_neg: bool,\n },\n NewerReferenceExt {\n id_len: u16,\n },\n FunExt {\n num_free: u32,\n },\n NewFunExt {\n size: u32,\n arity: u8,\n uniq: [u8; 16],\n index: u32,\n num_free: u32,\n },\n ExportExt,\n BitBinaryExt {\n length: u32,\n bits: u8,\n },\n NewFloatExt {\n num: f32,\n },\n Atom {\n len: u16,\n },\n AtomUtf8 {\n len: u16,\n },\n}\n\nmacro_rules! trace {\n ($target:expr) => {\n println!($target);\n };\n}\n\nimpl Reader {\n pub fn header(&mut self) -> Result<()> {\n let byte = self.source.read_u8()?;\n if byte != 131 {\n panic!(\"invalid header\");\n }\n Ok(())\n }\n\n pub fn raw_tag(&mut self) -> Result {\n let tag_int = self.source.read_u8()?;\n\n let res = match tag_int {\n tag::ATOM_CACHE_REF => {\n trace!(\"atom_cache_ref\");\n let index = self.source.read_u8()?;\n RawTag::AtomCacheRef { index }\n }\n tag::SMALL_INTEGER_EXT => {\n trace!(\"small_integer_ext\");\n let int = self.source.read_u8()?;\n RawTag::SmallIntegerExt { int }\n }\n tag::INTEGER_EXT => {\n trace!(\"integer_ext\");\n let int = self.source.read_i32::()?;\n RawTag::IntegerExt { int }\n }\n tag::FLOAT_EXT => {\n trace!(\"float_ext\");\n RawTag::FloatExt\n }\n tag::PORT_EXT => {\n trace!(\"port_ext\");\n RawTag::PortExt\n }\n tag::NEW_PORT_EXT => {\n trace!(\"new_port_ext\");\n RawTag::NewPortExt\n }\n tag::PID_EXT => {\n trace!(\"pid_ext\");\n RawTag::PidExt\n }\n tag::NEW_PID_EXT => {\n trace!(\"new_pid_ext\");\n RawTag::NewPidExt\n }\n tag::SMALL_TUPLE_EXT => {\n trace!(\"small_tuple_ext\");\n let arity = self.source.read_u8()?;\n RawTag::Tuple {\n arity: arity as u32,\n }\n }\n tag::LARGE_TUPLE_EXT => {\n trace!(\"large_tuple_ext\");\n let arity = self.source.read_u32::()?;\n RawTag::Tuple { arity }\n }\n tag::MAP_EXT => {\n trace!(\"map_ext\");\n let arity = self.source.read_u32::()?;\n RawTag::MapExt { arity }\n }\n tag::NIL_EXT => {\n trace!(\"nil_ext\");\n RawTag::NilExt\n }\n tag::STRING_EXT => {\n trace!(\"string_ext\");\n let length = self.source.read_u16::()?;\n RawTag::StringExt { length }\n }\n tag::LIST_EXT => {\n trace!(\"list_ext\");\n let length = self.source.read_u32::()?;\n RawTag::ListExt { length }\n }\n tag::BINARY_EXT => {\n trace!(\"binary_ext\");\n let length = self.source.read_u32::()?;\n RawTag::BinaryExt { length }\n }\n tag::SMALL_BIG_EXT => {\n trace!(\"small_big_ext\");\n let data_len = self.source.read_u8()?;\n let is_neg = self.source.read_u8()? == 1;\n RawTag::SmallBigExt { data_len, is_neg }\n }\n tag::LARGE_BIG_EXT => {\n trace!(\"large_big_ext\");\n let data_len = self.source.read_u32::()?;\n let is_neg = self.source.read_u8()? == 1;\n RawTag::LargeBigExt { data_len, is_neg }\n }\n tag::NEWER_REFERENCE_EXT => {\n trace!(\"newer_reference_ext\");\n let id_len = self.source.read_u16::()?;\n RawTag::NewerReferenceExt { id_len }\n }\n tag::FUN_EXT => {\n trace!(\"fun_ext\");\n let num_free = self.source.read_u32::()?;\n RawTag::FunExt { num_free }\n }\n tag::NEW_FUN_EXT => {\n trace!(\"new_fun_ext\");\n let size = self.source.read_u32::()?;\n let arity = self.source.read_u8()?;\n let mut uniq = [0u8; 16];\n self.source.read_exact(&mut uniq)?;\n let index = self.source.read_u32::()?;\n let num_free = self.source.read_u32::()?;\n RawTag::NewFunExt {\n size,\n arity,\n uniq,\n index,\n num_free,\n }\n }\n tag::EXPORT_EXT => {\n trace!(\"export_ext\");\n RawTag::ExportExt\n }\n tag::BIT_BINARY_EXT => {\n trace!(\"bit_binary_ext\");\n let length = self.source.read_u32::()?;\n let bits = self.source.read_u8()?;\n RawTag::BitBinaryExt { length, bits }\n }\n tag::NEW_FLOAT_EXT => {\n trace!(\"new_float_ext\");\n let num = self.source.read_f32::()?;\n RawTag::NewFloatExt { num }\n }\n tag::ATOM_EXT => {\n trace!(\"atom_ext\");\n let len = self.source.read_u16::()?;\n RawTag::Atom { len }\n }\n tag::SMALL_ATOM_EXT => {\n trace!(\"small_atom_ext\");\n let len = self.source.read_u8()?;\n RawTag::Atom { len: len as u16 }\n }\n tag::ATOM_UTF8_EXT => {\n trace!(\"atom_utf8_ext\");\n let len = self.source.read_u16::()?;\n RawTag::AtomUtf8 { len }\n }\n tag::SMALL_ATOM_UTF8_EXT => {\n trace!(\"small_atom_utf8_ext\");\n let len = self.source.read_u8()?;\n RawTag::AtomUtf8 { len: len as u16 }\n }\n tag => unreachable!(\"unknown tag {}\", tag),\n };\n Ok(res)\n }\n pub fn term(&mut self) -> Result {\n use RawTag::*;\n let res = match self.raw_tag()? {\n AtomUtf8 { len } => self.read_atom_term_utf8(len as usize)?,\n Atom { len } => self.read_atom_term_latin1(len as usize)?,\n SmallIntegerExt { int } => Term::Integer(int as i32),\n IntegerExt { int } => Term::Integer(int),\n NewFloatExt { num } => Term::Float(num),\n NilExt => Term::Nil,\n\n BinaryExt { length } => {\n let mut data = vec![0; length as usize];\n self.source.read_exact(&mut data[..])?;\n Term::Binary(data)\n }\n BitBinaryExt { length, bits } => {\n let mut data = vec![0; length as usize];\n self.source.read_exact(&mut data[..])?;\n Term::BitBinary(data, bits)\n }\n\n Tuple { arity } => {\n let terms = (0..arity).map(|_| self.term()).collect::>()?;\n Term::Tuple(terms)\n }\n MapExt { arity } => {\n let terms = (0..arity)\n .map(|_| Ok((self.term()?, self.term()?)))\n .collect::>()?;\n Term::Map(terms)\n }\n StringExt { length } => {\n let mut data = vec![0; length as usize];\n self.source.read_exact(&mut data[..])?;\n Term::ByteList(data)\n }\n ListExt { length } => {\n let head = (0..length).map(|_| self.term()).collect::>()?;\n let tail = self.term()?;\n Term::List(head, Box::new(tail))\n }\n\n _ => unimplemented!(),\n };\n Ok(res)\n }\n\n fn read_atom_term_latin1(&mut self, len: usize) -> Result {\n let mut data = vec![0; len];\n self.source.read_exact(&mut data[..])?;\n\n for byte in data.iter() {\n assert!(*byte < 128, \"TODO latin1 characters\");\n }\n\n match String::from_utf8(data) {\n Ok(string) => Ok(Term::Atom(string)),\n _ => unreachable!(),\n }\n }\n\n fn read_atom_term_utf8(&mut self, len: usize) -> Result {\n let mut data = vec![0; len];\n self.source.read_exact(&mut data[..])?;\n match String::from_utf8(data) {\n Ok(string) => Ok(Term::Atom(string)),\n _ => panic!(\"invalid atom\"),\n }\n }\n}\n" }, { "path": "util/libeir_etf/src/term.rs", "content": "use num_bigint::BigInt;\n\ntrait TermTypes {\n type Atom;\n}\n\n#[derive(Debug, PartialEq)]\npub enum Term {\n Integer(i32),\n Float(f32),\n Tuple(Vec),\n Map(Vec<(Term, Term)>),\n Nil,\n List(Vec, Box),\n ByteList(Vec),\n Binary(Vec),\n BitBinary(Vec, u8),\n BigInt(BigInt),\n Atom(String),\n}\n" }, { "path": "util/libeir_etf/src/test/mod.rs", "content": "use crate::{Reader, Term};\n\nmacro_rules! make_reader {\n ($var:ident = $path:expr) => {\n let bin = std::fs::read($path).unwrap();\n let mut cursor = std::io::Cursor::new(&bin);\n let mut $var = Reader::new(&mut cursor);\n };\n}\n\n#[test]\nfn int_tuple() {\n make_reader!(reader = \"test_data/int_tuple.etf\");\n\n reader.header().unwrap();\n let term = reader.term().unwrap();\n\n assert_eq!(\n term,\n Term::Tuple(vec![Term::Integer(1), Term::Integer(2), Term::Integer(3)])\n );\n}\n\n#[test]\nfn test_1() {\n make_reader!(reader = \"test_data/test_1.etf\");\n\n reader.header().unwrap();\n let term = reader.term().unwrap();\n\n assert_eq!(\n term,\n Term::List(\n vec![\n Term::Atom(\"hello\".into()),\n Term::Integer(1),\n Term::Nil,\n Term::Integer(2222)\n ],\n Box::new(Term::Nil)\n )\n );\n}\n\n#[test]\nfn test_2() {\n make_reader!(reader = \"test_data/test_2.etf\");\n\n reader.header().unwrap();\n let term = reader.term().unwrap();\n\n println!(\"{:?}\", term);\n}\n" }, { "path": "util/libeir_etf/src/writer.rs", "content": "use byteorder::{BigEndian, WriteBytesExt};\nuse num_bigint::{BigInt, Sign};\nuse std::convert::TryInto;\nuse std::io::{Result, Write};\n\nuse super::constants::tag;\nuse super::Term;\n\npub struct Writer {\n sink: S,\n state: Vec,\n}\n\n#[derive(Debug, Copy, Clone)]\nenum WriterState {\n RemainingTerms(usize),\n RemainingMap(usize, u8),\n RemainingList(usize),\n RemainingData(usize),\n}\nimpl WriterState {\n fn decr(&mut self) {\n match self {\n WriterState::RemainingTerms(n) if *n > 0 => *n -= 1,\n WriterState::RemainingMap(n, s) if *n > 0 && *s < 2 => *s += 1,\n WriterState::RemainingList(n) if *n > 0 => *n -= 1,\n _ => panic!(\"no term expected at current level\"),\n }\n }\n}\n\nimpl Writer {\n pub fn new(sink: S) -> Self {\n Writer {\n sink,\n state: vec![WriterState::RemainingTerms(1)],\n }\n }\n\n pub fn pop(&mut self) {\n match self.state.pop().expect(\"tried to pop empty stack\") {\n WriterState::RemainingTerms(0) => (),\n _ => panic!(\"tried to pop invalid state\"),\n }\n }\n\n pub fn next_kv(&mut self) {\n match self.state.last_mut().expect(\"tried to next on empty stack\") {\n WriterState::RemainingMap(0, _) => panic!(\"no map keys left\"),\n WriterState::RemainingMap(n, s @ 2) => {\n *n -= 1;\n *s = 0;\n }\n _ => panic!(\"tried to next on invalid state\"),\n }\n }\n\n pub fn next_tail(&mut self) {\n match self.state.last_mut().expect(\"tried to next on empty stack\") {\n a @ WriterState::RemainingList(0) => *a = WriterState::RemainingTerms(1),\n _ => panic!(\"tried to next on invalid state\"),\n }\n }\n}\n\n/// Generic\nimpl Writer {\n pub fn push_data(&mut self, data: &[u8]) -> Result<()> {\n let last_state = self.state.pop().unwrap();\n if let WriterState::RemainingData(mut rem) = last_state {\n assert!(rem <= data.len());\n rem -= data.len();\n if rem > 0 {\n self.state.push(WriterState::RemainingData(rem));\n }\n\n self.sink.write_all(data)\n } else {\n panic!()\n }\n }\n}\n\n/// Raw interface\nimpl Writer {\n pub fn raw_small_integer_ext(&mut self, int: u8) -> Result<()> {\n self.state.last_mut().unwrap().decr();\n self.sink.write_u8(tag::SMALL_INTEGER_EXT)?;\n self.sink.write_u8(int)\n }\n\n pub fn raw_integer_ext(&mut self, int: i32) -> Result<()> {\n self.state.last_mut().unwrap().decr();\n self.sink.write_u8(tag::INTEGER_EXT)?;\n self.sink.write_i32::(int)\n }\n\n pub fn raw_big_ext(&mut self, int: &BigInt) -> Result<()> {\n self.state.last_mut().unwrap().decr();\n\n let (sign, bytes) = int.to_bytes_be();\n let bytes_len = bytes.len();\n\n let sign_u8 = if sign == Sign::Minus { 1 } else { 0 };\n\n if let Ok(len) = bytes_len.try_into() {\n self.sink.write_u8(tag::SMALL_BIG_EXT)?;\n self.sink.write_u8(len)?;\n self.sink.write_u8(sign_u8)?;\n self.sink.write_all(&bytes)\n } else if let Ok(len) = bytes_len.try_into() {\n self.sink.write_u8(tag::LARGE_BIG_EXT)?;\n self.sink.write_u32::(len)?;\n self.sink.write_u8(sign_u8)?;\n self.sink.write_all(&bytes)\n } else {\n panic!(\"number too large\")\n }\n }\n\n pub fn raw_new_float_ext(&mut self, float: f32) -> Result<()> {\n self.state.last_mut().unwrap().decr();\n self.sink.write_u8(tag::NEW_FLOAT_EXT)?;\n self.sink.write_f32::(float)\n }\n\n pub fn raw_nil(&mut self) -> Result<()> {\n self.state.last_mut().unwrap().decr();\n self.sink.write_u8(tag::NIL_EXT)\n }\n\n pub fn raw_atom_utf8_ext(&mut self, data: &str) -> Result<()> {\n let bytes = data.as_bytes();\n let len_u16: u16 = bytes.len().try_into().unwrap();\n\n self.state.last_mut().unwrap().decr();\n self.sink.write_u8(tag::ATOM_UTF8_EXT)?;\n self.sink.write_u16::(len_u16)?;\n self.sink.write_all(bytes)\n }\n\n pub fn raw_small_atom_utf8_ext(&mut self, data: &str) -> Result<()> {\n let bytes = data.as_bytes();\n let len_u8: u8 = bytes.len().try_into().unwrap();\n\n self.state.last_mut().unwrap().decr();\n self.sink.write_u8(tag::SMALL_ATOM_UTF8_EXT)?;\n self.sink.write_u8(len_u8)?;\n self.sink.write_all(bytes)\n }\n\n pub fn raw_small_tuple_ext(&mut self, arity: u8) -> Result<()> {\n self.state.last_mut().unwrap().decr();\n self.state.push(WriterState::RemainingTerms(arity as usize));\n\n self.sink.write_u8(tag::SMALL_TUPLE_EXT)?;\n self.sink.write_u8(arity)\n }\n\n pub fn raw_large_tuple_ext(&mut self, arity: u16) -> Result<()> {\n self.state.last_mut().unwrap().decr();\n self.state.push(WriterState::RemainingTerms(arity as usize));\n\n self.sink.write_u8(tag::LARGE_TUPLE_EXT)?;\n self.sink.write_u16::(arity)\n }\n\n pub fn raw_map_ext(&mut self, size: u32) -> Result<()> {\n self.state.last_mut().unwrap().decr();\n self.state.push(WriterState::RemainingMap(size as usize, 0));\n\n self.sink.write_u8(tag::MAP_EXT)?;\n self.sink.write_u32::(size)\n }\n\n pub fn raw_list_ext(&mut self, length: u32) -> Result<()> {\n self.state.last_mut().unwrap().decr();\n self.state.push(WriterState::RemainingList(length as usize));\n\n self.sink.write_u8(tag::LIST_EXT)?;\n self.sink.write_u32::(length)\n }\n\n pub fn raw_binary_ext(&mut self, length: u32) -> Result<()> {\n self.state.last_mut().unwrap().decr();\n self.state.push(WriterState::RemainingData(length as usize));\n\n self.sink.write_u8(tag::BINARY_EXT)?;\n self.sink.write_u32::(length)\n }\n\n pub fn raw_bit_binary_ext(&mut self, length: u32, last_bits: u8) -> Result<()> {\n debug_assert!(last_bits <= 7);\n\n self.state.last_mut().unwrap().decr();\n self.state.push(WriterState::RemainingData(length as usize));\n\n self.sink.write_u8(tag::BIT_BINARY_EXT)?;\n self.sink.write_u32::(length)?;\n self.sink.write_u8(last_bits)\n }\n}\n\n/// Normal API for terminals\nimpl Writer {\n pub fn integer_u8(&mut self, int: u8) -> Result<()> {\n self.raw_small_integer_ext(int)\n }\n pub fn integer_i32(&mut self, int: i32) -> Result<()> {\n self.raw_integer_ext(int)\n }\n pub fn integer_big(&mut self, int: &BigInt) -> Result<()> {\n self.raw_big_ext(int)\n }\n\n pub fn float(&mut self, num: f32) -> Result<()> {\n self.raw_new_float_ext(num)\n }\n pub fn nil(&mut self) -> Result<()> {\n self.raw_nil()\n }\n pub fn atom(&mut self, string: &str) -> Result<()> {\n let len = string.len();\n if let Ok(_len) = TryInto::::try_into(len) {\n self.raw_small_atom_utf8_ext(string)\n } else if let Ok(_len) = TryInto::::try_into(len) {\n self.raw_atom_utf8_ext(string)\n } else {\n panic!(\"atom cannot be longer than 2^16\");\n }\n }\n pub fn tuple(&mut self, len: usize) -> Result<()> {\n if let Ok(len) = len.try_into() {\n self.raw_small_tuple_ext(len)\n } else if let Ok(len) = len.try_into() {\n self.raw_large_tuple_ext(len)\n } else {\n panic!(\"tuple cannot be longer than 2^16\");\n }\n }\n pub fn map>(&mut self, len: N) -> Result<()> {\n if let Ok(len) = len.try_into() {\n self.raw_map_ext(len)\n } else {\n panic!(\"map cannot be longer than 2^32\");\n }\n }\n pub fn list>(&mut self, len: N) -> Result<()> {\n if let Ok(len) = len.try_into() {\n self.raw_list_ext(len)\n } else {\n panic!(\"list cannot be longer than 2^32\");\n }\n }\n pub fn binary>(&mut self, len: N) -> Result<()> {\n if let Ok(len) = len.try_into() {\n self.raw_binary_ext(len)\n } else {\n panic!(\"binary cannot be longer than 2^32\");\n }\n }\n pub fn bit_binary>(&mut self, len: N, last_bits: u8) -> Result<()> {\n if let Ok(len) = len.try_into() {\n self.raw_bit_binary_ext(len, last_bits)\n } else {\n panic!(\"binary cannot be longer than 2^32\");\n }\n }\n}\n\nimpl Writer {\n pub fn term(&mut self, term: &Term) -> Result<()> {\n match term {\n Term::Float(num) => self.float(*num),\n Term::Integer(int) => {\n if let Ok(int) = (*int).try_into() {\n self.integer_u8(int)\n } else if let Ok(int) = (*int).try_into() {\n self.integer_i32(int)\n } else {\n unimplemented!()\n }\n }\n Term::Nil => self.nil(),\n\n Term::Tuple(elems) => {\n self.tuple(elems.len())?;\n for elem in elems {\n self.term(elem)?;\n }\n self.pop();\n Ok(())\n }\n Term::List(elems, tail) => {\n self.list(elems.len())?;\n for elem in elems {\n self.term(elem)?;\n }\n self.next_tail();\n self.term(tail)?;\n self.pop();\n Ok(())\n }\n Term::Map(elems) => {\n self.map(elems.len())?;\n for (k, v) in elems {\n self.term(k)?;\n self.term(v)?;\n self.next_kv();\n }\n self.pop();\n Ok(())\n }\n _ => unimplemented!(),\n }\n }\n}\n" }, { "path": "util/libeir_etf/test_data/generate.exs", "content": ":ok = File.write(\"int_tuple.etf\", :erlang.term_to_binary({1, 2, 3}))\n:ok = File.write(\"test_1.etf\", :erlang.term_to_binary([:hello, 1, [], 2222]))\n:ok = File.write(\"test_2.etf\", :erlang.term_to_binary(%{\"foo\" => :bar, 1 => {}}))\n" }, { "path": "util/libeir_etf/test_data/int_tuple.etf", "content": "h\u0003a\u0001a\u0002a\u0003" }, { "path": "util/libeir_util_binary/Cargo.toml", "content": "[package]\nname = \"libeir_util_binary\"\nversion = \"0.1.0\"\nauthors = [\"Hans Elias B. Josephsen \"]\nedition = \"2018\"\nlicense = \"MIT OR Apache-2.0\"\n\n# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html\n\n[dependencies]\nnum-traits = \"0.2.8\"\nnum-bigint = { git = \"https://github.com/hansihe/num-bigint.git\" }\n" }, { "path": "util/libeir_util_binary/src/bitvec.rs", "content": "use std::cmp::Ordering;\nuse std::hash::{Hash, Hasher};\n\nuse super::BitSlice;\nuse super::{BitCarrier, BitRead, BitWrite};\n\n#[derive(Debug, Clone)]\npub struct BitVec {\n buf: Vec,\n bit_size: usize,\n}\n\nimpl BitVec {\n pub fn new() -> Self {\n BitVec {\n buf: vec![],\n bit_size: 0,\n }\n }\n\n pub fn with_size(size: usize) -> Self {\n let byte_len = (size + 7) / 8;\n BitVec {\n buf: vec![0; byte_len],\n bit_size: size,\n }\n }\n\n pub fn clear(&mut self) {\n self.buf.clear();\n self.bit_size = 0;\n }\n\n pub fn empty(&mut self) -> bool {\n self.bit_size == 0\n }\n\n pub fn try_as_byte_aligned_slice(&self) -> Option<&[u8]> {\n if self.bit_size % 8 == 0 {\n Some(&self.buf)\n } else {\n None\n }\n }\n\n pub fn len(&self) -> usize {\n self.buf.len()\n }\n\n pub fn as_ref(&self) -> &[u8] {\n &self.buf\n }\n\n pub fn get(&self, n: usize) -> Option {\n self.buf.get(n).cloned()\n }\n\n pub fn push(&mut self, from: R)\n where\n R: BitRead,\n {\n let needed = from.bit_len();\n let availible = self.buf.len() * 8 - self.bit_size;\n\n if needed > availible {\n let needed_bytes = ((needed - availible) + 7) / 8;\n for _ in 0..needed_bytes {\n self.buf.push(0);\n }\n }\n\n let mut slice =\n BitSlice::<&mut [u8]>::with_offset_length(&mut self.buf[..], self.bit_size, needed);\n slice.write(from);\n\n self.bit_size += needed;\n }\n pub fn pop(&mut self, to: &mut R) -> Option<()>\n where\n R: BitWrite,\n {\n let to_size = to.bit_len();\n let self_size = self.bit_size;\n if self_size < to_size {\n return None;\n }\n\n let slice = BitSlice::<&mut [u8]>::with_offset_length(\n &mut self.buf[..],\n self.bit_size - to_size,\n to_size,\n );\n to.write(&slice);\n\n let unneeded = to_size / 8;\n for _ in 0..unneeded {\n self.buf.pop();\n }\n\n self.bit_size -= to_size;\n\n debug_assert!(self.bit_size <= self.buf.len() * 8);\n\n Some(())\n }\n\n pub fn iter_bytes(&self) -> BitVecBytesIterator {\n BitVecBytesIterator {\n vec: self,\n elem: 0,\n rem: self.bit_size + 8,\n }\n }\n}\n\nimpl Default for BitVec {\n fn default() -> Self {\n BitVec::new()\n }\n}\n\nimpl From> for BitVec {\n fn from(buf: Vec) -> BitVec {\n BitVec {\n bit_size: buf.len() * 8,\n buf,\n }\n }\n}\n\npub struct BitVecBytesIterator<'a> {\n vec: &'a BitVec,\n elem: usize,\n rem: usize,\n}\nimpl<'a> Iterator for BitVecBytesIterator<'a> {\n type Item = u8;\n fn next(&mut self) -> Option {\n if self.rem < 8 {\n None\n } else {\n self.rem -= 8;\n let mask = !(!0u8)\n .checked_shr(std::cmp::min(8, self.rem) as u32)\n .unwrap_or(0);\n let ret = self.vec.buf[self.elem] & mask;\n self.elem += 1;\n Some(ret)\n }\n }\n}\n\n//impl Eq for BitVec {}\n//impl PartialEq for BitVec {\n// fn eq(&self, other: &Self) -> bool {\n// if self.bit_size != other.bit_size { return false; }\n// self.iter_bytes().eq(other.iter_bytes())\n// }\n//}\n//\n//impl Ord for BitVec {\n// fn cmp(&self, other: &Self) -> Ordering {\n// match self.iter_bytes().cmp(other.iter_bytes()) {\n// Ordering::Equal => (),\n// non_eq => return non_eq,\n// }\n//\n// self.bit_size.cmp(&other.bit_size)\n// }\n//}\n//impl PartialOrd for BitVec {\n// fn partial_cmp(&self, other: &Self) -> Option {\n// Some(self.cmp(other))\n// }\n//}\n//\n//impl Hash for BitVec {\n// fn hash(&self, state: &mut H) where H: Hasher {\n// self.bit_size.hash(state);\n// for elem in self.iter_bytes() {\n// elem.hash(state);\n// }\n// }\n//}\n\nimpl BitCarrier for BitVec {\n type T = u8;\n fn bit_len(&self) -> usize {\n self.bit_size\n }\n}\nimpl BitRead for BitVec {\n fn read_word(&self, n: usize) -> u8 {\n self.buf.get(n).cloned().unwrap_or(0)\n }\n}\nimpl BitWrite for BitVec {\n fn write_word(&mut self, n: usize, data: u8, mask: u8) {\n self.buf\n .get_mut(n)\n .map(|d| *d = (*d & !mask) | (data & mask));\n }\n}\n\nimpl Eq for BitVec {}\nimpl PartialEq for BitVec\nwhere\n O: BitRead,\n{\n fn eq(&self, other: &O) -> bool {\n if self.bit_len() != other.bit_len() {\n return false;\n }\n self.iter_words().eq(other.iter_words())\n }\n}\n\nimpl PartialOrd for BitVec\nwhere\n O: BitRead,\n{\n fn partial_cmp(&self, other: &O) -> Option {\n match self.iter_words().cmp(other.iter_words()) {\n Ordering::Equal => (),\n non_eq => return Some(non_eq),\n }\n Some(self.bit_len().cmp(&other.bit_len()))\n }\n}\nimpl Ord for BitVec {\n fn cmp(&self, other: &Self) -> Ordering {\n self.partial_cmp(other).unwrap()\n }\n}\n\nimpl Hash for BitVec {\n fn hash(&self, state: &mut H)\n where\n H: Hasher,\n {\n self.bit_len().hash(state);\n for elem in self.iter_words() {\n elem.hash(state);\n }\n }\n}\n\n#[cfg(test)]\nmod test {\n use super::BitVec;\n\n #[test]\n fn basic_push_pop() {\n let mut vec = BitVec::new();\n\n vec.push(1u32);\n assert!(vec.len() == 4);\n assert!(vec.get(0) == Some(0));\n assert!(vec.get(1) == Some(0));\n assert!(vec.get(2) == Some(0));\n assert!(vec.get(3) == Some(1));\n assert!(vec.get(4) == None);\n\n let mut ret: u32 = 0;\n vec.pop(&mut ret);\n assert!(vec.len() == 0);\n assert!(ret == 1);\n\n vec.clear();\n vec.push(true);\n vec.push(1u32);\n assert!(vec.len() == 5);\n assert!(vec.get(0) == Some(128));\n assert!(vec.get(1) == Some(0));\n assert!(vec.get(2) == Some(0));\n assert!(vec.get(3) == Some(0));\n assert!(vec.get(4) == Some(128));\n assert!(vec.get(5) == None);\n\n let mut ret: bool = false;\n vec.pop(&mut ret);\n assert!(ret == true);\n\n let mut ret: u32 = 0;\n vec.pop(&mut ret);\n assert!(ret == 0b10000000_00000000_00000000_00000000);\n }\n}\n" }, { "path": "util/libeir_util_binary/src/extend.rs", "content": "use crate::{BitCarrier, BitTransport, BitRead, BitSlice};\n\n/// Extends the inner carrier by the given number of words.\n///\n/// Even if `head_extend` and `tail_extend` is 0, this will pad the length of\n/// inner to the next whole transport size.\n#[derive(Debug, Clone)]\npub struct ExtendWords {\n pub(crate) inner: I,\n pub(crate) extend: I::T,\n pub(crate) head_extend: usize,\n pub(crate) tail_extend: usize,\n}\n\nimpl BitCarrier for ExtendWords\nwhere\n I: BitCarrier,\n{\n type T = I::T;\n fn bit_len(&self) -> usize {\n (((self.inner.bit_len() + 7) / 8) + self.head_extend + self.tail_extend) * I::T::BIT_SIZE\n }\n}\n\nimpl BitRead for ExtendWords\nwhere\n I: BitRead,\n{\n fn read_word(&self, n: usize) -> I::T {\n if n < self.head_extend {\n self.extend\n } else {\n let n = n - self.head_extend;\n\n let inner_bl = self.inner.bit_len();\n let last_word = inner_bl / 8;\n\n let inner_bl_mod = inner_bl % I::T::BIT_SIZE;\n\n if inner_bl == 0 {\n self.extend\n } else if n < last_word || (n == last_word && inner_bl_mod == 0) {\n // We read a whole word, no funny business\n self.inner.read_word(n)\n } else if n == last_word {\n debug_assert!(inner_bl_mod != 0);\n\n // We read a partial word.\n // We need to extend the last bits.\n let word = self.inner.read_word(n);\n let mod_inv = I::T::BIT_SIZE - inner_bl_mod;\n let mask = I::T::MAX << mod_inv as u32;\n (word & mask) | (self.extend & !mask)\n } else if n > last_word {\n self.extend\n } else {\n unreachable!()\n }\n }\n }\n}\n\npub type Extend = BitSlice>;\n\npub fn extend_words_pad(inner: I, extend: I::T, head_words: usize, tail_words: usize) -> ExtendWords {\n ExtendWords {\n inner,\n extend,\n head_extend: head_words,\n tail_extend: tail_words,\n }\n}\n\npub fn extend_bits(inner: I, extend: I::T, head_bits: usize, tail_bits: usize) -> Extend {\n let head_words = (head_bits + (I::T::BIT_SIZE - 1)) / I::T::BIT_SIZE;\n let tail_words = (tail_bits + (I::T::BIT_SIZE - 1)) / I::T::BIT_SIZE;\n\n let offset = (head_words * I::T::BIT_SIZE) - head_bits;\n let length = head_bits + inner.bit_len() + tail_bits;\n\n inner.extend_words_pad(extend, head_words, tail_words).slice_bits(offset, length)\n}\n\n#[cfg(test)]\nmod tests {\n use crate::{BitSlice, BitCarrier, BitRead};\n\n #[test]\n fn extend_words_pad() {\n let bs = BitSlice::with_offset_length(0b10010110u8, 2, 6);\n\n let bse = (&bs).extend_words_pad(0xff, 0, 0);\n assert_eq!(bse.bit_len(), 8);\n assert_eq!(bse.read_word(0), 0b01011011);\n\n let bse = (&bs).extend_bits(0xff, 4, 4);\n assert_eq!(bse.bit_len(), 6 + 8);\n assert_eq!(bse.read_word(0), 0b11110101);\n assert_eq!(bse.read_word(1) & 0b11111100, 0b10111100);\n }\n\n}\n" }, { "path": "util/libeir_util_binary/src/impls.rs", "content": "use super::{BitCarrier, BitRead, BitTransport, BitWrite};\n\nmacro_rules! impl_prim {\n ($typ:ty, $utyp:ty) => {\n impl BitCarrier for $typ {\n type T = u8;\n fn bit_len(&self) -> usize {\n std::mem::size_of::() * 8\n }\n }\n impl BitRead for $typ {\n fn read_word(&self, n: usize) -> u8 {\n let size = std::mem::size_of::();\n if n < size {\n ((*self as $utyp) >> (8 * (size - 1 - n))) as u8\n } else {\n 0\n }\n }\n }\n impl BitWrite for $typ {\n fn write_word(&mut self, n: usize, data: u8, mask: u8) {\n let size = std::mem::size_of::();\n let offset = 8 * (size - 1 - n);\n *self = (((*self as $utyp) & !((mask as $utyp) << offset))\n | ((data as $utyp) << offset)) as $typ;\n }\n }\n };\n}\n\nmacro_rules! impl_float {\n ($typ:ty, $utyp:ty) => {\n impl BitCarrier for $typ {\n type T = u8;\n fn bit_len(&self) -> usize {\n std::mem::size_of::() * 8\n }\n }\n impl BitRead for $typ {\n fn read_word(&self, n: usize) -> u8 {\n let size = std::mem::size_of::();\n if n < size {\n ((self.to_bits()) >> (8 * (size - 1 - n))) as u8\n } else {\n 0\n }\n }\n }\n impl BitWrite for $typ {\n fn write_word(&mut self, n: usize, data: u8, mask: u8) {\n let size = std::mem::size_of::();\n let offset = 8 * (size - 1 - n);\n *self = Self::from_bits(\n ((self.to_bits()) & !((mask as $utyp) << offset)) | ((data as $utyp) << offset),\n );\n }\n }\n };\n}\n\nimpl_prim!(u8, u8);\nimpl_prim!(i8, u8);\nimpl_prim!(u16, u16);\nimpl_prim!(i16, u16);\nimpl_prim!(u32, u32);\nimpl_prim!(i32, u32);\nimpl_prim!(u64, u64);\nimpl_prim!(i64, u64);\nimpl_prim!(u128, u128);\nimpl_prim!(i128, u128);\n\nimpl_float!(f32, u32);\nimpl_float!(f64, u64);\n\n// Base u1 implementations\nimpl BitCarrier for bool {\n type T = u8;\n fn bit_len(&self) -> usize {\n 1\n }\n}\nimpl BitRead for bool {\n fn read_word(&self, _n: usize) -> u8 {\n (*self as u8) << 7\n }\n}\nimpl BitWrite for bool {\n fn write_word(&mut self, n: usize, data: u8, mask: u8) {\n assert!(n == 0);\n if mask & 0b10000000 != 1 {\n *self = (data & 0b10000000) != 0;\n } else {\n panic!()\n }\n }\n}\n\n// Blanket implementations\nimpl BitCarrier for &N\nwhere\n N: BitCarrier,\n Tr: BitTransport,\n{\n type T = Tr;\n fn bit_len(&self) -> usize {\n N::bit_len(self)\n }\n}\nimpl BitRead for &N\nwhere\n N: BitRead,\n{\n fn read_word(&self, n: usize) -> Self::T {\n N::read_word(self, n)\n }\n}\n\nimpl BitCarrier for &mut N\nwhere\n N: BitCarrier,\n Tr: BitTransport,\n{\n type T = Tr;\n fn bit_len(&self) -> usize {\n N::bit_len(self)\n }\n}\nimpl BitRead for &mut N\nwhere\n N: BitRead,\n{\n fn read_word(&self, n: usize) -> Self::T {\n N::read_word(self, n)\n }\n}\nimpl BitWrite for &mut N\nwhere\n N: BitWrite,\n{\n fn write_word(&mut self, n: usize, data: Self::T, mask: Self::T) {\n N::write_word(self, n, data, mask)\n }\n}\n\n//impl BitCarrier for &mut N where N: BitCarrier, T: BitTransport {\n// fn bit_len(&self) -> usize {\n// N::bit_len(self)\n// }\n//}\n//impl BitRead for &mut N where N: BitRead, T: BitTransport {\n// fn read_word(&self, n: usize) -> T {\n// N::read_word(self, n)\n// }\n//}\n\nimpl BitCarrier for Vec\nwhere\n Tr: BitTransport,\n{\n type T = Tr;\n fn bit_len(&self) -> usize {\n (self as &[Self::T]).bit_len()\n }\n}\nimpl BitRead for Vec\nwhere\n Tr: BitTransport,\n{\n fn read_word(&self, n: usize) -> Self::T {\n (self as &[Self::T]).read_word(n)\n }\n}\nimpl BitWrite for Vec\nwhere\n Tr: BitTransport,\n{\n fn write_word(&mut self, n: usize, data: Self::T, mask: Self::T) {\n (self as &mut [Self::T]).write_word(n, data, mask)\n }\n}\n\nimpl BitCarrier for &[Tr]\nwhere\n Tr: BitTransport,\n{\n type T = Tr;\n fn bit_len(&self) -> usize {\n self.len() * 8\n }\n}\nimpl BitRead for &[Tr]\nwhere\n Tr: BitTransport,\n{\n fn read_word(&self, n: usize) -> Self::T {\n self.get(n).cloned().unwrap_or(Self::T::ZERO)\n }\n}\n\nimpl BitCarrier for &mut [Tr]\nwhere\n Tr: BitTransport,\n{\n type T = Tr;\n fn bit_len(&self) -> usize {\n self.len() * 8\n }\n}\nimpl BitRead for &mut [Tr]\nwhere\n Tr: BitTransport,\n{\n fn read_word(&self, n: usize) -> Self::T {\n self.get(n).cloned().unwrap_or(Self::T::ZERO)\n }\n}\nimpl BitWrite for &mut [Tr]\nwhere\n Tr: BitTransport,\n{\n fn write_word(&mut self, n: usize, data: Self::T, mask: Self::T) {\n self.get_mut(n).map(|v| *v = (*v & !mask) | (data & mask));\n }\n}\n\nimpl BitCarrier for [Tr]\nwhere\n Tr: BitTransport,\n{\n type T = Tr;\n fn bit_len(&self) -> usize {\n self.len() * 8\n }\n}\nimpl BitRead for [Tr]\nwhere\n Tr: BitTransport,\n{\n fn read_word(&self, n: usize) -> Self::T {\n self.get(n).cloned().unwrap_or(Self::T::ZERO)\n }\n}\nimpl BitWrite for [Tr]\nwhere\n Tr: BitTransport,\n{\n fn write_word(&mut self, n: usize, data: Self::T, mask: Self::T) {\n self.get_mut(n).map(|v| *v = (*v & !mask) | (data & mask));\n }\n}\n\n//macro_rules! impl_traits {\n// (($($es:ty,),*), $typ:ty) => {\n// impl<$($es),*> Eq for $typ where {}\n// impl PartialEq for $typ where O: BitRead {\n// fn eq(&self, other: &Self) -> bool {\n// if self.bit_len() != other.bit_len() { return false; }\n// self.iter_words().eq(other.iter_words())\n// }\n// }\n//\n// impl<$($es),*> Ord for $typ {\n// fn cmp(&self, other: &Self) -> Ordering {\n// match self.iter_words().cmp(other.iter_words()) {\n// Ordering::Equal => (),\n// non_eq => return non_eq,\n// }\n//\n// self.bit_len().cmp(&other.bit_len())\n// }\n// }\n// impl<$($es),*> PartialOrd for $typ {\n// fn partial_cmp(&self, other: &Self) -> Option {\n// Some(self.cmp(other))\n// }\n// }\n//\n// impl<$($es),*> Hash for $typ {\n// fn hash(&self, state: &mut H) where H: Hasher {\n// self.bit_len().hash(state);\n// for elem in self.iter_words() {\n// elem.hash(state);\n// }\n// }\n// }\n//\n//\n// }\n//}\n\n//impl_traits!((), BitSlice);\n//impl_traits!((), BitVec);\n" }, { "path": "util/libeir_util_binary/src/integer.rs", "content": "//use rug::Integer;\n//use rug::integer::Order;\nuse num_bigint::{BigInt, Sign};\n\nuse super::{BitRead, BitSlice, BitWrite, BitCarrier};\n\n#[derive(Debug, Copy, Clone)]\npub enum Endian {\n Big,\n Little,\n}\n//impl Endian {\n// fn to_order(&self) -> Order {\n// match self {\n// Endian::Big => Order::Msf,\n// Endian::Little => Order::Lsf,\n// }\n// }\n//}\n\nimpl BitCarrier for BigInt {\n type T = u8;\n fn bit_len(&self) -> usize {\n let bits = self.bits() as usize;\n if self < &0 {\n bits + 1\n } else {\n bits\n }\n }\n}\n\npub fn integer_to_carrier(mut int: BigInt, bits: usize, endian: Endian) -> BitSlice> {\n let negative = int < 0;\n if negative {\n int += 1;\n }\n\n let keep_bytes = (bits + 7) / 8;\n let aux_bits = bits % 8;\n\n let (_sign, mut digits) = match endian {\n Endian::Big => int.to_bytes_be(),\n Endian::Little => int.to_bytes_le(),\n };\n\n match endian {\n Endian::Big => {\n let mut new = Vec::new();\n\n if keep_bytes > digits.len() {\n new.resize(keep_bytes - digits.len(), 0);\n new.extend(digits.iter());\n } else {\n new.extend(digits.iter().skip(digits.len() - keep_bytes));\n }\n\n digits = new;\n }\n Endian::Little => {\n digits.resize(keep_bytes, 0);\n }\n }\n\n if negative {\n for digit in digits.iter_mut() {\n *digit = !*digit;\n }\n }\n\n match endian {\n Endian::Big => {\n if aux_bits > 0 {\n digits[0] &= !(!0 << aux_bits);\n BitSlice::with_offset_length(digits, 8 - aux_bits, bits)\n } else {\n BitSlice::with_offset_length(digits, 0, bits)\n }\n }\n Endian::Little => {\n if aux_bits > 0 {\n digits[keep_bytes - 1] <<= 8 - aux_bits;\n }\n BitSlice::with_offset_length(digits, 0, bits)\n }\n }\n}\n\nfn carrier_to_buf(carrier: C, signed: bool, endian: Endian) -> (Vec, bool)\nwhere\n C: BitRead,\n{\n let bit_len = carrier.bit_len();\n let num_bytes = (bit_len + 7) / 8;\n\n let aux_bits = bit_len % 8;\n let aux_bits_wrap = if aux_bits == 0 { 8 } else { aux_bits };\n\n let offset = match endian {\n Endian::Big => 8 - aux_bits_wrap,\n Endian::Little => 0,\n };\n\n let mut buf = vec![0; num_bytes];\n {\n let mut slice = BitSlice::with_offset_length(&mut buf, offset, bit_len);\n slice.write(carrier);\n }\n\n let mut last = match endian {\n Endian::Big => buf[0],\n Endian::Little => buf[num_bytes - 1] >> aux_bits,\n };\n\n // Sign extend\n let mut sign = false;\n if signed {\n sign = last & (1 << (aux_bits_wrap - 1)) != 0;\n if sign {\n last |= !(!0 >> (8 - aux_bits_wrap));\n }\n }\n\n match endian {\n Endian::Big => buf[0] = last,\n Endian::Little => buf[num_bytes - 1] = last,\n }\n\n (buf, sign)\n}\n\npub fn carrier_to_integer(carrier: C, signed: bool, endian: Endian) -> BigInt\nwhere\n C: BitRead,\n{\n let (mut buf, sign) = carrier_to_buf(carrier, signed, endian);\n\n if sign {\n for elem in buf.iter_mut() {\n *elem = !*elem;\n }\n let mut int = match endian {\n Endian::Big => BigInt::from_bytes_be(Sign::Plus, &buf),\n Endian::Little => BigInt::from_bytes_le(Sign::Plus, &buf),\n };\n int *= -1;\n int -= 1;\n int\n } else {\n match endian {\n Endian::Big => BigInt::from_bytes_be(Sign::Plus, &buf),\n Endian::Little => BigInt::from_bytes_le(Sign::Plus, &buf),\n }\n }\n}\n\n#[cfg(test)]\nmod tests {\n use super::super::{BitSlice, BitWrite};\n use super::{carrier_to_buf, carrier_to_integer, integer_to_carrier, Endian};\n use num_bigint::BigInt;\n\n #[test]\n fn integer_adapter_basic() {\n let int = BigInt::from(0b00001111_00010000);\n\n {\n let conv = integer_to_carrier(int.clone(), 16, Endian::Little);\n let mut out: [u8; 2] = [0; 2];\n out.write(&conv);\n assert!(out[0] == 0b00010000);\n assert!(out[1] == 0b00001111);\n }\n\n {\n let conv = integer_to_carrier(int.clone(), 16, Endian::Big);\n let mut out: [u8; 2] = [0; 2];\n out.write(&conv);\n assert!(out[0] == 0b00001111);\n assert!(out[1] == 0b00010000);\n }\n }\n\n #[test]\n fn integer_adapter_unaligned() {\n let int = BigInt::from(0b00001111_00010000);\n\n {\n let conv = integer_to_carrier(int.clone(), 12, Endian::Little);\n\n let mut out: [u8; 2] = [0; 2];\n {\n let mut slice = BitSlice::with_offset_length(&mut out as &mut [u8], 0, 12);\n slice.write(conv);\n }\n\n assert!(out[0] == 0b00010000);\n assert!(out[1] == 0b11110000);\n }\n\n {\n let conv = integer_to_carrier(int.clone(), 12, Endian::Big);\n\n let mut out: [u8; 2] = [0; 2];\n {\n let mut slice = BitSlice::with_offset_length(&mut out as &mut [u8], 0, 12);\n slice.write(conv);\n }\n\n assert!(out[0] == 0b11110001);\n assert!(out[1] == 0b00000000);\n }\n }\n\n #[test]\n fn integer_adapter_negative() {\n {\n let int = BigInt::from(-5);\n let conv = integer_to_carrier(int.clone(), 16, Endian::Big);\n let mut out: i16 = 0;\n out.write(&conv);\n dbg!(out);\n assert!(out == -5);\n }\n\n {\n let int = BigInt::from(-10000);\n let conv = integer_to_carrier(int.clone(), 16, Endian::Big);\n let mut out: i16 = 0;\n out.write(&conv);\n dbg!(out);\n assert!(out == -10000);\n }\n }\n\n #[test]\n fn integer_carrier_to_buf() {\n {\n let int = BigInt::from(5);\n let conv = integer_to_carrier(int.clone(), 16, Endian::Big);\n let mut buf: [u8; 2] = [0; 2];\n buf.write(&conv);\n\n let (out, sign) = carrier_to_buf(&buf as &[u8], false, Endian::Big);\n assert!(sign == false);\n assert!(out[0] == 0);\n assert!(out[1] == 5);\n\n let (out, sign) = carrier_to_buf(&buf as &[u8], true, Endian::Big);\n assert!(out[0] == 0);\n assert!(out[1] == 5);\n assert!(sign == false);\n }\n\n {\n let int = BigInt::from(0b00000101_01010101);\n let conv = integer_to_carrier(int.clone(), 12, Endian::Big);\n\n let mut buf: [u8; 2] = [0; 2];\n let mut carrier = BitSlice::with_offset_length(&mut buf as &mut [u8], 0, 12);\n\n carrier.write(&conv);\n\n let (out, sign) = carrier_to_buf(&carrier, false, Endian::Big);\n assert!(out[0] == 0b00000101);\n assert!(out[1] == 0b01010101);\n assert!(sign == false);\n\n let (out, sign) = carrier_to_buf(&carrier, true, Endian::Big);\n assert!(out[0] == 0b00000101);\n assert!(out[1] == 0b01010101);\n assert!(sign == false);\n }\n\n {\n let int = BigInt::from(0b00001010_10101010);\n let conv = integer_to_carrier(int.clone(), 12, Endian::Big);\n\n let mut buf: [u8; 2] = [0; 2];\n let mut carrier = BitSlice::with_offset_length(&mut buf as &mut [u8], 0, 12);\n\n carrier.write(&conv);\n\n let (out, sign) = carrier_to_buf(&carrier, false, Endian::Big);\n assert!(out[0] == 0b00001010);\n assert!(out[1] == 0b10101010);\n assert!(sign == false);\n\n let (out, sign) = carrier_to_buf(&carrier, true, Endian::Big);\n assert!(out[0] == 0b11111010);\n assert!(out[1] == 0b10101010);\n assert!(sign == true);\n }\n\n {\n let int = BigInt::from(0b00001010_10101010);\n let conv = integer_to_carrier(int.clone(), 12, Endian::Little);\n\n let mut buf: [u8; 2] = [0; 2];\n let mut carrier = BitSlice::with_offset_length(&mut buf as &mut [u8], 0, 12);\n\n carrier.write(&conv);\n\n let (out, sign) = carrier_to_buf(&carrier, false, Endian::Little);\n assert!(out[0] == 0b10101010);\n assert!(out[1] == 0b00001010);\n assert!(sign == false);\n\n let (out, sign) = carrier_to_buf(&carrier, true, Endian::Little);\n assert!(out[0] == 0b10101010);\n assert!(out[1] == 0b11111010);\n assert!(sign == true);\n }\n }\n\n #[test]\n fn integer_round_trip_basic() {\n {\n let int = BigInt::from(5);\n let conv = integer_to_carrier(int.clone(), 16, Endian::Big);\n let mut buf: [u8; 2] = [0; 2];\n buf.write(&conv);\n let back = carrier_to_integer(&buf as &[u8], true, Endian::Big);\n assert!(int == back);\n }\n\n {\n let int = BigInt::from(-5);\n let conv = integer_to_carrier(int.clone(), 16, Endian::Big);\n let mut buf: [u8; 2] = [0; 2];\n buf.write(&conv);\n let back = carrier_to_integer(&buf as &[u8], true, Endian::Big);\n assert!(int == back);\n }\n\n {\n let int = BigInt::from(5);\n let conv = integer_to_carrier(int.clone(), 16, Endian::Little);\n let mut buf: [u8; 2] = [0; 2];\n buf.write(&conv);\n let back = carrier_to_integer(&buf as &[u8], true, Endian::Little);\n assert!(int == back);\n }\n\n {\n let int = BigInt::from(-5);\n let conv = integer_to_carrier(int.clone(), 16, Endian::Little);\n let mut buf: [u8; 2] = [0; 2];\n buf.write(&conv);\n let back = carrier_to_integer(&buf as &[u8], true, Endian::Little);\n assert!(int == back);\n }\n }\n\n #[test]\n fn integer_round_trip_unaligned() {\n {\n let int = BigInt::from(5);\n let conv = integer_to_carrier(int.clone(), 12, Endian::Big);\n\n let mut buf: [u8; 2] = [0; 2];\n let mut carrier = BitSlice::with_offset_length(&mut buf as &mut [u8], 0, 12);\n\n carrier.write(&conv);\n\n let back = carrier_to_integer(&carrier, true, Endian::Big);\n assert!(int == back);\n }\n\n {\n let int = BigInt::from(5);\n let conv = integer_to_carrier(int.clone(), 12, Endian::Little);\n\n let mut buf: [u8; 2] = [0; 2];\n let mut carrier = BitSlice::with_offset_length(&mut buf as &mut [u8], 0, 12);\n\n carrier.write(&conv);\n\n let back = carrier_to_integer(&carrier, true, Endian::Little);\n assert!(int == back);\n }\n\n {\n let int = BigInt::from(-5);\n let conv = integer_to_carrier(int.clone(), 12, Endian::Big);\n\n let mut buf: [u8; 2] = [0; 2];\n let mut carrier = BitSlice::with_offset_length(&mut buf as &mut [u8], 0, 12);\n\n carrier.write(&conv);\n\n let back = carrier_to_integer(&carrier, true, Endian::Big);\n assert!(int == back);\n }\n\n {\n let int = BigInt::from(-5);\n let conv = integer_to_carrier(int.clone(), 12, Endian::Little);\n\n let mut buf: [u8; 2] = [0; 2];\n let mut carrier = BitSlice::with_offset_length(&mut buf as &mut [u8], 0, 12);\n\n carrier.write(&conv);\n\n let back = carrier_to_integer(&carrier, true, Endian::Little);\n assert!(int == back);\n }\n }\n}\n" }, { "path": "util/libeir_util_binary/src/lib.rs", "content": "use std::cmp::Ord;\nuse std::fmt::Debug;\nuse std::hash::Hash;\nuse std::marker::PhantomData;\nuse std::ops::{BitAnd, BitOr, Not};\n\nuse num_traits::{CheckedShl, CheckedShr};\n\nmod impls;\n\nmod slice;\npub use self::slice::BitSlice;\n\nmod bitvec;\npub use self::bitvec::BitVec;\n\nmod integer;\npub use self::integer::{carrier_to_integer, integer_to_carrier, Endian};\n\nmod extend;\npub use self::extend::{ExtendWords, Extend};\n\n/// A primitive data type that can be used to store bits.\n/// Must be sized, copyable, and implement a set of\n/// elemental operations.\npub trait BitTransport:\n Sized\n + Ord\n + Copy\n + Not\n + BitAnd\n + BitOr\n + CheckedShr\n + CheckedShl\n + Eq\n + Hash\n + Debug\n{\n const SIZE: usize;\n const BIT_SIZE: usize = Self::SIZE * 8;\n\n const ZERO: Self;\n const ONE: Self;\n const MAX: Self;\n}\n\nimpl BitTransport for u8 {\n const SIZE: usize = 1;\n const ZERO: u8 = 0;\n const ONE: u8 = 0;\n const MAX: u8 = 0xff;\n}\n\n/// The base trait for bit carriers.\n/// Has a certain bit length.\npub trait BitCarrier {\n type T: BitTransport;\n\n /// The total length in bits.\n fn bit_len(&self) -> usize;\n\n /// Total word length including partial word at the end.\n fn word_len(&self) -> usize {\n (self.bit_len() + (Self::T::BIT_SIZE - 1)) / Self::T::BIT_SIZE\n }\n /// Number of bits in the padding word at the end.\n fn partial_bit_len(&self) -> usize {\n let rem = self.bit_len() % Self::T::BIT_SIZE;\n if rem == 0 {\n Self::T::BIT_SIZE\n } else {\n rem\n }\n }\n\n fn extend_words_pad(self, extend: Self::T, head_words: usize, tail_words: usize) -> ExtendWords\n where\n Self: Sized,\n {\n crate::extend::extend_words_pad(self, extend, head_words, tail_words)\n }\n\n fn slice_bits(self, offset: usize, length: usize) -> BitSlice\n where\n Self: Sized,\n {\n BitSlice::with_offset_length(self, offset, length)\n }\n\n fn extend_bits(self, extend: Self::T, head_bits: usize, tail_bits: usize) -> Extend\n where\n Self: Sized,\n {\n crate::extend::extend_bits(self, extend, head_bits, tail_bits)\n }\n}\n\npub trait BitRead: BitCarrier {\n /// Reads the nth word from the data type.\n /// The last word may be padded with arbitrary bits at the\n /// least significant digit side.\n fn read_word(&self, n: usize) -> Self::T;\n\n fn read_bit(&self, bit_n: usize) -> bool {\n let word_n = bit_n / Self::T::BIT_SIZE;\n let sub_bit_n = bit_n % Self::T::BIT_SIZE;\n\n let word = self.read_word(word_n);\n\n let offset = (Self::T::BIT_SIZE - 1 - sub_bit_n) as u32;\n (word & (Self::T::ONE << offset)) != Self::T::ZERO\n }\n\n fn read

(&self, to: &mut P)\n where\n Self: Sized,\n P: BitWrite,\n {\n to.write(self)\n }\n\n fn iter_words(&self) -> CarrierWordIter\n where\n Self: Sized,\n {\n CarrierWordIter {\n inner: self,\n _transport: PhantomData,\n idx: 0,\n rem: self.bit_len() + 8,\n }\n }\n}\n\npub trait BitWrite: BitCarrier {\n /// Sets the masked bits of element n to data.\n /// Writes outside of the container with a non zero mask\n /// not allowed.\n fn write_word(&mut self, n: usize, data: Self::T, mask: Self::T);\n\n /// Writes one bit carrier into another bit carrier of the\n /// same length.\n fn write

(&mut self, from: P)\n where\n P: BitRead,\n {\n assert!(self.bit_len() == from.bit_len());\n\n let mut len = self.bit_len() as isize;\n for n in 0..self.word_len() {\n let num_bits = std::cmp::min(len as usize, Self::T::BIT_SIZE) as u32;\n let mask = !((!Self::T::ZERO)\n .checked_shr(num_bits)\n .unwrap_or(Self::T::ZERO));\n\n let read = from.read_word(n);\n self.write_word(n, read, mask);\n len -= Self::T::BIT_SIZE as isize;\n }\n }\n}\n\npub fn copy(from: S, mut to: D)\nwhere\n S: BitRead,\n D: BitWrite,\n T: BitTransport,\n{\n to.write(from)\n}\n\npub struct CarrierWordIter<'a, I, T>\nwhere\n I: BitRead,\n T: BitTransport,\n{\n inner: &'a I,\n _transport: PhantomData,\n idx: usize,\n rem: usize,\n}\nimpl<'a, I, T> Iterator for CarrierWordIter<'a, I, T>\nwhere\n I: BitRead,\n T: BitTransport,\n{\n type Item = T;\n fn next(&mut self) -> Option {\n if self.rem < 8 {\n None\n } else {\n let res = self.inner.read_word(self.idx);\n self.rem -= 8;\n self.idx += 1;\n Some(res)\n }\n }\n}\n" }, { "path": "util/libeir_util_binary/src/slice.rs", "content": "use std::cmp::{Ord, Ordering, PartialOrd};\nuse std::hash::{Hash, Hasher};\n\nuse num_traits::{CheckedShl, CheckedShr};\n\nuse super::{BitCarrier, BitRead, BitTransport, BitWrite};\n\n/// Changes the alignment/length of a bit carrier.\n#[derive(Debug, Clone)]\npub struct BitSlice {\n inner: I,\n word_offset: usize,\n bit_offset: u32,\n bit_length: usize,\n}\nimpl BitCarrier for BitSlice\nwhere\n I: BitCarrier,\n Tr: BitTransport,\n{\n type T = Tr;\n fn bit_len(&self) -> usize {\n self.bit_length\n }\n}\nimpl BitRead for BitSlice\nwhere\n I: BitRead,\n{\n fn read_word(&self, n: usize) -> Self::T {\n let p1 = self.inner.read_word(self.word_offset + n + 0);\n let p2 = self.inner.read_word(self.word_offset + n + 1);\n (p1.checked_shl(self.bit_offset).unwrap_or(Self::T::ZERO))\n | (p2\n .checked_shr(Self::T::BIT_SIZE as u32 - self.bit_offset)\n .unwrap_or(Self::T::ZERO))\n }\n}\n\nimpl BitWrite for BitSlice\nwhere\n I: BitWrite,\n{\n fn write_word(&mut self, n: usize, data: Self::T, mask: Self::T) {\n // TODO find a way to avoid branch?\n if mask == Self::T::ZERO {\n return;\n }\n if self.bit_offset == 0 {\n self.inner.write_word(self.word_offset + n, data, mask);\n } else {\n self.inner.write_word(\n self.word_offset + n + 0,\n data >> self.bit_offset,\n mask >> self.bit_offset,\n );\n self.inner.write_word(\n self.word_offset + n + 1,\n data << (Self::T::BIT_SIZE as u32 - self.bit_offset),\n mask << (Self::T::BIT_SIZE as u32 - self.bit_offset),\n );\n }\n }\n}\n\nimpl BitSlice\nwhere\n I: BitCarrier,\n{\n pub fn with_offset_length(inner: I, bit_offset: usize, bit_len: usize) -> Self {\n assert!(bit_offset + bit_len <= inner.bit_len());\n BitSlice {\n inner,\n word_offset: bit_offset / I::T::BIT_SIZE,\n bit_offset: (bit_offset % I::T::BIT_SIZE) as u32,\n bit_length: bit_len,\n }\n }\n}\n\nimpl BitSlice\nwhere\n I: BitRead,\n{\n // Iterates over each underlying transport item in the slice\n //pub fn word_iter(&self) -> BitSliceWordIter {\n // BitSliceWordIter {\n // slice: self,\n // idx: 0,\n // rem: self.bit_length + 8,\n // }\n //}\n}\n\nimpl Eq for BitSlice where I: BitRead {}\nimpl PartialEq for BitSlice\nwhere\n I: BitRead,\n O: BitRead,\n T: BitTransport,\n{\n fn eq(&self, other: &O) -> bool {\n if self.bit_len() != other.bit_len() {\n return false;\n }\n self.iter_words().eq(other.iter_words())\n }\n}\n\nimpl PartialOrd for BitSlice\nwhere\n I: BitRead,\n O: BitRead,\n T: BitTransport,\n{\n fn partial_cmp(&self, other: &O) -> Option {\n match self.iter_words().cmp(other.iter_words()) {\n Ordering::Equal => (),\n non_eq => return Some(non_eq),\n }\n Some(self.bit_len().cmp(&other.bit_len()))\n }\n}\nimpl Ord for BitSlice\nwhere\n I: BitRead,\n{\n fn cmp(&self, other: &Self) -> Ordering {\n self.partial_cmp(other).unwrap()\n }\n}\n\nimpl Hash for BitSlice\nwhere\n I: BitRead,\n{\n fn hash(&self, state: &mut H)\n where\n H: Hasher,\n {\n self.bit_len().hash(state);\n for elem in self.iter_words() {\n elem.hash(state);\n }\n }\n}\n\n//impl Eq for BitSlice where I: BitRead, T: BitTransport {}\n//impl PartialEq for BitSlice where I: BitRead, T: BitTransport {\n// fn eq(&self, other: &Self) -> bool {\n// if self.bit_length != other.bit_length { return false; }\n// self.word_iter().eq(other.word_iter())\n// }\n//}\n//\n//impl Ord for BitSlice where I: BitRead, T: BitTransport {\n// fn cmp(&self, other: &Self) -> Ordering {\n// match self.word_iter().cmp(other.word_iter()) {\n// Ordering::Equal => (),\n// non_eq => return non_eq,\n// }\n//\n// self.bit_length.cmp(&other.bit_length)\n// }\n//}\n//impl PartialOrd for BitSlice where I: BitRead, T: BitTransport {\n// fn partial_cmp(&self, other: &Self) -> Option {\n// Some(self.cmp(other))\n// }\n//}\n//\n//impl Hash for BitSlice where I: BitRead, T: BitTransport {\n// fn hash(&self, state: &mut H) where H: Hasher {\n// self.bit_length.hash(state);\n// for elem in self.word_iter() {\n// elem.hash(state);\n// }\n// }\n//}\n" }, { "path": "util/libeir_util_datastructures/Cargo.toml", "content": "[package]\nname = \"libeir_util_datastructures\"\nversion = \"0.1.0\"\nauthors = [\"Hans Elias B. Josephsen \"]\nedition = \"2018\"\nlicense = \"MIT OR Apache-2.0\"\n\n# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html\n\n[dependencies]\ncranelift-entity = \"0.56.0\"\ncranelift-bforest = { git = \"https://github.com/hansihe/wasmtime.git\", branch = \"main\" }\nhashbrown = { git = \"https://github.com/rust-lang/hashbrown.git\", features = [\"raw\", \"nightly\"] }\n" }, { "path": "util/libeir_util_datastructures/src/aux_hash_map.rs", "content": "use std::alloc::{Allocator, Global};\nuse std::borrow::Borrow;\nuse std::collections::hash_map::RandomState;\nuse std::fmt::Debug;\nuse std::hash::{BuildHasher, Hasher};\nuse std::marker::PhantomData;\n\nuse crate::aux_traits::{AuxEq, AuxHash};\n\n//use cranelift_entity::{ListPool, EntityList, EntityRef};\n//use cranelift_entity::packed_option::ReservedValue;\n\nuse hashbrown::raw::{RawIter, RawTable};\n\n//impl AuxHash for T where T: Hash {\n// fn aux_hash(&self, state: &mut H, _container: &C) {\n// self.hash(state)\n// }\n//}\n//impl AuxHash> for EntityList\n//where\n// E: EntityRef + ReservedValue + Hash\n//{\n// fn aux_hash(&self, state: &mut H, container: &ListPool) {\n// self.as_slice(container).hash(state)\n// }\n//}\n\n//impl AuxEq for T where T: Eq {\n// fn aux_eq(&self, other: &Self, _container: &C) -> bool {\n// self.eq(other)\n// }\n// fn aux_ne(&self, other: &Self, _container: &C) -> bool {\n// self.ne(other)\n// }\n//}\n//impl AuxEq> for EntityList\n//where\n// E: EntityRef + ReservedValue + Eq\n//{\n// fn aux_eq(&self, other: &Self, container: &ListPool) -> bool {\n// self.as_slice(container) == other.as_slice(container)\n// }\n//}\n\n/// Implementation of a HashMap where the hash/equality functions\n/// requires additional information.\n#[derive(Clone)]\npub struct AuxHashMap\nwhere\n A: Clone + Allocator,\n{\n hash_builder: S,\n table: RawTable<(K, V), A>,\n aux: PhantomData,\n}\n\nimpl AuxHashMap {\n #[inline]\n pub fn new() -> Self {\n Self::default()\n }\n}\n\nimpl AuxHashMap {\n #[inline]\n pub fn with_hasher(hash_builder: S) -> Self {\n Self {\n hash_builder,\n table: RawTable::new_in(Global),\n aux: PhantomData,\n }\n }\n\n #[inline]\n pub fn iter(&self) -> Iter<'_, K, V> {\n unsafe {\n Iter {\n inner: self.table.iter(),\n marker: PhantomData,\n }\n }\n }\n}\n\n#[inline]\nfn make_hash + ?Sized>(\n hash_builder: &impl BuildHasher,\n container: &C,\n val: &K,\n) -> u64 {\n let mut state = hash_builder.build_hasher();\n val.aux_hash(&mut state, container);\n state.finish()\n}\n\nimpl AuxHashMap\nwhere\n K: AuxEq + AuxHash,\n S: BuildHasher,\n{\n #[inline]\n pub fn try_insert(&mut self, k: K, v: V, container: &C) -> Result<(), ()> {\n let hash = make_hash(&self.hash_builder, container, &k);\n if let Some(_item) = self\n .table\n .find(hash, |x| k.aux_eq(&x.0, container, container))\n {\n Err(())\n } else {\n let hash_builder = &self.hash_builder;\n self.table\n .insert(hash, (k, v), |x| make_hash(hash_builder, container, &x.0));\n Ok(())\n }\n }\n\n #[inline]\n pub fn get(&self, k: &Q, container: &C) -> Option<&V>\n where\n K: Borrow,\n Q: AuxHash + AuxEq,\n {\n self.get_key_value(k, container).map(|(_, v)| v)\n }\n\n #[inline]\n pub fn get_key_value(&self, k: &Q, container: &C) -> Option<(&K, &V)>\n where\n K: Borrow,\n Q: AuxHash + AuxEq,\n {\n let hash = make_hash(&self.hash_builder, container, k);\n self.table\n .find(hash, |x| k.aux_eq(x.0.borrow(), container, container))\n .map(|item| unsafe {\n let &(ref key, ref value) = item.as_ref();\n (key, value)\n })\n }\n}\n\nimpl Default for AuxHashMap\nwhere\n S: BuildHasher + Default,\n{\n #[inline]\n fn default() -> Self {\n Self::with_hasher(Default::default())\n }\n}\n\nimpl Debug for AuxHashMap\nwhere\n K: Debug,\n V: Debug,\n S: BuildHasher,\n{\n fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {\n f.debug_map().entries(self.iter()).finish()\n }\n}\n\n#[derive(Clone)]\npub struct Iter<'a, K, V> {\n inner: RawIter<(K, V)>,\n marker: PhantomData<(&'a K, &'a V)>,\n}\nimpl<'a, K, V> Iterator for Iter<'a, K, V> {\n type Item = (&'a K, &'a V);\n\n #[inline]\n fn next(&mut self) -> Option<(&'a K, &'a V)> {\n self.inner.next().map(|x| unsafe {\n let r = x.as_ref();\n (&r.0, &r.1)\n })\n }\n #[inline]\n fn size_hint(&self) -> (usize, Option) {\n self.inner.size_hint()\n }\n}\n\n#[cfg(test)]\nmod tests {\n\n //use super::{ AuxHashMap, AuxHash };\n //use std::hash::{ Hash, Hasher };\n\n //#[test]\n //fn test_deduped_entity() {\n\n // #[derive(PartialEq, Eq)]\n // struct Key(usize);\n // impl AuxHash for Key {\n // fn aux_hash(&self, state: &mut H, container: &AuxData) {\n // assert!(container.0 == 11);\n // self.0.hash(state)\n // }\n // }\n\n // struct AuxData(usize);\n\n // let mut map: AuxHashMap = AuxHashMap::new();\n // let aux = AuxData(11);\n\n // map.try_insert(Key(1), 1, &aux).unwrap();\n // map.try_insert(Key(1), 1, &aux).err().unwrap();\n\n // map.try_insert(Key(2), 2, &aux).unwrap();\n // map.try_insert(Key(2), 2, &aux).err().unwrap();\n\n // map.try_insert(Key(1), 1, &aux).err().unwrap();\n\n // assert!(map.get(&Key(1), &aux) == Some(&1));\n // assert!(map.get(&Key(2), &aux) == Some(&2));\n\n //}\n}\n" }, { "path": "util/libeir_util_datastructures/src/aux_traits/bforest_impl.rs", "content": "use super::{AuxDebug, AuxImpl, HasAux};\nuse cranelift_bforest::{Set, SetForest};\nuse std::fmt::{Formatter, Result as FmtResult};\n\nimpl, C: HasAux>> AuxDebug for Set {\n fn aux_fmt(&self, f: &mut Formatter<'_>, aux: &C) -> FmtResult {\n let iaux = aux.get_aux();\n let mut b = f.debug_set();\n for val in self.iter(iaux) {\n b.entry(&AuxImpl(&val, aux));\n }\n b.finish()\n }\n}\n" }, { "path": "util/libeir_util_datastructures/src/aux_traits/entity_impl.rs", "content": "use super::{AuxDebug, AuxImpl, HasAux};\nuse cranelift_entity::packed_option::ReservedValue;\nuse cranelift_entity::{EntityList, EntityRef, ListPool, PrimaryMap, SecondaryMap};\nuse std::fmt::{Debug, Formatter, Result as FmtResult};\n\nimpl>, E: EntityRef + ReservedValue + Debug> AuxDebug for EntityList {\n fn aux_fmt(&self, f: &mut Formatter<'_>, aux: &C) -> FmtResult {\n let mut b = f.debug_list();\n b.entries(self.as_slice(aux.get_aux()));\n b.finish()\n }\n}\n\nimpl, C> AuxDebug for PrimaryMap {\n fn aux_fmt(&self, f: &mut Formatter<'_>, aux: &C) -> FmtResult {\n let mut b = f.debug_map();\n b.entries(self.iter().map(|(k, v)| (k, AuxImpl(v, aux))));\n b.finish()\n }\n}\n\nimpl + Clone, C> AuxDebug for SecondaryMap {\n fn aux_fmt(&self, f: &mut Formatter<'_>, aux: &C) -> FmtResult {\n let mut b = f.debug_map();\n b.entries(self.iter().map(|(k, v)| (k, AuxImpl(v, aux))));\n b.finish()\n }\n}\n" }, { "path": "util/libeir_util_datastructures/src/aux_traits/mod.rs", "content": "use std::fmt::{Debug, Formatter, Result as FmtResult};\nuse std::hash::{Hash, Hasher};\n\nmod bforest_impl;\nmod entity_impl;\nmod std_impl;\n\npub trait HasAux {\n fn get_aux(&self) -> &Inner;\n}\nimpl HasAux for T {\n fn get_aux(&self) -> &Self {\n self\n }\n}\nimpl HasAux for &T {\n fn get_aux(&self) -> &T {\n *self\n }\n}\n\npub trait AuxDebug {\n fn aux_fmt(&self, f: &mut Formatter<'_>, container: &Aux) -> FmtResult;\n}\n\n/// Hashes a data type with access to auxiliary data\npub trait AuxHash {\n fn aux_hash(&self, state: &mut H, container: &Aux);\n}\n\n/// Tests equality with access to auxiliary data\npub trait AuxEq {\n fn aux_eq(&self, other: &Self, self_container: &Aux, other_container: &Aux) -> bool;\n fn aux_ne(&self, other: &Self, self_container: &Aux, other_container: &Aux) -> bool {\n !self.aux_eq(other, self_container, other_container)\n }\n}\n\npub struct AuxImpl<'a, V, Aux>(pub &'a V, pub &'a Aux);\nimpl<'a, V: AuxDebug, Aux> Debug for AuxImpl<'a, V, Aux> {\n fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {\n self.0.aux_fmt(f, self.1)\n }\n}\nimpl<'a, V: AuxHash, Aux> Hash for AuxImpl<'a, V, Aux> {\n fn hash(&self, state: &mut H) {\n self.0.aux_hash(state, self.1)\n }\n}\nimpl<'a, V: AuxEq, Aux> PartialEq for AuxImpl<'a, V, Aux> {\n fn eq(&self, rhs: &Self) -> bool {\n self.0.aux_eq(rhs.0, self.1, rhs.1)\n }\n}\nimpl<'a, V: AuxEq, Aux> Eq for AuxImpl<'a, V, Aux> {}\n\n#[macro_export]\nmacro_rules! aux_container_impl {\n ($typ:ty) => {\n impl std::fmt::Debug for $typ {\n fn debug(&self, formatter: std::fmt::Formatter) -> std::fmt::Result {\n $crate::aux_traits::AuxDebug::fmt(self, formatter, self)\n }\n }\n impl std::hash::Hash for $typ {\n fn hash(&self, hasher: &mut H) {\n $crate::aux_traits::AuxHash::fmt(self, hasher, self)\n }\n }\n impl PartialEq for $typ {\n fn eq(&self, other: &Self) {\n $crate::aux_traits::AuxEq::eq(self, other, self, other)\n }\n }\n impl Eq for $typ {}\n };\n}\n" }, { "path": "util/libeir_util_datastructures/src/aux_traits/std_impl/mod.rs", "content": "use super::{AuxDebug, AuxEq, AuxHash, AuxImpl, HasAux};\nuse std::collections::HashMap;\nuse std::fmt::{Debug, Formatter, Result as FmtResult};\nuse std::hash::{Hash, Hasher};\n\nimpl, C> AuxDebug for Option {\n fn aux_fmt(&self, f: &mut Formatter<'_>, aux: &C) -> FmtResult {\n self.as_ref().map(|v| AuxImpl(v, aux)).fmt(f)\n }\n}\nimpl, Aux> AuxHash for Option {\n fn aux_hash(&self, state: &mut H, aux: &Aux) {\n self.as_ref().map(|v| AuxImpl(v, aux)).hash(state)\n }\n}\nimpl, Aux> AuxEq for Option {\n fn aux_eq(&self, other: &Self, self_aux: &Aux, other_aux: &Aux) -> bool {\n let l = self.as_ref().map(|v| AuxImpl(v, self_aux));\n let r = other.as_ref().map(|v| AuxImpl(v, other_aux));\n l.eq(&r)\n }\n}\n\nimpl, V: AuxDebug> AuxDebug for HashMap {\n fn aux_fmt(&self, f: &mut Formatter<'_>, aux: &C) -> FmtResult {\n let mut b = f.debug_map();\n b.entries(\n self.iter()\n .map(|(k, v)| (AuxImpl(k, aux.get_aux()), AuxImpl(v, aux.get_aux()))),\n );\n b.finish()\n }\n}\n\nmacro_rules! impl_regular {\n ($typ:ty) => {\n impl AuxDebug for $typ {\n fn aux_fmt(&self, f: &mut Formatter<'_>, _aux: &C) -> FmtResult {\n Debug::fmt(self, f)\n }\n }\n impl AuxHash for $typ {\n fn aux_hash(&self, f: &mut H, _aux: &C) {\n Hash::hash(self, f)\n }\n }\n impl AuxEq for $typ {\n fn aux_eq(&self, rhs: &$typ, _aux: &C, _rhs_aux: &C) -> bool {\n self.eq(rhs)\n }\n }\n };\n}\n\nimpl_regular!(());\nimpl_regular!(u8);\nimpl_regular!(i8);\nimpl_regular!(u16);\nimpl_regular!(i16);\nimpl_regular!(u32);\nimpl_regular!(i32);\nimpl_regular!(u64);\nimpl_regular!(i64);\nimpl_regular!(usize);\nimpl_regular!(isize);\nimpl_regular!(char);\n" }, { "path": "util/libeir_util_datastructures/src/dedup_aux_primary_map.rs", "content": "use std::ops::Index;\n\nuse cranelift_entity::{EntityRef, PrimaryMap};\n\nuse crate::aux_hash_map::AuxHashMap;\nuse crate::aux_traits::{AuxEq, AuxHash};\n\npub type DedupPrimaryMap = DedupAuxPrimaryMap;\n\n#[derive(Debug, Clone)]\npub struct DedupAuxPrimaryMap\nwhere\n K: EntityRef,\n V: AuxHash + AuxEq,\n{\n forward: PrimaryMap,\n backward: AuxHashMap,\n}\n\nimpl DedupAuxPrimaryMap\nwhere\n K: EntityRef,\n V: AuxHash + AuxEq,\n{\n pub fn new() -> Self {\n DedupAuxPrimaryMap {\n forward: PrimaryMap::new(),\n backward: AuxHashMap::new(),\n }\n }\n\n pub fn push(&mut self, v: V, c: &C) -> K\n where\n V: Clone,\n {\n if let Some(k) = self.backward.get(&v, c) {\n *k\n } else {\n let k = self.forward.push(v.clone());\n self.backward.try_insert(v, k, c).unwrap();\n k\n }\n }\n}\n\nimpl Index for DedupAuxPrimaryMap\nwhere\n K: EntityRef,\n V: AuxHash + AuxEq,\n{\n type Output = V;\n fn index(&self, key: K) -> &V {\n &self.forward[key]\n }\n}\n" }, { "path": "util/libeir_util_datastructures/src/forest.rs", "content": "//use cranelift_bforest::{Set, SetForest};\n//\n//pub struct BoundSet<'a, K: Copy, C> {\n// set: &'a Set,\n// forest: &'a SetForest,\n// comp: &'a C,\n//}\n//\n//impl BoundSet {\n//\n// pub fn\n//\n//}\n" }, { "path": "util/libeir_util_datastructures/src/hashmap_stack.rs", "content": "use ::std::collections::HashMap;\nuse ::std::fmt::Debug;\nuse ::std::hash::Hash;\nuse ::std::ops::Index;\n\npub struct HashMapStack {\n stack: Vec>,\n}\n\nimpl HashMapStack\nwhere\n K: Hash + Eq,\n{\n pub fn new() -> Self {\n HashMapStack { stack: vec![] }\n }\n\n pub fn push(&mut self) {\n self.stack.push(HashMap::new());\n }\n\n pub fn pop(&mut self) {\n if self.stack.len() == 0 {\n panic!(\"attempt too pop from empty HashMapStack\");\n }\n\n self.stack.pop();\n }\n\n pub fn layer(&self, n: usize) -> &HashMap {\n &self.stack[n]\n }\n\n pub fn insert(&mut self, key: K, value: V) {\n self.stack\n .last_mut()\n .expect(\"attempt to insert into empty HashMapStack\")\n .insert(key, value);\n }\n\n pub fn get<'a>(&self, key: &K) -> Option<&V> {\n self.resolve_first(|l| l.get(key))\n }\n\n pub fn contains_key(&self, key: &K) -> bool {\n let resolved = self.resolve_first(|l| match l.contains_key(key) {\n true => Some(()),\n false => None,\n });\n resolved == Some(())\n }\n\n pub fn height(&self) -> usize {\n self.stack.len()\n }\n\n pub fn resolve_first<'a, F, T>(&'a self, resolver: F) -> Option\n where\n F: Fn(&'a HashMap) -> Option,\n T: 'a,\n {\n for level in self.stack.iter().rev() {\n if let Some(inner) = resolver(level) {\n return Some(inner);\n }\n }\n None\n }\n\n pub fn flatten(&self) -> HashMap<&K, &V> {\n let mut out = HashMap::new();\n\n for level in self.stack.iter() {\n for (key, value) in level {\n out.insert(key, value);\n }\n }\n\n out\n }\n}\n\nimpl HashMapStack\nwhere\n K: Hash + Eq + Clone,\n V: Copy,\n{\n pub fn flatten_clone(&self) -> HashMap {\n let mut out = HashMap::new();\n\n for level in self.stack.iter() {\n for (key, value) in level {\n out.insert(key.clone(), value.clone());\n }\n }\n\n out\n }\n}\n\nimpl<'a, K, V> Index<&'a K> for HashMapStack\nwhere\n K: Eq + Hash,\n{\n type Output = V;\n\n fn index(&self, index: &K) -> &V {\n self.get(index).expect(\"no entry found for key\")\n }\n}\n\nimpl Debug for HashMapStack\nwhere\n K: Debug + Hash + Eq,\n V: Debug,\n{\n fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {\n let flat = self.flatten();\n write!(f, \"{:?}\", flat)\n }\n}\n\n#[cfg(test)]\nmod test {\n use super::HashMapStack;\n\n #[test]\n fn simple() {\n let mut hms = HashMapStack::new();\n\n assert!(!hms.contains_key(&0));\n\n hms.push();\n hms.insert(0u32, 0u32);\n assert!(hms.contains_key(&0));\n\n hms.push();\n hms.insert(1, 0);\n assert!(hms.contains_key(&0));\n assert!(hms[&0] == 0);\n hms.insert(0, 1);\n assert!(hms[&0] == 1);\n assert!(hms[&1] == 0);\n\n hms.pop();\n assert!(hms[&0] == 0);\n assert!(!hms.contains_key(&1));\n\n hms.pop();\n assert!(!hms.contains_key(&0));\n }\n\n #[test]\n #[should_panic]\n fn insert_in_empty() {\n let mut hms = HashMapStack::new();\n hms.insert(0u32, 0u32);\n }\n\n #[test]\n fn flatten() {\n let mut hms = HashMapStack::new();\n\n hms.push();\n hms.insert(0u32, 0u32);\n\n hms.push();\n hms.insert(1, 0);\n\n let flat = hms.flatten_clone();\n assert!(flat.contains_key(&0));\n assert!(flat.contains_key(&1));\n }\n}\n" }, { "path": "util/libeir_util_datastructures/src/lib.rs", "content": "#![deny(warnings)]\n#![feature(allocator_api)]\n\npub mod aux_hash_map;\npub mod aux_traits;\npub mod dedup_aux_primary_map;\npub mod forest;\npub mod hashmap_stack;\npub mod pooled_entity_set;\n" }, { "path": "util/libeir_util_datastructures/src/pooled_entity_set.rs", "content": "use std::fmt::{Debug, Formatter};\nuse std::hash::{Hash, Hasher};\nuse std::marker::PhantomData;\n\nuse cranelift_entity::packed_option::ReservedValue;\nuse cranelift_entity::EntityList;\nuse cranelift_entity::EntityRef;\nuse cranelift_entity::ListPool;\n\nuse crate::aux_traits::{AuxDebug, AuxEq, AuxHash, HasAux};\n\n#[derive(Debug, Clone)]\npub struct EntitySetPool {\n typ: PhantomData,\n pool: ListPool,\n}\nimpl EntitySetPool {\n pub fn new() -> Self {\n EntitySetPool {\n typ: PhantomData,\n pool: ListPool::new(),\n }\n }\n}\n\n#[derive(Debug, Copy, Clone, PartialEq, Eq)]\nstruct PooledSetValue(u64);\n\nimpl ReservedValue for PooledSetValue {\n fn reserved_value() -> Self {\n PooledSetValue(std::u64::MAX)\n }\n}\n\nimpl EntityRef for PooledSetValue {\n fn index(self) -> usize {\n self.0 as usize\n }\n fn new(n: usize) -> Self {\n debug_assert!(n < std::usize::MAX);\n PooledSetValue(n as u64)\n }\n}\n\n#[derive(Debug, Clone)]\npub struct EntitySet\nwhere\n K: EntityRef,\n{\n list: EntityList,\n unused: PhantomData,\n}\n\nimpl>, K: EntityRef + Debug> AuxDebug for EntitySet {\n fn aux_fmt(&self, f: &mut std::fmt::Formatter, aux: &C) -> std::fmt::Result {\n let mut b = f.debug_set();\n b.entries(self.iter(aux.get_aux()));\n b.finish()\n }\n}\nimpl>, K: EntityRef> AuxHash for EntitySet {\n fn aux_hash(&self, hasher: &mut H, aux: &C) {\n let mut n = 0;\n for key in self.iter(aux.get_aux()) {\n key.index().hash(hasher);\n n += 1;\n }\n n.hash(hasher);\n }\n}\nimpl>, K: EntityRef> AuxEq for EntitySet {\n fn aux_eq(&self, other: &Self, self_aux: &C, other_aux: &C) -> bool {\n self.eq_other(other, self_aux.get_aux(), other_aux.get_aux())\n }\n}\n\nimpl Default for EntitySet {\n fn default() -> Self {\n Self {\n list: EntityList::new(),\n unused: PhantomData,\n }\n }\n}\n\nimpl EntitySet\nwhere\n K: EntityRef,\n{\n pub fn new() -> Self {\n Self {\n list: EntityList::new(),\n unused: PhantomData,\n }\n }\n\n pub fn contains(&self, k: K, pool: &EntitySetPool) -> bool {\n let index = k.index();\n\n let list_len = self.list.len(&pool.pool);\n let list_len_entries = list_len * 63;\n\n if index < list_len_entries {\n let list_val = self.list.get(index / 63, &pool.pool).unwrap();\n list_val.0 & (1 << (index % 63)) != 0\n } else {\n false\n }\n }\n\n pub fn size(&self, pool: &EntitySetPool) -> usize {\n let mut len = 0;\n for n in self.list.as_slice(&pool.pool) {\n debug_assert!(n.0 != std::u64::MAX);\n len += n.0.count_ones() as usize;\n }\n len\n }\n\n pub fn clear(&mut self, pool: &mut EntitySetPool) {\n self.list.clear(&mut pool.pool)\n }\n\n //pub fn keys(&self) -> Keys\n\n fn grow_to_pages(&mut self, pages: usize, pool: &mut EntitySetPool) {\n let len = self.list.len(&pool.pool);\n if len < pages {\n // TODO: grow in one go\n for _ in 0..(pages - len) {\n self.list.push(PooledSetValue(0), &mut pool.pool);\n }\n }\n }\n\n pub fn insert(&mut self, k: K, pool: &mut EntitySetPool) -> bool {\n let index = k.index();\n\n let list_len = self.list.len(&pool.pool);\n let needed_list_len = (index / 63) + 1; //(index + 62) / 63;\n\n if list_len < needed_list_len {\n self.grow_to_pages(needed_list_len, pool);\n }\n\n let result = self.contains(k, pool);\n let val = self.list.get_mut(index / 63, &mut pool.pool).unwrap();\n\n val.0 |= 1 << (index % 63);\n\n result\n }\n\n pub fn remove(&mut self, k: K, pool: &mut EntitySetPool) -> bool {\n let index = k.index();\n\n let list_len = self.list.len(&mut pool.pool);\n let list_len_entries = list_len * 63;\n\n if index < list_len_entries {\n let list_val = self.list.get_mut(index / 63, &mut pool.pool).unwrap();\n let bit_idx = 1 << (index % 63);\n let ret = list_val.0 & bit_idx != 0;\n list_val.0 &= !bit_idx;\n ret\n } else {\n false\n }\n }\n\n pub fn make_copy(&self, pool: &mut EntitySetPool) -> EntitySet {\n let mut new_list = EntityList::new();\n\n let len = self.list.len(&pool.pool);\n for n in 0..len {\n let item = self.list.get(n, &pool.pool).unwrap();\n new_list.push(item, &mut pool.pool);\n }\n\n EntitySet {\n list: new_list,\n unused: PhantomData,\n }\n }\n\n pub fn union(&mut self, other: &EntitySet, pool: &mut EntitySetPool) {\n let other_list = &other.list;\n let other_pages_len = other_list.len(&pool.pool);\n self.grow_to_pages(other_pages_len, pool);\n for n in 0..other_pages_len {\n let other_val = other_list.get(n, &pool.pool).unwrap();\n let val_mut = self.list.get_mut(n, &mut pool.pool).unwrap();\n debug_assert!(val_mut.0 != std::u64::MAX);\n debug_assert!(other_val.0 != std::u64::MAX);\n val_mut.0 |= other_val.0;\n }\n }\n\n pub fn iter<'a>(&self, pool: &'a EntitySetPool) -> EntitySetIter<'a, K> {\n EntitySetIter {\n pool: &pool.pool,\n list: self.list.clone(),\n unused: PhantomData,\n current_data: None,\n current: 0,\n finished: false,\n }\n }\n\n pub fn eq(&self, other: &EntitySet, pool: &EntitySetPool) -> bool {\n self.eq_other(other, pool, pool)\n }\n\n pub fn eq_other(\n &self,\n other: &EntitySet,\n pool: &EntitySetPool,\n other_pool: &EntitySetPool,\n ) -> bool {\n let self_list = self.list.as_slice(&pool.pool);\n let other_list = other.list.as_slice(&other_pool.pool);\n\n // Check common head\n for (a, b) in self_list.iter().zip(other_list) {\n debug_assert!(a.0 != std::u64::MAX);\n debug_assert!(b.0 != std::u64::MAX);\n if a != b {\n return false;\n }\n }\n\n // If the length differs, validate that the tail is empty\n match (self_list.len(), other_list.len()) {\n (a, b) if a > b => {\n for n in &self_list[b..] {\n debug_assert!(n.0 != std::u64::MAX);\n if n.0 != 0 {\n return false;\n }\n }\n }\n (a, b) if a < b => {\n for n in &other_list[a..] {\n debug_assert!(n.0 != std::u64::MAX);\n if n.0 != 0 {\n return false;\n }\n }\n }\n _ => (),\n }\n\n true\n }\n\n pub fn bind<'a>(&self, pool: &'a EntitySetPool) -> BoundEntitySet<'a, K> {\n BoundEntitySet {\n set: self.clone(),\n pool,\n }\n }\n}\n\n#[derive(Clone)]\npub struct BoundEntitySet<'a, K: EntityRef> {\n set: EntitySet,\n pool: &'a EntitySetPool,\n}\nimpl<'a, K: EntityRef> BoundEntitySet<'a, K> {\n pub fn contains(&self, k: K) -> bool {\n self.set.contains(k, self.pool)\n }\n\n pub fn size(&self) -> usize {\n self.set.size(self.pool)\n }\n\n pub fn iter(&self) -> EntitySetIter<'_, K> {\n self.set.iter(self.pool)\n }\n}\nimpl<'a, K: EntityRef> IntoIterator for &'a BoundEntitySet<'a, K> {\n type Item = K;\n type IntoIter = EntitySetIter<'a, K>;\n fn into_iter(self) -> EntitySetIter<'a, K> {\n BoundEntitySet::iter(self)\n }\n}\nimpl<'a, K> Debug for BoundEntitySet<'a, K>\nwhere\n K: EntityRef + Debug,\n{\n fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {\n f.debug_set().entries(self.set.iter(self.pool)).finish()\n }\n}\nimpl<'a, K: EntityRef> PartialEq for BoundEntitySet<'a, K> {\n fn eq(&self, rhs: &BoundEntitySet) -> bool {\n self.set.eq_other(&rhs.set, self.pool, &rhs.pool)\n }\n}\nimpl<'a, K: EntityRef> Eq for BoundEntitySet<'a, K> {}\n\npub struct EntitySetIter<'a, T>\nwhere\n T: EntityRef,\n{\n pool: &'a ListPool,\n list: EntityList,\n unused: PhantomData,\n current_data: Option,\n current: usize,\n finished: bool,\n}\nimpl<'a, T> Iterator for EntitySetIter<'a, T>\nwhere\n T: EntityRef,\n{\n type Item = T;\n #[inline]\n fn next(&mut self) -> Option {\n loop {\n if self.finished {\n return None;\n }\n let rem = self.current % 63;\n if rem == 0 {\n self.current_data = self.list.get(self.current / 63, self.pool);\n if let Some(current_data) = self.current_data {\n if current_data.0 == 0 {\n self.current += 63;\n continue;\n }\n } else {\n self.finished = true;\n return None;\n }\n }\n\n if (self.current_data.unwrap().0 & (1 << rem)) != 0 {\n let ret = Some(T::new(self.current));\n self.current += 1;\n return ret;\n } else {\n self.current += 1;\n }\n }\n }\n}\n\n#[cfg(test)]\nmod test {\n use super::EntitySet;\n use super::EntitySetPool;\n\n use ::cranelift_entity::entity_impl;\n\n /// Basic block in function\n #[derive(Copy, Clone, Hash, PartialEq, Eq, PartialOrd, Ord)]\n pub struct TestEntity(u32);\n entity_impl!(TestEntity, \"test_entity\");\n\n #[test]\n fn test_pooled_set() {\n let mut pool = EntitySetPool::new();\n\n let mut set1: EntitySet = EntitySet::new();\n\n assert!(!set1.contains(TestEntity(0), &mut pool));\n assert!(!set1.contains(TestEntity(1), &mut pool));\n assert!(!set1.contains(TestEntity(2), &mut pool));\n assert!(!set1.contains(TestEntity(9999), &mut pool));\n\n set1.insert(TestEntity(2), &mut pool);\n assert!(!set1.contains(TestEntity(0), &mut pool));\n assert!(!set1.contains(TestEntity(1), &mut pool));\n assert!(set1.contains(TestEntity(2), &mut pool));\n assert!(!set1.contains(TestEntity(3), &mut pool));\n\n set1.insert(TestEntity(62), &mut pool);\n set1.insert(TestEntity(63), &mut pool);\n\n set1.insert(TestEntity(200), &mut pool);\n assert!(!set1.contains(TestEntity(0), &mut pool));\n assert!(set1.contains(TestEntity(2), &mut pool));\n assert!(!set1.contains(TestEntity(199), &mut pool));\n assert!(set1.contains(TestEntity(200), &mut pool));\n assert!(!set1.contains(TestEntity(201), &mut pool));\n\n set1.insert(TestEntity(10), &mut pool);\n assert!(set1.contains(TestEntity(200), &mut pool));\n\n set1.remove(TestEntity(200), &mut pool);\n assert!(!set1.contains(TestEntity(200), &mut pool));\n assert!(set1.contains(TestEntity(10), &mut pool));\n assert!(!set1.contains(TestEntity(9), &mut pool));\n assert!(set1.contains(TestEntity(2), &mut pool));\n assert!(!set1.contains(TestEntity(200), &mut pool));\n\n set1.remove(TestEntity(2), &mut pool);\n assert!(!set1.contains(TestEntity(2), &mut pool));\n assert!(set1.contains(TestEntity(10), &mut pool));\n\n let mut set2: EntitySet = EntitySet::new();\n\n for i in 2..200 {\n println!(\"{}\", i);\n assert!(!set2.contains(TestEntity(i - 1), &mut pool));\n assert!(!set2.contains(TestEntity(i), &mut pool));\n assert!(!set2.contains(TestEntity(i + 1), &mut pool));\n set2.insert(TestEntity(i), &mut pool);\n assert!(!set2.contains(TestEntity(i - 1), &mut pool));\n assert!(set2.contains(TestEntity(i), &mut pool));\n assert!(!set2.contains(TestEntity(i + 1), &mut pool));\n set2.remove(TestEntity(i), &mut pool);\n assert!(!set2.contains(TestEntity(i - 1), &mut pool));\n assert!(!set2.contains(TestEntity(i), &mut pool));\n assert!(!set2.contains(TestEntity(i + 1), &mut pool));\n }\n }\n\n #[test]\n fn test_pooled_set_remove() {\n let mut pool = EntitySetPool::new();\n\n let mut set1: EntitySet = EntitySet::new();\n\n assert!(!set1.remove(TestEntity(2), &mut pool));\n assert!(!set1.remove(TestEntity(100), &mut pool));\n set1.insert(TestEntity(2), &mut pool);\n assert!(set1.remove(TestEntity(2), &mut pool));\n assert!(!set1.remove(TestEntity(2), &mut pool));\n set1.insert(TestEntity(100), &mut pool);\n assert!(!set1.remove(TestEntity(2), &mut pool));\n assert!(set1.remove(TestEntity(100), &mut pool));\n assert!(!set1.remove(TestEntity(99), &mut pool));\n assert!(!set1.remove(TestEntity(2), &mut pool));\n }\n\n #[test]\n fn test_pooled_set_eq() {\n let mut pool = EntitySetPool::new();\n\n let mut set1: EntitySet = EntitySet::new();\n let mut set2: EntitySet = EntitySet::new();\n\n assert!(set1.eq(&set2, &pool));\n\n set1.insert(TestEntity(2), &mut pool);\n assert!(!set1.eq(&set2, &pool));\n assert!(!set2.eq(&set1, &pool));\n\n set2.insert(TestEntity(2), &mut pool);\n assert!(set1.eq(&set2, &pool));\n assert!(set2.eq(&set1, &pool));\n\n set2.insert(TestEntity(100), &mut pool);\n assert!(!set1.eq(&set2, &pool));\n assert!(!set2.eq(&set1, &pool));\n\n set1.insert(TestEntity(100), &mut pool);\n assert!(set1.eq(&set2, &pool));\n assert!(set2.eq(&set1, &pool));\n }\n\n #[test]\n fn test_iterator() {\n let mut pool = EntitySetPool::new();\n let mut set1: EntitySet = EntitySet::new();\n\n set1.insert(TestEntity(5), &mut pool);\n set1.insert(TestEntity(62), &mut pool);\n set1.insert(TestEntity(63), &mut pool);\n set1.insert(TestEntity(64), &mut pool);\n set1.insert(TestEntity(500), &mut pool);\n set1.insert(TestEntity(501), &mut pool);\n set1.insert(TestEntity(502), &mut pool);\n set1.insert(TestEntity(503), &mut pool);\n set1.insert(TestEntity(504), &mut pool);\n set1.insert(TestEntity(505), &mut pool);\n set1.insert(TestEntity(506), &mut pool);\n set1.insert(TestEntity(507), &mut pool);\n set1.insert(TestEntity(508), &mut pool);\n set1.insert(TestEntity(509), &mut pool);\n set1.insert(TestEntity(510), &mut pool);\n set1.insert(TestEntity(511), &mut pool);\n set1.insert(TestEntity(512), &mut pool);\n\n let mut iter = set1.iter(&pool);\n assert!(iter.next() == Some(TestEntity(5)));\n assert!(iter.next() == Some(TestEntity(62)));\n assert!(iter.next() == Some(TestEntity(63)));\n assert!(iter.next() == Some(TestEntity(64)));\n assert!(iter.next() == Some(TestEntity(500)));\n assert!(iter.next() == Some(TestEntity(501)));\n assert!(iter.next() == Some(TestEntity(502)));\n assert!(iter.next() == Some(TestEntity(503)));\n assert!(iter.next() == Some(TestEntity(504)));\n assert!(iter.next() == Some(TestEntity(505)));\n assert!(iter.next() == Some(TestEntity(506)));\n assert!(iter.next() == Some(TestEntity(507)));\n assert!(iter.next() == Some(TestEntity(508)));\n assert!(iter.next() == Some(TestEntity(509)));\n assert!(iter.next() == Some(TestEntity(510)));\n assert!(iter.next() == Some(TestEntity(511)));\n assert!(iter.next() == Some(TestEntity(512)));\n assert!(iter.next() == None);\n assert!(iter.next() == None);\n }\n}\n" }, { "path": "util/libeir_util_dot_graph/Cargo.toml", "content": "[package]\nname = \"libeir_util_dot_graph\"\nversion = \"0.1.0\"\nauthors = [\"Hans Elias B. Josephsen \"]\nedition = \"2018\"\n\n# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html\n\n[dependencies]\n" }, { "path": "util/libeir_util_dot_graph/src/lib.rs", "content": "#![feature(allocator_api)]\n\nuse std::fmt::Display;\nuse std::fmt::{Error, Write};\nuse std::path::Path;\n\n//mod tablegen;\n\nconst DOT_BREAK: &str = \"
\";\n\nfn format_label(label: &str, out: &mut String) {\n for c in label.chars() {\n match c {\n '{' => out.push_str(\"\\\\{\"),\n '}' => out.push_str(\"\\\\}\"),\n '|' => out.push_str(\"\\\\|\"),\n '>' => out.push_str(\">\"),\n '<' => out.push_str(\"<\"),\n '&' => out.push_str(\"&\"),\n '\"' => out.push_str(\""\"),\n '\\n' => out.push_str(DOT_BREAK),\n c => out.push(c),\n }\n }\n}\n\npub trait NodeId {\n fn make_id(&self, out: &mut String);\n}\nimpl NodeId for &str {\n fn make_id(&self, out: &mut String) {\n out.push_str(self);\n }\n}\n\n/// Newtype that implements NodeId for any Display type\n#[derive(Copy, Clone)]\npub struct DisplayNid(pub I);\nimpl NodeId for DisplayNid {\n fn make_id(&self, out: &mut String) {\n write!(out, \"{}\", self.0).unwrap();\n }\n}\n\n/// Adds a prefix to a NodeId\n#[derive(Copy, Clone)]\npub struct PrefixedNid(pub P, pub I);\nimpl NodeId for PrefixedNid {\n fn make_id(&self, out: &mut String) {\n write!(out, \"{}_\", self.0).unwrap();\n self.1.make_id(out);\n }\n}\n\n/// References a subpart of a node\n#[derive(Copy, Clone)]\npub struct SubNid(pub I, pub S);\nimpl NodeId for SubNid {\n fn make_id(&self, out: &mut String) {\n self.0.make_id(out);\n write!(out, \":{}\", self.1).unwrap();\n }\n}\n\npub trait ContentFormatting {\n fn make_raw(&self, out: &mut String);\n}\nimpl ContentFormatting for &str {\n fn make_raw(&self, out: &mut String) {\n format_label(self, out);\n }\n}\n\npub trait Content {\n fn make_raw(&self, out: &mut String);\n}\nimpl Content for &str {\n fn make_raw(&self, out: &mut String) {\n format_label(self, out);\n }\n}\n\npub struct StructuredNode {}\nimpl StructuredNode {\n pub fn text(&mut self, _content: F) {}\n pub fn vertical(&mut self, _cells: &[()]) {}\n pub fn horizontal(&mut self, _cells: &[()]) {}\n}\n\npub struct GraphPrinter {\n out: O,\n id_buf: Option,\n error: Result<(), Error>,\n}\n\nimpl GraphPrinter {\n pub fn new() -> Self {\n Self::with_out(String::new())\n }\n\n pub fn finish_run_dot(self, out: &Path) {\n let dot_res = self.finish().unwrap();\n\n let dir = std::env::temp_dir();\n\n let mut dot_path = dir.clone();\n dot_path.push(\"out.dot\");\n {\n let mut dot_file = std::fs::File::create(&dot_path).unwrap();\n use std::io::Write;\n dot_file.write(dot_res.as_bytes()).unwrap();\n }\n\n let ext = out.extension().unwrap();\n\n use std::process::Command;\n let res = Command::new(\"dot\")\n .args(&[\n \"-o\",\n out.to_str().unwrap(),\n \"-T\",\n ext.to_str().unwrap(),\n dot_path.to_str().unwrap(),\n ])\n .output()\n .expect(\"failed to execute dot\");\n\n if !res.status.success() {\n println!(\"status: {}\", res.status);\n println!(\"stdout: {}\", std::str::from_utf8(&res.stdout).unwrap());\n println!(\"stderr: {}\", std::str::from_utf8(&res.stderr).unwrap());\n panic!();\n }\n }\n}\n\nimpl GraphPrinter {\n pub fn with_out(out: O) -> Self {\n let mut g = GraphPrinter {\n out,\n id_buf: Some(String::new()),\n error: Ok(()),\n };\n g.w(|w| {\n write!(w, \"digraph g {{\\n\")?;\n write!(\n w,\n \"node [labeljust=\\\"l\\\", shape=record, fontname=\\\"Courier New\\\"]\\n\"\n )?;\n write!(w, \"edge [fontname=\\\"Courier New\\\" ]\\n\\n\")?;\n Ok(())\n });\n g\n }\n\n pub fn finish(mut self) -> Result {\n self.w(|w| {\n write!(w, \"}}\\n\")?;\n Ok(())\n });\n let error = self.error;\n let out = self.out;\n error.map(|_| out)\n }\n\n pub fn node(&mut self, id: I, label: &str)\n where\n I: NodeId,\n {\n let mut id_buf = self.id_buf.take().unwrap();\n\n id_buf.clear();\n id.make_id(&mut id_buf);\n self.w(|w| {\n write!(w, \"{} [ label=<\", &id_buf)?;\n Ok(())\n });\n\n id_buf.clear();\n format_label(label, &mut id_buf);\n self.w(|w| {\n write!(w, \"{}> ];\\n\", &id_buf)?;\n Ok(())\n });\n\n self.id_buf = Some(id_buf);\n }\n\n pub fn edge(&mut self, from: I1, to: I2, label: &str)\n where\n I1: NodeId,\n I2: NodeId,\n {\n let mut id_buf = self.id_buf.take().unwrap();\n\n id_buf.clear();\n from.make_id(&mut id_buf);\n self.w(|w| {\n write!(w, \"{} -> \", &id_buf)?;\n Ok(())\n });\n\n id_buf.clear();\n to.make_id(&mut id_buf);\n self.w(|w| {\n write!(w, \"{} \", &id_buf)?;\n Ok(())\n });\n\n id_buf.clear();\n format_label(label, &mut id_buf);\n self.w(|w| {\n write!(w, \"[ label=<{}> ];\\n\", id_buf)?;\n Ok(())\n });\n\n self.id_buf = Some(id_buf);\n }\n\n fn w(&mut self, f: F)\n where\n F: FnOnce(&mut O) -> Result<(), Error>,\n {\n if self.error.is_ok() {\n self.error = f(&mut self.out);\n }\n }\n}\n\n//#[allow(clippy::write_with_newline)]\n//pub fn function_to_dot(fun: &Function, w: &mut dyn Write) -> ::std::io::Result<()> {\n// let mut to_eir_ctx = ToEirTextContext::new();\n//\n// write!(w, \"digraph g {{\\n\")?;\n// write!(w, \"node [labeljust=\\\"l\\\", shape=record, fontname=\\\"Courier New\\\"]\\n\")?;\n// write!(w, \"edge [fontname=\\\"Courier New\\\" ]\\n\\n\")?;\n//\n// let fun_name = format_label(&format!(\"{}\", fun.ident()));\n// write!(w, \"entry [ label= ];\\n\",\n// fun_name)?;\n// write!(w, \"entry -> blk_{};\\n\\n\", fun.block_entry())?;\n//\n// let mut buf = Vec::new();\n//\n// write!(w, \"constants [ label=<\")?;\n// super::printer::print_constants(&mut to_eir_ctx, fun, 0, &mut buf)?;\n// let text = std::str::from_utf8(&buf).unwrap();\n// let text = format_label(text);\n// write!(w, \"{}\", text)?;\n// write!(w, \"> ];\\n\")?;\n//\n// let block_graph = fun.block_graph();\n// let mut block_dfs = Dfs::new(&block_graph, fun.block_entry());\n//\n// while let Some(block) = block_dfs.next(&block_graph) {\n// write!(w, \"blk_{} [ label=<\", block)?;\n//\n// buf.clear();\n// block.to_eir_text_fun(&mut to_eir_ctx, fun, 0, &mut buf).unwrap();\n// let text = std::str::from_utf8(&buf).unwrap();\n// let text = format_label(text);\n// write!(w, \"{}\", text)?;\n//\n// write!(w, \"> ];\\n\")?;\n//\n// for out in block_graph.neighbors(block) {\n// write!(w, \"blk_{} -> blk_{};\\n\", block, out)?;\n// }\n//\n// write!(w, \"\\n\")?;\n// }\n//\n// write!(w, \"}}\\n\")?;\n// Ok(())\n//}\n\n#[cfg(test)]\nmod test {\n use crate::{GraphPrinter, NodeId};\n use std::path::Path;\n\n #[test]\n fn basic() {\n let mut p = GraphPrinter::new();\n p.node(\"woo\", \"Something something\");\n p.node(\"hoo\", \"Something else\");\n p.edge(\"woo\", \"hoo\", \"Some edge\");\n let out = p.finish().unwrap();\n }\n\n #[test]\n fn basic_to_file() {\n let mut p = GraphPrinter::new();\n p.node(\"woo\", \"Something something\");\n p.node(\"hoo\", \"Something else\");\n p.edge(\"woo\", \"hoo\", \"Some edge\");\n p.finish_run_dot(Path::new(\"something.png\"));\n\n std::fs::remove_file(Path::new(\"something.png\")).unwrap();\n }\n}\n" }, { "path": "util/libeir_util_dot_graph/src/tablegen.rs", "content": "//! Convernient builder API for HTML tables.\n\nuse std::alloc::Alloc;\n\npub enum Cell {\n Terminal(T),\n Horizontal(Box, Box)\n}\n" }, { "path": "util/libeir_util_number/Cargo.toml", "content": "[package]\nname = \"libeir_util_number\"\nversion = \"0.1.0\"\nauthors = [\"Hans Elias B. Josephsen \"]\nedition = \"2018\"\nlicense = \"MIT OR Apache-2.0\"\n\n[dependencies]\nnum-traits = \"0.2.8\"\nnum-bigint = { git = \"https://github.com/hansihe/num-bigint.git\" }\n\nlibeir_util_binary = { path = \"../libeir_util_binary\" }\n" }, { "path": "util/libeir_util_number/src/bigint_to_float.rs", "content": "use num_bigint::{BigInt, Sign};\n\n/// https://github.com/erlang/otp/blob/0de9ecd561bdc964f1c6436d240729b3952cdf3a/erts/emulator/beam/big.c#L1642-L1667\npub fn bigint_to_double(big: &BigInt) -> f64 {\n let (sign, data) = big.to_bytes_be();\n\n let mut d: f64 = 0.0;\n let dbase = ((!0u8) as f64) + 1.0;\n\n for digit in data.iter() {\n d = d * dbase + (*digit as f64);\n }\n\n if sign == Sign::Minus {\n -d\n } else {\n d\n }\n}\n\n#[cfg(test)]\nmod tests {\n use super::bigint_to_double;\n use num_bigint::BigInt;\n\n #[test]\n fn test_bigint_to_double() {\n let bi = BigInt::from(100);\n assert!(bigint_to_double(&bi) == 100.0);\n\n let bi = BigInt::from(10000000000i64);\n assert!(bigint_to_double(&bi) == 10000000000.0);\n\n let bi = BigInt::from(1000000000000000000i64);\n assert!(bigint_to_double(&bi) == 1000000000000000000.0);\n }\n}\n" }, { "path": "util/libeir_util_number/src/binary.rs", "content": "use crate::Integer;\nuse libeir_util_binary::{Endian, BitCarrier, BitRead, BitSlice, integer_to_carrier};\n\nimpl BitCarrier for Integer {\n type T = u8;\n fn bit_len(&self) -> usize {\n match self {\n Integer::Big(bi) => bi.bit_len(),\n Integer::Small(si) => si.bit_len(),\n }\n }\n}\n\n#[derive(Debug)]\npub enum IntegerBits {\n //SmallBE(SmallIntCarrierBE),\n //SmallLE(SmallIntCarrierLE),\n Big(BitSlice>),\n}\n\nimpl BitCarrier for IntegerBits {\n type T = u8;\n fn bit_len(&self) -> usize {\n match self {\n //Self::SmallBE(si) => si.bit_len(),\n //Self::SmallLE(si) => si.bit_len(),\n Self::Big(bi) => bi.bit_len(),\n }\n }\n}\nimpl BitRead for IntegerBits {\n fn read_word(&self, n: usize) -> u8 {\n match self {\n //Self::SmallBE(si) => si.read_word(n),\n //Self::SmallLE(si) => si.read_word(n),\n Self::Big(bi) => bi.read_word(n),\n }\n }\n}\n\nimpl Integer {\n\n pub fn encode_bitstring(&self, bits: usize, endian: Endian) -> IntegerBits {\n match self {\n Integer::Big(bi) => IntegerBits::Big(integer_to_carrier(bi.clone(), bits, endian)),\n Integer::Small(si) => {\n // TODO: Don't convert\n IntegerBits::Big(integer_to_carrier((*si).into(), bits, endian))\n \n //let mask = if si < &0 {\n // 0xff\n //} else {\n // 0x00\n //};\n\n //match endian {\n // Endian::Big => {\n // IntegerBits::SmallBE(SmallIntCarrierBE {\n // data: *si as u64,\n // bits,\n // padding: mask,\n // bytes: (bits + 7) / 8,\n // })\n // }\n // Endian::Little => {\n // IntegerBits::SmallLE(SmallIntCarrierLE {\n // data: *si as u64,\n // bits,\n // padding: mask,\n // })\n // }\n //}\n }\n }\n }\n\n}\n\n//impl BitCarrier for IntegerBitVec {\n// type T = u8;\n// fn bit_len(&self) -> usize {\n// match self {\n// Self::Small(si) => i.bit_len(),\n// Self::Big(bi) => bi.bit_len(),\n// }\n// }\n//}\n//\n//impl BitRead for IntegerBitVec {\n// fn read_word(&self, n: usize) -> u8 {\n// match self {\n// Self::Small(si) => si.read_word(n),\n// Self::Big(bi) => bi.read_word(n),\n// }\n// }\n//}\n//\n//impl From for IntegerBitVec {\n// fn from(int: Integer) -> Self {\n// match int {\n// Integer::Big(bi) => Self::Big(libeir_util_binary::integer_to_carrier(bi, )),\n// Integer::Small(si) => Self::Small(si),\n// }\n// }\n//}\n\n//#[derive(Debug)]\n//pub struct SmallIntCarrierBE {\n// data: u64,\n// bits: usize,\n// padding: u8,\n// bytes: usize,\n//}\n//impl BitCarrier for SmallIntCarrierBE {\n// type T = u8;\n// fn bit_len(&self) -> usize {\n// self.bits\n// }\n//}\n//impl BitRead for SmallIntCarrierBE {\n// fn read_word(&self, n: usize) -> u8 {\n// if n >= self.bytes {\n// return self.padding;\n// }\n//\n// let inv = self.bytes - n - 1;\n// println!(\"inv: {:?}\", inv);\n//\n// if inv >= 8 {\n// self.padding\n// } else {\n// let d1 = self.data.read_word(7 - inv);\n// let d2 = if inv == 7 {\n// self.padding\n// } else {\n// self.data.read_word(n)\n// };\n//\n// self.data.read_word(7 - inv)\n// }\n// }\n//}\n//\n//#[derive(Debug)]\n//pub struct SmallIntCarrierLE {\n// data: u64,\n// bits: usize,\n// padding: u8,\n//}\n//impl BitCarrier for SmallIntCarrierLE {\n// type T = u8;\n// fn bit_len(&self) -> usize {\n// self.bits\n// }\n//}\n//impl BitRead for SmallIntCarrierLE {\n// fn read_word(&self, n: usize) -> u8 {\n// if n >= 8 {\n// self.padding\n// } else {\n// let offset = self.bits % 8;\n// let d = self.data.read_word(7 - n);\n// if offset == 0 {\n// d\n// } else {\n// d << (8 - offset)\n// }\n// }\n// }\n//}\n\n// <<20::big-size(12)>> -> <<1, 4::size(4)>>\n// <<20::little-size(12)>> -> <<20, 0::size(4)>>\n// <<-20::big-size(12)>> -> <<254, 12::size(4)>>\n// <<-20::little-size(12)>> -> <<236, 15::size(4)>>\n\n\n#[cfg(test)]\nmod tests {\n use crate::Integer;\n use libeir_util_binary::{Endian, BitVec};\n\n #[test]\n fn unsigned_big_endian_bigint() {\n let num = 20;\n\n let bs1 = Integer::Big(num.into()).encode_bitstring(12, Endian::Big);\n let mut b1 = BitVec::new();\n b1.push(&bs1);\n\n let parts = (b1.get(0).unwrap(), b1.get(1).unwrap());\n assert_eq!(parts, (1, 4 << 4));\n }\n\n #[test]\n fn unsigned_little_endian_bigint() {\n let num = 20;\n\n let bs1 = Integer::Big(num.into()).encode_bitstring(12, Endian::Little);\n let mut b1 = BitVec::new();\n b1.push(&bs1);\n\n let parts = (b1.get(0).unwrap(), b1.get(1).unwrap());\n assert_eq!(parts, (20, 0 << 4));\n }\n\n #[test]\n fn signed_big_endian_bigint() {\n let num = -20;\n\n let bs1 = Integer::Big(num.into()).encode_bitstring(12, Endian::Big);\n let mut b1 = BitVec::new();\n b1.push(&bs1);\n\n let parts = (b1.get(0).unwrap(), b1.get(1).unwrap());\n assert_eq!(parts, (254, 12 << 4));\n }\n\n #[test]\n fn signed_little_endian_bigint() {\n let num = -20;\n\n let bs1 = Integer::Big(num.into()).encode_bitstring(12, Endian::Little);\n let mut b1 = BitVec::new();\n b1.push(&bs1);\n\n let parts = (b1.get(0).unwrap(), b1.get(1).unwrap());\n assert_eq!(parts, (236, 15 << 4));\n }\n\n #[test]\n fn unsigned_big_endian_smallint() {\n let num = 20;\n\n let bs1 = Integer::Small(num).encode_bitstring(12, Endian::Big);\n let mut b1 = BitVec::new();\n b1.push(&bs1);\n\n let parts = (b1.get(0).unwrap(), b1.get(1).unwrap());\n assert_eq!(parts, (1, 4 << 4));\n }\n\n #[test]\n fn unsigned_little_endian_smallint() {\n let num = 20;\n\n let bs1 = Integer::Small(num).encode_bitstring(12, Endian::Little);\n let mut b1 = BitVec::new();\n b1.push(&bs1);\n\n let parts = (b1.get(0).unwrap(), b1.get(1).unwrap());\n assert_eq!(parts, (20, 0 << 4));\n }\n\n #[test]\n fn signed_big_endian_smallint() {\n let num = -20;\n\n let bs1 = Integer::Small(num).encode_bitstring(12, Endian::Big);\n let mut b1 = BitVec::new();\n b1.push(&bs1);\n\n let parts = (b1.get(0).unwrap(), b1.get(1).unwrap());\n assert_eq!(parts, (254, 12 << 4));\n }\n\n #[test]\n fn signed_little_endian_smallint() {\n let num = -20;\n\n let bs1 = Integer::Small(num).encode_bitstring(12, Endian::Little);\n let mut b1 = BitVec::new();\n b1.push(&bs1);\n\n let parts = (b1.get(0).unwrap(), b1.get(1).unwrap());\n assert_eq!(parts, (236, 15 << 4));\n }\n\n #[test]\n fn num_to_bitstring() {\n let num = 0b101001101001;\n\n let bs1 = Integer::Small(num).encode_bitstring(12, Endian::Little);\n let mut b1 = BitVec::new();\n b1.push(&bs1);\n\n let bs2 = Integer::Big(num.into()).encode_bitstring(12, Endian::Little);\n let mut b2 = BitVec::new();\n b2.push(&bs2);\n\n println!(\"{:?}\", b1);\n println!(\"{:?}\", b2);\n assert_eq!(b1, b2);\n }\n\n}\n" }, { "path": "util/libeir_util_number/src/float.rs", "content": "use crate::Integer;\n\nuse std::cmp::Ordering;\nuse std::hash::{Hash, Hasher};\nuse std::mem::transmute;\nuse std::num::FpCategory;\nuse std::ops::{Add, Div, Mul, Neg, Rem, Sub};\n\nuse num_bigint::BigInt;\nuse num_traits::FromPrimitive;\n\n#[derive(Debug, Copy, Clone)]\npub struct Float(f64);\n\nimpl Float {\n pub fn new(float: f64) -> Result {\n FloatError::from_category(float.classify())?;\n Ok(Float(float))\n }\n\n #[inline(always)]\n pub fn raw(&self) -> u64 {\n unsafe { transmute(self.0) }\n }\n\n pub fn inner(&self) -> f64 {\n self.0\n }\n\n pub fn plus(&self) -> Float {\n if self.0 < 0.0 {\n Float::new(self.0 * -1.0).unwrap()\n } else {\n *self\n }\n }\n\n pub fn is_zero(&self) -> bool {\n self.0.classify() == FpCategory::Zero\n }\n\n pub fn to_integer(&self) -> Integer {\n Integer::Big(BigInt::from_f64(self.0).unwrap()).shrink()\n }\n\n /// Returns whether this float is more precise than an integer.\n /// If the float is precise, the other integer this is being compared to will\n /// be converted to a float.\n /// If the float is not precise, it will be converted to the integer.\n pub fn is_precise(&self) -> bool {\n self.0 > -9007199254740992.0 && self.0 < 9007199254740992.0\n }\n}\n\n#[derive(Debug, Copy, Clone)]\npub enum FloatError {\n Nan,\n Infinite,\n}\nimpl FloatError {\n pub fn from_category(category: FpCategory) -> Result<(), Self> {\n match category {\n FpCategory::Nan => Err(FloatError::Nan),\n FpCategory::Infinite => Err(FloatError::Infinite),\n _ => Ok(()),\n }\n }\n}\n\nimpl std::fmt::Display for FloatError {\n fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {\n match self {\n FloatError::Nan => write!(f, \"NaN\"),\n FloatError::Infinite => write!(f, \"Inf\"),\n }\n }\n}\nimpl std::error::Error for FloatError {}\n\nmacro_rules! impl_op {\n ($trait:ident, $fun:ident) => {\n impl $trait for Float {\n type Output = Result;\n fn $fun(self, rhs: Float) -> Self::Output {\n Float::new($trait::$fun(self.0, rhs.0))\n }\n }\n };\n}\n\nimpl Hash for Float {\n fn hash(&self, state: &mut H) {\n self.raw().hash(state)\n }\n}\n\nimpl PartialEq for Float {\n fn eq(&self, rhs: &Float) -> bool {\n self.raw() == rhs.raw()\n }\n}\nimpl Eq for Float {}\n\nimpl PartialOrd for Float {\n fn partial_cmp(&self, rhs: &Float) -> Option {\n self.0.partial_cmp(&rhs.0)\n }\n}\nimpl Ord for Float {\n fn cmp(&self, rhs: &Float) -> Ordering {\n self.partial_cmp(rhs).unwrap()\n }\n}\n\nimpl_op!(Add, add);\nimpl_op!(Sub, sub);\nimpl_op!(Mul, mul);\nimpl_op!(Div, div);\nimpl_op!(Rem, rem);\n\nimpl Neg for Float {\n type Output = Float;\n fn neg(self) -> Self::Output {\n Float::new(-self.0).unwrap()\n }\n}\n\nimpl std::fmt::Display for Float {\n fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {\n write!(f, \"{}\", self.0)\n }\n}\n\nimpl Add<&Integer> for Float {\n type Output = Result;\n fn add(self, rhs: &Integer) -> Self::Output {\n self + rhs.to_efloat()?\n }\n}\nimpl Add for &Integer {\n type Output = Result;\n fn add(self, rhs: Float) -> Self::Output {\n self.to_efloat()? + rhs\n }\n}\n\nimpl Sub<&Integer> for Float {\n type Output = Result;\n fn sub(self, rhs: &Integer) -> Self::Output {\n self - rhs.to_efloat()?\n }\n}\nimpl Sub for &Integer {\n type Output = Result;\n fn sub(self, rhs: Float) -> Self::Output {\n self.to_efloat()? - rhs\n }\n}\n\nimpl Mul<&Integer> for Float {\n type Output = Result;\n fn mul(self, rhs: &Integer) -> Self::Output {\n self * rhs.to_efloat()?\n }\n}\nimpl Mul for &Integer {\n type Output = Result;\n fn mul(self, rhs: Float) -> Self::Output {\n self.to_efloat()? * rhs\n }\n}\n\nimpl Div<&Integer> for Float {\n type Output = Result;\n fn div(self, rhs: &Integer) -> Self::Output {\n self / rhs.to_efloat()?\n }\n}\nimpl Div for &Integer {\n type Output = Result;\n fn div(self, rhs: Float) -> Self::Output {\n self.to_efloat()? / rhs\n }\n}\n\nimpl Rem<&Integer> for Float {\n type Output = Result;\n fn rem(self, rhs: &Integer) -> Self::Output {\n self % rhs.to_efloat()?\n }\n}\nimpl Rem for &Integer {\n type Output = Result;\n fn rem(self, rhs: Float) -> Self::Output {\n self.to_efloat()? % rhs\n }\n}\n" }, { "path": "util/libeir_util_number/src/integer.rs", "content": "use crate::{DivisionError, Float, FloatError};\n\nuse std::cmp::Ordering;\nuse std::convert::TryInto;\nuse std::fmt::{Display, Formatter};\nuse std::ops::{Add, BitAnd, BitOr, BitXor, Div, Mul, Neg, Not, Rem, Shl, Shr, Sub};\nuse std::str::FromStr;\n\nuse num_bigint::{BigInt, ParseBigIntError};\npub use num_traits::{FromPrimitive, ToPrimitive, Zero};\n\n#[derive(Debug, Clone, Hash)]\npub enum Integer {\n Small(i64),\n Big(BigInt),\n}\n\nimpl Integer {\n pub fn is_zero(&self) -> bool {\n match self {\n Integer::Small(num) => *num == 0,\n Integer::Big(num) => num.is_zero(),\n }\n }\n\n pub fn plus(&self) -> Integer {\n match self {\n Integer::Small(num) if num < &0 => Integer::Small(-num),\n Integer::Big(num) if num < &0 => Integer::Big(-num.clone()),\n _ => self.clone(),\n }\n }\n\n pub fn to_float(&self) -> f64 {\n match self {\n Integer::Small(int) => *int as f64,\n Integer::Big(int) => crate::bigint_to_double(int),\n }\n }\n\n pub fn to_efloat(&self) -> Result {\n Float::new(self.to_float())\n }\n\n pub fn to_bigint(self) -> BigInt {\n match self {\n Integer::Small(int) => int.into(),\n Integer::Big(int) => int,\n }\n }\n\n pub fn shrink(self) -> Self {\n match self {\n Integer::Small(int) => Integer::Small(int),\n Integer::Big(int) => {\n if let Some(small) = int.to_i64() {\n Integer::Small(small)\n } else {\n Integer::Big(int)\n }\n }\n }\n }\n\n pub fn from_string_radix(string: &str, radix: u32) -> Option {\n if let Ok(i) = i64::from_str_radix(string, radix) {\n return Some(Integer::Small(i));\n }\n let bi = BigInt::parse_bytes(string.as_bytes(), radix)?;\n Some(Integer::Big(bi))\n }\n\n pub fn to_u64(&self) -> Option {\n ToPrimitive::to_u64(self)\n }\n\n pub fn to_usize(&self) -> Option {\n ToPrimitive::to_usize(self)\n }\n}\n\nimpl Display for Integer {\n fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {\n match self {\n Integer::Small(int) => int.fmt(f),\n Integer::Big(int) => int.fmt(f),\n }\n }\n}\n\nimpl FromStr for Integer {\n type Err = ParseBigIntError;\n fn from_str(s: &str) -> Result {\n match s.parse::() {\n Ok(int) => Ok(Integer::Small(int)),\n Err(_) => match s.parse::() {\n Ok(int) => Ok(Integer::Big(int)),\n Err(err) => Err(err),\n },\n }\n }\n}\n\nimpl PartialEq for Integer {\n fn eq(&self, rhs: &Integer) -> bool {\n match (self, rhs) {\n (Integer::Small(lhs), Integer::Small(rhs)) => lhs.eq(rhs),\n (Integer::Small(lhs), Integer::Big(rhs)) => lhs.eq(rhs),\n (Integer::Big(lhs), Integer::Small(rhs)) => lhs.eq(rhs),\n (Integer::Big(lhs), Integer::Big(rhs)) => lhs.eq(rhs),\n }\n }\n}\nimpl Eq for Integer {}\n\nimpl PartialOrd for Integer {\n fn partial_cmp(&self, rhs: &Integer) -> Option {\n match (self, rhs) {\n (Integer::Small(lhs), Integer::Small(rhs)) => lhs.partial_cmp(rhs),\n (Integer::Small(lhs), Integer::Big(rhs)) => lhs.partial_cmp(rhs),\n (Integer::Big(lhs), Integer::Small(rhs)) => lhs.partial_cmp(rhs),\n (Integer::Big(lhs), Integer::Big(rhs)) => lhs.partial_cmp(rhs),\n }\n }\n}\nimpl Ord for Integer {\n fn cmp(&self, rhs: &Integer) -> Ordering {\n self.partial_cmp(rhs).unwrap()\n }\n}\n\nimpl PartialEq for Integer {\n fn eq(&self, rhs: &f64) -> bool {\n match self {\n Integer::Small(lhs) => (*lhs as f64).eq(rhs),\n Integer::Big(lhs) => crate::bigint_to_double(lhs).eq(rhs),\n }\n }\n}\nimpl PartialEq for f64 {\n fn eq(&self, rhs: &Integer) -> bool {\n rhs.eq(self)\n }\n}\nimpl PartialOrd for Integer {\n fn partial_cmp(&self, rhs: &f64) -> Option {\n match self {\n Integer::Small(lhs) => (*lhs as f64).partial_cmp(rhs),\n Integer::Big(lhs) => crate::bigint_to_double(lhs).partial_cmp(rhs),\n }\n }\n}\nimpl PartialOrd for f64 {\n fn partial_cmp(&self, rhs: &Integer) -> Option {\n rhs.partial_cmp(self).map(|v| v.reverse())\n }\n}\n\nimpl PartialEq for Integer {\n fn eq(&self, rhs: &char) -> bool {\n match self {\n Integer::Small(lhs) => lhs.eq(&(*rhs as i64)),\n Integer::Big(lhs) => lhs.eq(&(*rhs as i64)),\n }\n }\n}\nimpl PartialEq for char {\n fn eq(&self, rhs: &Integer) -> bool {\n rhs.eq(self)\n }\n}\nimpl PartialOrd for Integer {\n fn partial_cmp(&self, rhs: &char) -> Option {\n match self {\n Integer::Small(lhs) => lhs.partial_cmp(&(*rhs as i64)),\n Integer::Big(lhs) => lhs.partial_cmp(&(*rhs as i64)),\n }\n }\n}\nimpl PartialOrd for char {\n fn partial_cmp(&self, rhs: &Integer) -> Option {\n rhs.partial_cmp(self).map(|v| v.reverse())\n }\n}\n\nimpl PartialEq for Integer {\n fn eq(&self, rhs: &i64) -> bool {\n match self {\n Integer::Small(lhs) => lhs.eq(rhs),\n Integer::Big(lhs) => lhs.eq(rhs),\n }\n }\n}\nimpl PartialEq for i64 {\n fn eq(&self, rhs: &Integer) -> bool {\n rhs.eq(self)\n }\n}\nimpl PartialOrd for Integer {\n fn partial_cmp(&self, rhs: &i64) -> Option {\n match self {\n Integer::Small(lhs) => lhs.partial_cmp(rhs),\n Integer::Big(lhs) => lhs.partial_cmp(rhs),\n }\n }\n}\nimpl PartialOrd for i64 {\n fn partial_cmp(&self, rhs: &Integer) -> Option {\n rhs.partial_cmp(self).map(|v| v.reverse())\n }\n}\n\nimpl Shr for Integer {\n type Output = Integer;\n fn shr(self, num: u32) -> Integer {\n let big = self.to_bigint() >> (num as usize);\n Integer::Big(big).shrink()\n }\n}\nimpl Shl for Integer {\n type Output = Integer;\n fn shl(self, num: u32) -> Integer {\n let big = self.to_bigint() << (num as usize);\n Integer::Big(big).shrink()\n }\n}\n\nimpl Mul for Integer {\n type Output = Integer;\n fn mul(self, rhs: i64) -> Integer {\n match self {\n Integer::Small(lhs) => {\n let mut int: BigInt = lhs.into();\n int = int * rhs;\n Integer::Big(int).shrink()\n }\n Integer::Big(lhs) => Integer::Big(lhs * rhs),\n }\n }\n}\nimpl Mul<&Integer> for Integer {\n type Output = Integer;\n fn mul(self, rhs: &Integer) -> Integer {\n let mut lhs = self.to_bigint();\n match rhs {\n Integer::Small(rhs) => lhs = lhs * rhs,\n Integer::Big(rhs) => lhs *= rhs,\n }\n Integer::Big(lhs).shrink()\n }\n}\nimpl Div<&Integer> for Integer {\n type Output = Result;\n fn div(self, rhs: &Integer) -> Self::Output {\n if rhs.is_zero() {\n return Err(DivisionError);\n }\n\n let mut lhs = self.to_bigint();\n match rhs {\n Integer::Small(rhs) => lhs = lhs / rhs,\n Integer::Big(rhs) => lhs /= rhs,\n }\n Ok(Integer::Big(lhs).shrink())\n }\n}\nimpl Add<&Integer> for Integer {\n type Output = Integer;\n fn add(self, rhs: &Integer) -> Integer {\n let mut lhs = self.to_bigint();\n match rhs {\n Integer::Small(rhs) => lhs = lhs + rhs,\n Integer::Big(rhs) => lhs += rhs,\n }\n Integer::Big(lhs).shrink()\n }\n}\nimpl Sub<&Integer> for Integer {\n type Output = Integer;\n fn sub(self, rhs: &Integer) -> Integer {\n let mut lhs = self.to_bigint();\n match rhs {\n Integer::Small(rhs) => lhs = lhs - rhs,\n Integer::Big(rhs) => lhs -= rhs,\n }\n Integer::Big(lhs).shrink()\n }\n}\nimpl Rem<&Integer> for Integer {\n type Output = Integer;\n fn rem(self, rhs: &Integer) -> Integer {\n let mut lhs = self.to_bigint();\n match rhs {\n Integer::Small(rhs) => lhs = lhs % rhs,\n Integer::Big(rhs) => lhs %= rhs,\n }\n Integer::Big(lhs).shrink()\n }\n}\n\nimpl BitAnd<&Integer> for Integer {\n type Output = Integer;\n fn bitand(self, rhs: &Integer) -> Integer {\n let l = self.to_bigint();\n match rhs {\n Integer::Small(r) => l & BigInt::from(*r),\n Integer::Big(r) => l & r,\n }\n .into()\n }\n}\nimpl BitOr<&Integer> for Integer {\n type Output = Integer;\n fn bitor(self, rhs: &Integer) -> Integer {\n let l = self.to_bigint();\n match rhs {\n Integer::Small(r) => l | BigInt::from(*r),\n Integer::Big(r) => l | r,\n }\n .into()\n }\n}\nimpl BitXor<&Integer> for Integer {\n type Output = Integer;\n fn bitxor(self, rhs: &Integer) -> Integer {\n let l = self.to_bigint();\n match rhs {\n Integer::Small(r) => l ^ BigInt::from(*r),\n Integer::Big(r) => l ^ r,\n }\n .into()\n }\n}\n\nimpl Neg for Integer {\n type Output = Integer;\n fn neg(self) -> Integer {\n match self {\n Integer::Small(int) => Integer::Small(-int),\n Integer::Big(int) => Integer::Big(-int),\n }\n }\n}\nimpl Not for &Integer {\n type Output = Integer;\n fn not(self) -> Integer {\n match self {\n Integer::Small(int) => Integer::Small(!int),\n Integer::Big(int) => Integer::Big(!int),\n }\n }\n}\n\nimpl ToPrimitive for Integer {\n fn to_i64(&self) -> Option {\n match self {\n Integer::Small(int) => int.to_i64(),\n Integer::Big(int) => int.to_i64(),\n }\n }\n fn to_u64(&self) -> Option {\n match self {\n Integer::Small(int) => int.to_u64(),\n Integer::Big(int) => int.to_u64(),\n }\n }\n}\n\nimpl FromPrimitive for Integer {\n fn from_i64(n: i64) -> Option {\n Some(Integer::Small(n))\n }\n fn from_u64(n: u64) -> Option {\n if let Ok(int) = n.try_into() {\n Some(Integer::Small(int))\n } else {\n Some(Integer::Big(n.into()))\n }\n }\n}\n\nimpl From for Integer {\n fn from(i: i64) -> Integer {\n Integer::from_i64(i).unwrap()\n }\n}\nimpl From for Integer {\n fn from(i: u64) -> Integer {\n Integer::from_u64(i).unwrap()\n }\n}\nimpl From for Integer {\n fn from(i: i32) -> Integer {\n Integer::from_i32(i).unwrap()\n }\n}\nimpl From for Integer {\n fn from(i: usize) -> Integer {\n Integer::from_usize(i).unwrap()\n }\n}\nimpl From for Integer {\n fn from(i: char) -> Integer {\n Integer::from_u64(i as u64).unwrap()\n }\n}\nimpl From for Integer {\n fn from(i: BigInt) -> Integer {\n Integer::Big(i)\n }\n}\n" }, { "path": "util/libeir_util_number/src/lib.rs", "content": "mod bigint_to_float;\npub use bigint_to_float::bigint_to_double;\n\nmod integer;\npub use integer::Integer;\n\nmod float;\npub use float::{Float, FloatError};\n\nmod number;\npub use number::Number;\n\nmod binary;\n\npub use num_bigint as bigint;\npub use num_bigint::BigInt;\npub use num_traits as traits;\npub use num_traits::{cast, FromPrimitive, NumCast, ToPrimitive};\n\n#[derive(Debug, Copy, Clone)]\npub struct DivisionError;\n" }, { "path": "util/libeir_util_number/src/number.rs", "content": "use std::cmp::Ordering;\nuse std::ops::{Add, Div, Mul, Neg, Sub};\n\nuse crate::{Float, FloatError, Integer};\n\n#[derive(Debug, Clone, Hash)]\npub enum Number {\n Integer(Integer),\n Float(Float),\n}\n\nimpl Number {\n pub fn is_zero(&self) -> bool {\n match self {\n Number::Integer(int) => int.is_zero(),\n Number::Float(float) => float.is_zero(),\n }\n }\n pub fn plus(self) -> Self {\n match self {\n Number::Integer(int) => int.plus().into(),\n Number::Float(float) => float.plus().into(),\n }\n }\n pub fn equals(&self, rhs: &Number, exact: bool) -> bool {\n match (self, rhs) {\n (Number::Integer(l), Number::Integer(r)) => l == r,\n (Number::Float(l), Number::Float(r)) => l == r,\n\n (Number::Integer(_l), Number::Float(_r)) if exact => false,\n (Number::Integer(l), Number::Float(r)) => {\n if r.is_precise() {\n l.to_float() == r.inner()\n } else {\n l == &r.to_integer()\n }\n }\n (Number::Float(_), Number::Integer(_)) => rhs.equals(self, exact),\n }\n }\n\n pub fn to_efloat(&self) -> Result {\n match self {\n Number::Integer(integer) => integer.to_efloat(),\n Number::Float(float) => Ok(*float),\n }\n }\n}\n\nimpl PartialEq for Number {\n fn eq(&self, rhs: &Number) -> bool {\n self.equals(rhs, false)\n }\n}\nimpl Eq for Number {}\n\nimpl PartialOrd for Number {\n fn partial_cmp(&self, other: &Number) -> Option {\n Some(self.cmp(other))\n }\n}\nimpl Ord for Number {\n fn cmp(&self, other: &Number) -> Ordering {\n match (self, other) {\n (Number::Integer(l), Number::Integer(r)) => l.cmp(r),\n (Number::Float(l), Number::Float(r)) => l.cmp(r),\n (Number::Integer(l), Number::Float(r)) => {\n if r.is_precise() {\n l.to_float().partial_cmp(&r.inner()).unwrap()\n } else {\n l.cmp(&r.to_integer())\n }\n }\n (Number::Float(l), Number::Integer(r)) => {\n if l.is_precise() {\n l.inner().partial_cmp(&r.to_float()).unwrap()\n } else {\n l.to_integer().cmp(r)\n }\n }\n }\n }\n}\n\nimpl From for Number {\n fn from(int: Integer) -> Number {\n Number::Integer(int)\n }\n}\nimpl From for Number {\n fn from(int: usize) -> Number {\n Number::Integer(int.into())\n }\n}\nimpl From for Number {\n fn from(float: Float) -> Number {\n Number::Float(float)\n }\n}\n\nimpl Neg for Number {\n type Output = Number;\n fn neg(self) -> Number {\n match self {\n Number::Integer(int) => Number::Integer(-int),\n Number::Float(float) => Number::Float(-float),\n }\n }\n}\n\nimpl Add<&Number> for &Number {\n type Output = Result;\n fn add(self, rhs: &Number) -> Self::Output {\n let res: Number = match (self, rhs) {\n (Number::Integer(l), Number::Integer(r)) => (l.clone() + r).into(),\n (Number::Integer(l), Number::Float(r)) => (l + *r)?.into(),\n (Number::Float(l), Number::Integer(r)) => (*l + r)?.into(),\n (Number::Float(l), Number::Float(r)) => (*l + *r)?.into(),\n };\n Ok(res)\n }\n}\n\nimpl Sub<&Number> for &Number {\n type Output = Result;\n fn sub(self, rhs: &Number) -> Self::Output {\n let res: Number = match (self, rhs) {\n (Number::Integer(l), Number::Integer(r)) => (l.clone() - r).into(),\n (Number::Integer(l), Number::Float(r)) => (l - *r)?.into(),\n (Number::Float(l), Number::Integer(r)) => (*l - r)?.into(),\n (Number::Float(l), Number::Float(r)) => (*l - *r)?.into(),\n };\n Ok(res)\n }\n}\n\nimpl Mul<&Number> for &Number {\n type Output = Result;\n fn mul(self, rhs: &Number) -> Self::Output {\n let res: Number = match (self, rhs) {\n (Number::Integer(l), Number::Integer(r)) => (l.clone() * r).into(),\n (Number::Integer(l), Number::Float(r)) => (l * *r)?.into(),\n (Number::Float(l), Number::Integer(r)) => (*l * r)?.into(),\n (Number::Float(l), Number::Float(r)) => (*l * *r)?.into(),\n };\n Ok(res)\n }\n}\n\nimpl Div<&Number> for &Number {\n type Output = Result;\n fn div(self, rhs: &Number) -> Self::Output {\n let res: Number = match (self, rhs) {\n (Number::Integer(l), Number::Integer(r)) => (l.to_efloat()? + r)?.into(),\n (Number::Integer(l), Number::Float(r)) => (l / *r)?.into(),\n (Number::Float(l), Number::Integer(r)) => (*l / r)?.into(),\n (Number::Float(l), Number::Float(r)) => (*l / *r)?.into(),\n };\n Ok(res)\n }\n}\n" }, { "path": "util/libeir_util_parse/Cargo.toml", "content": "[package]\nname = \"libeir_util_parse\"\nversion = \"0.1.0\"\nauthors = [\"Hans Elias B. Josephsen \"]\nedition = \"2018\"\nlicense = \"MIT OR Apache-2.0\"\n\n# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html\n\n[dependencies]\ncodespan-reporting = \"0.9\"\nscoped_cell = { path = \"../scoped_cell\" }\nsnafu = \"0.5\"\n\nlibeir_diagnostics = { path = \"../../libeir_diagnostics\" }\n\n[dev-dependencies]\npretty_assertions = \"0.5\"\n" }, { "path": "util/libeir_util_parse/src/errors.rs", "content": "use std::marker::PhantomData;\nuse std::rc::Rc;\n\nuse scoped_cell::{scoped_cell, ScopedCell};\n\nuse libeir_diagnostics::*;\n\n// TODO: I would like to do a lot of things differently here, but things are\n// tricky without GATs. Revisit once it lands.\n\n#[derive(Debug, Clone)]\npub enum ErrorOrWarning {\n Error(E),\n Warning(W),\n}\nimpl ToDiagnostic for ErrorOrWarning\nwhere\n E: ToDiagnostic,\n W: ToDiagnostic,\n{\n fn to_diagnostic(&self) -> Diagnostic {\n match self {\n ErrorOrWarning::Error(err) => err.to_diagnostic(),\n ErrorOrWarning::Warning(warn) => warn.to_diagnostic(),\n }\n }\n}\n\n#[derive(Clone)]\npub struct Errors {\n pub errors: Vec>,\n failed: bool,\n}\n\nimpl Errors {\n pub fn new() -> Self {\n Errors {\n errors: Vec::new(),\n failed: false,\n }\n }\n\n pub fn failed(&self) -> bool {\n self.failed\n }\n\n pub fn print(&self, codemap: &CodeMap)\n where\n E: ToDiagnostic,\n W: ToDiagnostic,\n {\n use term::termcolor::{ColorChoice, StandardStream};\n use term::Config;\n let config = Config::default();\n let mut out = StandardStream::stderr(ColorChoice::Auto);\n for diag in self.iter_diagnostics() {\n term::emit(&mut out, &config, codemap, &diag).unwrap();\n }\n }\n\n pub fn iter_diagnostics<'a>(&'a self) -> impl Iterator + 'a\n where\n E: ToDiagnostic,\n W: ToDiagnostic,\n {\n self.errors.iter().map(|e| e.to_diagnostic())\n }\n\n pub fn errors_from(&mut self, other: Errors)\n where\n IE: Into,\n IW: Into,\n {\n self.failed = self.failed | other.failed;\n for ew in other.errors {\n match ew {\n ErrorOrWarning::Error(err) => self.errors.push(ErrorOrWarning::Error(err.into())),\n ErrorOrWarning::Warning(warn) => {\n self.errors.push(ErrorOrWarning::Warning(warn.into()))\n }\n }\n }\n }\n}\n\nimpl ErrorReceiver for Errors {\n type E = E;\n type W = W;\n\n fn is_failed(&self) -> bool {\n self.failed\n }\n\n fn warning(&mut self, warning: W) {\n self.errors.push(ErrorOrWarning::Warning(warning));\n }\n\n fn error(&mut self, error: E) {\n self.errors.push(ErrorOrWarning::Error(error));\n self.failed = true;\n }\n}\n\npub struct MessageIgnore {\n failed: bool,\n _phantom: PhantomData<(E, W)>,\n}\n\nimpl MessageIgnore {\n pub fn new() -> Self {\n MessageIgnore {\n failed: false,\n _phantom: PhantomData,\n }\n }\n\n pub fn failed(&self) -> bool {\n self.failed\n }\n}\n\nimpl ErrorReceiver for MessageIgnore {\n type E = E;\n type W = W;\n\n fn is_failed(&self) -> bool {\n self.failed\n }\n fn warning(&mut self, _warning: W) {}\n fn error(&mut self, _error: E) {\n self.failed = true;\n }\n}\n\npub trait ErrorReceiver {\n type E;\n type W;\n\n fn is_failed(&self) -> bool;\n fn warning(&mut self, warning: Self::W);\n fn error(&mut self, error: Self::E);\n}\n\nimpl ErrorReceiver for &mut dyn ErrorReceiver {\n type E = E;\n type W = W;\n fn is_failed(&self) -> bool {\n (**self).is_failed()\n }\n fn warning(&mut self, warning: Self::W) {\n (**self).warning(warning)\n }\n fn error(&mut self, error: Self::E) {\n (**self).error(error)\n }\n}\n\npub fn error_tee<'a, E, W, F, R>(\n receiver: &'a mut (dyn ErrorReceiver + 'a),\n fun: F,\n) -> R\nwhere\n F: FnOnce(ErrorReceiverTee) -> R,\n{\n scoped_cell(receiver, |cell| {\n let tee = ErrorReceiverTee { cell };\n fun(tee)\n })\n}\n\npub struct ErrorReceiverTee<'a, E, W> {\n cell: ScopedCell + 'a>,\n}\nimpl<'a, E, W> Clone for ErrorReceiverTee<'a, E, W> {\n fn clone(&self) -> Self {\n ErrorReceiverTee {\n cell: self.cell.clone(),\n }\n }\n}\n\nimpl<'a, E, W> ErrorReceiverTee<'a, E, W> {\n pub fn make_adapter(\n &mut self,\n error_adapter: FE,\n warning_adapter: FW,\n ) -> ErrorReceiverTeeAdapter<'a, E, W, NE, NW>\n where\n FE: Fn(NE) -> E + 'static,\n FW: Fn(NW) -> W + 'static,\n {\n ErrorReceiverTeeAdapter {\n cell: self.cell.clone(),\n error_adapter: Rc::new(error_adapter),\n warning_adapter: Rc::new(warning_adapter),\n phantom: PhantomData,\n }\n }\n\n pub fn make_into_adapter(&mut self) -> ErrorReceiverTeeAdapter<'a, E, W, NE, NW>\n where\n NE: Into,\n NW: Into,\n {\n ErrorReceiverTeeAdapter {\n cell: self.cell.clone(),\n error_adapter: Rc::new(|o| o.into()),\n warning_adapter: Rc::new(|o| o.into()),\n phantom: PhantomData,\n }\n }\n}\n\nimpl<'a, E, W> ErrorReceiver for ErrorReceiverTee<'a, E, W> {\n type E = E;\n type W = W;\n\n fn is_failed(&self) -> bool {\n self.cell.borrow_mut(|inner| (*inner).is_failed())\n }\n fn error(&mut self, error: E) {\n self.cell.borrow_mut(|inner| {\n inner.error(error);\n });\n }\n fn warning(&mut self, warning: W) {\n self.cell.borrow_mut(|inner| {\n inner.warning(warning);\n });\n }\n}\n\npub struct ErrorReceiverTeeAdapter<'a, IE, IW, OE, OW> {\n cell: ScopedCell + 'a>,\n error_adapter: Rc IE>,\n warning_adapter: Rc IW>,\n phantom: PhantomData<(OE, OW)>,\n}\n\nimpl<'a, IE, IW, OE, OW> ErrorReceiver for ErrorReceiverTeeAdapter<'a, IE, IW, OE, OW> {\n type E = OE;\n type W = OW;\n\n fn is_failed(&self) -> bool {\n self.cell.borrow_mut(|inner| (*inner).is_failed())\n }\n fn error(&mut self, error: OE) {\n self.cell.borrow_mut(|inner| {\n inner.error((self.error_adapter)(error));\n });\n }\n fn warning(&mut self, warning: OW) {\n self.cell.borrow_mut(|inner| {\n inner.warning((self.warning_adapter)(warning));\n });\n }\n}\n\nimpl<'a, IE, IW, OE, OW> Clone for ErrorReceiverTeeAdapter<'a, IE, IW, OE, OW> {\n fn clone(&self) -> Self {\n Self {\n cell: self.cell.clone(),\n error_adapter: self.error_adapter.clone(),\n warning_adapter: self.warning_adapter.clone(),\n phantom: PhantomData,\n }\n }\n}\n\n#[cfg(test)]\nmod tests {\n use super::{error_tee, ErrorReceiver, Errors};\n\n #[test]\n fn basic_usage() {\n fn inner2(recv: &mut dyn ErrorReceiver) {\n error_tee(recv, |_tee| {});\n }\n\n fn inner(recv: &mut dyn ErrorReceiver) {\n error_tee(recv, |mut tee| {\n let mut adapter = tee.make_into_adapter();\n inner2(&mut adapter);\n });\n }\n\n let mut errors = Errors::new();\n inner(&mut errors);\n }\n}\n" }, { "path": "util/libeir_util_parse/src/lib.rs", "content": "mod source;\npub use source::*;\n\nmod scanner;\npub use scanner::*;\n\nmod util;\npub use util::*;\n\nmod result;\npub use result::*;\n\nmod errors;\npub use errors::*;\n\nmod parser;\npub use parser::*;\n" }, { "path": "util/libeir_util_parse/src/parser.rs", "content": "use std::path::{Path, PathBuf};\nuse std::sync::Arc;\n\nuse libeir_diagnostics::*;\n\nuse crate::ErrorReceiver;\nuse crate::{FileMapSource, Source};\n\npub struct Parser {\n pub config: C,\n pub codemap: Arc,\n}\n\nimpl Parser {\n pub fn new(config: C, codemap: Arc) -> Self {\n Self { config, codemap }\n }\n}\n\nimpl Parser {\n pub fn parse<'a, T>(\n &self,\n errors: &'a mut (dyn ErrorReceiver::Error, W = ::Error> + 'a),\n source: Arc,\n ) -> Result\n where\n T: Parse,\n {\n >::parse(&self, errors, FileMapSource::new(source))\n }\n\n pub fn parse_string<'a, T, S>(\n &self,\n errors: &'a mut (dyn ErrorReceiver::Error, W = ::Error> + 'a),\n source: S,\n ) -> Result\n where\n T: Parse,\n S: AsRef,\n {\n let id = self.codemap.add(\"nofile\", source.as_ref().to_string());\n let file = self.codemap.get(id).unwrap();\n self.parse(errors, file)\n }\n\n pub fn parse_file<'a, T, S>(\n &self,\n errors: &'a mut (dyn ErrorReceiver::Error, W = ::Error> + 'a),\n source: S,\n ) -> Result\n where\n T: Parse,\n S: AsRef,\n {\n let path = source.as_ref();\n match std::fs::read_to_string(path) {\n Err(err) => {\n errors.error(>::root_file_error(err, path.to_owned()));\n Err(())\n }\n Ok(content) => {\n let id = self.codemap.add(path, content);\n let file = self.codemap.get(id).unwrap();\n self.parse(errors, file)\n }\n }\n }\n}\n\npub trait Parse {\n type Parser;\n type Error;\n type Config;\n type Token;\n\n fn root_file_error(err: std::io::Error, path: PathBuf) -> Self::Error;\n\n /// Initializes a token stream for the underlying parser and invokes parse_tokens\n fn parse<'a, S>(\n parser: &Parser,\n errors: &'a mut (dyn ErrorReceiver + 'a),\n source: S,\n ) -> Result\n where\n S: Source;\n\n /// Implemented by each parser, which should parse the token stream and produce a T\n fn parse_tokens<'a, S>(\n errors: &'a mut (dyn ErrorReceiver + 'a),\n tokens: S,\n ) -> Result\n where\n S: IntoIterator;\n}\n" }, { "path": "util/libeir_util_parse/src/result.rs", "content": "/// A result of parsing. Can have one of three states:\n/// - Fail: Error only\n/// - Warn: Error and result\n/// - Ok: Result only\npub enum ParseResult {\n Fail(E),\n Warn(E, R),\n Ok(R),\n}\n\npub trait Print {\n fn print(&self);\n}\n\nimpl ParseResult {\n pub fn unwrap(self) -> R {\n match self {\n ParseResult::Fail(_err) => {\n panic!();\n }\n ParseResult::Warn(_err, res) => res,\n ParseResult::Ok(res) => res,\n }\n }\n\n pub fn unwrap_print(self) -> R\n where\n E: Print,\n {\n match self {\n ParseResult::Fail(err) => {\n err.print();\n panic!();\n }\n ParseResult::Warn(err, res) => {\n err.print();\n res\n }\n ParseResult::Ok(res) => res,\n }\n }\n}\n" }, { "path": "util/libeir_util_parse/src/scanner.rs", "content": "use std::convert::Into;\nuse std::ops::Range;\n\nuse libeir_diagnostics::*;\n\nuse super::source::Source;\n\n/// An implementation of `Scanner` for general use\n///\n/// source -> pending -> current\n///\n/// ## pending\n/// `peek` returns pending without advancing\n///\n/// ## current\n/// `pop` returns current and advances\n/// `read` returns current without advances\npub struct Scanner {\n source: S,\n current: (SourceIndex, char),\n pending: (SourceIndex, char),\n start: SourceIndex,\n end: SourceIndex,\n}\nimpl Scanner\nwhere\n S: Source,\n{\n pub fn new(mut source: S) -> Self {\n let span = source.span();\n let start = span.start();\n let end = span.end();\n let current = source.read().unwrap_or((SourceIndex::UNKNOWN, '\\0'));\n let pending = source.read().unwrap_or((SourceIndex::UNKNOWN, '\\0'));\n Scanner {\n source,\n current,\n pending,\n start,\n end,\n }\n }\n\n pub fn start(&self) -> SourceIndex {\n self.start\n }\n\n /// Advance scanner pipeline by a single character.\n ///\n /// Current becomes pending, pending becomes next character from source.\n #[inline]\n pub fn advance(&mut self) {\n self.current = self.pending;\n self.pending = match self.source.read() {\n None => (self.end, '\\0'),\n Some(ic) => ic,\n };\n }\n\n /// Get current character and advance.\n #[inline]\n pub fn pop(&mut self) -> (SourceIndex, char) {\n let current = self.current;\n self.advance();\n current\n }\n\n /// Get pending character.\n #[inline]\n pub fn peek(&self) -> (SourceIndex, char) {\n self.pending\n }\n\n /// Get the next character from the source.\n #[inline]\n pub fn peek_next(&mut self) -> (SourceIndex, char) {\n match self.source.peek() {\n None => (self.end, '\\0'),\n Some((pos, c)) => (pos, c),\n }\n }\n\n /// Get current character.\n #[inline]\n pub fn read(&self) -> (SourceIndex, char) {\n self.current\n }\n\n #[inline]\n pub fn slice(&self, span: impl Into>) -> &str {\n self.source.slice(span)\n }\n}\n" }, { "path": "util/libeir_util_parse/src/source.rs", "content": "use std::char;\nuse std::ops::Range;\nuse std::path::PathBuf;\nuse std::sync::Arc;\n\nuse snafu::Snafu;\n\nuse libeir_diagnostics::*;\n\npub type SourceResult = std::result::Result;\n\npub trait Source: Sized {\n fn new(src: Arc) -> Self;\n\n fn read(&mut self) -> Option<(SourceIndex, char)>;\n\n fn peek(&mut self) -> Option<(SourceIndex, char)>;\n\n fn span(&self) -> SourceSpan;\n\n fn slice(&self, span: impl Into>) -> &str;\n}\n\n#[derive(Debug, Snafu)]\npub enum SourceError {\n #[snafu(visibility(pub), display(\"{} while reading {:?}\", source, path))]\n RootFileIO {\n source: std::io::Error,\n path: PathBuf,\n },\n\n #[snafu(display(\"invalid source path\"))]\n InvalidPath { reason: String },\n\n #[snafu(display(\"{}\", source))]\n PathVariableSubstitute {\n source: crate::util::PathVariableSubstituteError,\n },\n}\nimpl SourceError {\n pub fn to_diagnostic(&self) -> Diagnostic {\n match self {\n SourceError::RootFileIO { source, path: _ } => {\n Diagnostic::error().with_message(source.to_string())\n }\n SourceError::InvalidPath { reason } => {\n Diagnostic::error().with_message(format!(\"invalid path: {}\", reason))\n }\n SourceError::PathVariableSubstitute { source } => source.to_diagnostic(),\n }\n }\n}\n\n/// A source which reads from a `diagnostics::SourceFile`\npub struct FileMapSource {\n src: Arc,\n bytes: *const [u8],\n start: SourceIndex,\n peek: Option<(SourceIndex, char)>,\n end: usize,\n pos: usize,\n eof: bool,\n}\nimpl FileMapSource {\n fn peek_char(&self) -> Option<(SourceIndex, char)> {\n self.peek\n }\n\n fn next_char(&mut self) -> Option<(SourceIndex, char)> {\n // If we've peeked a char already, return that\n let result = if self.peek.is_some() {\n std::mem::replace(&mut self.peek, None)\n } else {\n let next = unsafe { self.next_char_internal() };\n match next {\n None => {\n self.eof = true;\n return None;\n }\n result => result,\n }\n };\n\n // Reset peek\n self.peek = unsafe { self.next_char_internal() };\n\n result\n }\n\n #[inline]\n unsafe fn next_char_internal(&mut self) -> Option<(SourceIndex, char)> {\n let mut pos = self.pos;\n let end = self.end;\n if pos == end {\n self.eof = true;\n }\n\n if self.eof {\n return None;\n }\n\n let start = self.start + pos;\n\n let bytes: &[u8] = &*self.bytes;\n\n // Decode UTF-8\n let x = *bytes.get_unchecked(pos);\n if x < 128 {\n self.pos = pos + 1;\n return Some((start, char::from_u32_unchecked(x as u32)));\n }\n\n // Multibyte case follows\n // Decode from a byte combination out of: [[[x y] z] w]\n // NOTE: Performance is sensitive to the exact formulation here\n let init = Self::utf8_first_byte(x, 2);\n\n pos = pos + 1;\n let y = if pos == end {\n 0u8\n } else {\n *bytes.get_unchecked(pos)\n };\n let mut ch = Self::utf8_acc_cont_byte(init, y);\n if x >= 0xE0 {\n // [[x y z] w] case\n // 5th bit in 0xE0 .. 0xEF is always clear, so `init` is still valid\n pos = pos + 1;\n let z = if pos == end {\n 0u8\n } else {\n *bytes.get_unchecked(pos)\n };\n let y_z = Self::utf8_acc_cont_byte((y & Self::CONT_MASK) as u32, z);\n ch = init << 12 | y_z;\n if x >= 0xF0 {\n // [x y z w] case\n // use only the lower 3 bits of `init`\n pos = pos + 1;\n let w = if pos == end {\n 0u8\n } else {\n *bytes.get_unchecked(pos)\n };\n ch = (init & 7) << 18 | Self::utf8_acc_cont_byte(y_z, w);\n }\n }\n\n pos = pos + 1;\n if pos >= end {\n self.eof = true\n }\n self.pos = pos;\n\n Some((start, char::from_u32_unchecked(ch as u32)))\n }\n\n /// Returns the initial codepoint accumulator for the first byte.\n /// The first byte is special, only want bottom 5 bits for width 2, 4 bits\n /// for width 3, and 3 bits for width 4.\n #[inline]\n fn utf8_first_byte(byte: u8, width: u32) -> u32 {\n (byte & (0x7F >> width)) as u32\n }\n\n /// Returns the value of `ch` updated with continuation byte `byte`.\n #[inline]\n fn utf8_acc_cont_byte(ch: u32, byte: u8) -> u32 {\n (ch << 6) | (byte & Self::CONT_MASK) as u32\n }\n\n /// Mask of the value bits of a continuation byte.\n const CONT_MASK: u8 = 0b0011_1111;\n}\nimpl Source for FileMapSource {\n fn new(src: Arc) -> Self {\n let start = SourceIndex::new(src.id(), ByteIndex(0));\n let mut source = Self {\n src,\n bytes: &[],\n peek: None,\n start,\n end: 0,\n pos: 0,\n eof: false,\n };\n let s = source.src.source();\n let bytes = s.as_bytes();\n source.end = bytes.len();\n source.bytes = bytes;\n source.peek = unsafe { source.next_char_internal() };\n source\n }\n\n #[inline]\n fn read(&mut self) -> Option<(SourceIndex, char)> {\n self.next_char()\n }\n\n #[inline]\n fn peek(&mut self) -> Option<(SourceIndex, char)> {\n self.peek_char()\n }\n\n #[inline]\n fn span(&self) -> SourceSpan {\n self.src.source_span()\n }\n\n #[inline]\n fn slice(&self, span: impl Into>) -> &str {\n self.src.source_slice(span).unwrap()\n }\n}\n\nimpl Iterator for FileMapSource {\n type Item = (SourceIndex, char);\n\n fn next(&mut self) -> Option {\n self.read()\n }\n}\n\n#[cfg(test)]\nmod test {\n use pretty_assertions::assert_eq;\n\n use super::*;\n\n fn read_all_chars(source: FileMapSource) -> Vec {\n source.map(|result| result.1).collect()\n }\n\n #[test]\n fn file_source() {\n let expected = vec!['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd', '!'];\n\n let codemap = CodeMap::default();\n\n let id1 = codemap.add(\"nofile\", \"hello world!\".to_string());\n let file1 = codemap.get(id1).unwrap();\n let source1 = FileMapSource::new(file1);\n let chars = read_all_chars(source1);\n\n assert_eq!(expected, chars);\n\n let id2 = codemap.add(\"nofile\", \"hello world!\".to_string());\n let file2 = codemap.get(id2).unwrap();\n let mut source2 = FileMapSource::new(file2);\n assert_eq!(\n Some((SourceIndex::new(id2, ByteIndex(0)), 'h')),\n source2.peek()\n );\n assert_eq!(\n Some((SourceIndex::new(id2, ByteIndex(0)), 'h')),\n source2.next()\n );\n\n let id3 = codemap.add(\"nofile\", \"éé\".to_string());\n let file3 = codemap.get(id3).unwrap();\n let mut source3 = FileMapSource::new(file3);\n assert_eq!(\n Some((SourceIndex::new(id3, ByteIndex(0)), 'é')),\n source3.peek()\n );\n assert_eq!(\n Some((SourceIndex::new(id3, ByteIndex(0)), 'é')),\n source3.next()\n );\n assert_eq!(\n Some((SourceIndex::new(id3, ByteIndex(2)), 'é')),\n source3.peek()\n );\n assert_eq!(\n Some((SourceIndex::new(id3, ByteIndex(2)), 'é')),\n source3.next()\n );\n }\n}\n" }, { "path": "util/libeir_util_parse/src/util.rs", "content": "use std::env;\nuse std::path::{Path, PathBuf};\n\nuse libeir_diagnostics::Diagnostic;\n\nuse snafu::Snafu;\n\n#[derive(Debug, Snafu)]\npub enum PathVariableSubstituteError {\n InvalidPathVariable {\n variable: String,\n source: std::env::VarError,\n },\n}\nimpl PathVariableSubstituteError {\n pub fn to_diagnostic(&self) -> Diagnostic {\n match self {\n PathVariableSubstituteError::InvalidPathVariable {\n source: env::VarError::NotPresent,\n variable,\n } => Diagnostic::error().with_message(format!(\n \"invalid environment variable '{}': not defined\",\n variable,\n )),\n PathVariableSubstituteError::InvalidPathVariable {\n source: env::VarError::NotUnicode { .. },\n variable,\n } => Diagnostic::error().with_message(format!(\n \"invalid environment variable '{}': contains invalid unicode data\",\n variable,\n )),\n }\n }\n}\n\npub fn substitute_path_variables>(\n path: P,\n) -> Result {\n let mut new = PathBuf::new();\n for c in path.as_ref().components() {\n if let Some(s) = c.as_os_str().to_str() {\n if s.as_bytes().get(0) == Some(&b'$') {\n let var = s.split_at(1).1;\n match env::var(var) {\n Ok(c) => {\n new.push(c);\n continue;\n }\n Err(e) => {\n return Err(PathVariableSubstituteError::InvalidPathVariable {\n variable: var.to_owned(),\n source: e,\n });\n }\n }\n }\n }\n new.push(c.as_os_str());\n }\n Ok(new)\n}\n" }, { "path": "util/libeir_util_parse_listing/Cargo.toml", "content": "[package]\nname = \"libeir_util_parse_listing\"\nversion = \"0.1.0\"\nauthors = [\"Hans Elias B. Josephsen \"]\nedition = \"2018\"\nbuild = \"build.rs\"\nlicense = \"MIT OR Apache-2.0\"\n\n[dependencies]\nlibeir_util_parse = { path = \"../libeir_util_parse\" }\nlibeir_ir = { path = \"../../libeir_ir\" }\nlibeir_diagnostics = { path = \"../../libeir_diagnostics\" }\nlibeir_intern = { path = \"../../libeir_intern\" }\n\nlalrpop-util = \"0.17\"\n\n[dev-dependencies]\ncodespan-reporting = \"0.9\"\n\n[build-dependencies]\nlalrpop = \"0.17\"\n" }, { "path": "util/libeir_util_parse_listing/build.rs", "content": "extern crate lalrpop;\n\nfn main() {\n lalrpop::Configuration::new()\n .use_cargo_dir_conventions()\n .process_file(\"src/grammar.lalrpop\")\n .unwrap();\n println!(\"cargo:rerun-if-changed=src/grammar.lalrpop\");\n}\n" }, { "path": "util/libeir_util_parse_listing/src/ast.rs", "content": "use libeir_diagnostics::SourceSpan;\nuse libeir_intern::Ident;\nuse libeir_ir::Integer;\n\n#[derive(Debug)]\npub struct Root {\n pub items: Vec,\n}\nimpl Root {\n pub fn span(&self) -> SourceSpan {\n self.items\n .first()\n .map(|i| i.span())\n .unwrap_or(SourceSpan::UNKNOWN)\n }\n}\n\n#[derive(Debug)]\npub enum Item {\n Atom(Ident),\n String(Ident),\n Int(Int),\n Float(Float),\n\n Tuple(Tuple),\n List(List),\n}\n\nimpl Item {\n pub fn tuple(&self) -> Option<&Tuple> {\n match self {\n Item::Tuple(inner) => Some(inner),\n _ => None,\n }\n }\n\n pub fn atom(&self) -> Option {\n match self {\n Item::Atom(inner) => Some(*inner),\n _ => None,\n }\n }\n\n pub fn string(&self) -> Option {\n match self {\n Item::String(inner) => Some(*inner),\n _ => None,\n }\n }\n\n pub fn integer(&self) -> Option<&Int> {\n match self {\n Item::Int(inner) => Some(inner),\n _ => None,\n }\n }\n\n pub fn float(&self) -> Option<&Float> {\n match self {\n Item::Float(inner) => Some(inner),\n _ => None,\n }\n }\n\n pub fn list(&self) -> Option<&List> {\n match self {\n Item::List(inner) => Some(inner),\n _ => None,\n }\n }\n\n pub fn list_iter(&self) -> Option> {\n self.list().map(|v| ListIterator {\n curr: Some(v),\n idx: 0,\n })\n }\n\n pub fn span(&self) -> SourceSpan {\n match self {\n Item::Atom(ident) => ident.span,\n Item::String(ident) => ident.span,\n Item::Int(int) => int.span,\n Item::Tuple(tup) => tup.span,\n Item::List(list) => list.span,\n Item::Float(float) => float.span,\n }\n }\n}\n\npub struct ListIterator<'a> {\n curr: Option<&'a List>,\n idx: usize,\n}\nimpl<'a> Iterator for ListIterator<'a> {\n type Item = &'a Item;\n fn next(&mut self) -> Option {\n if let Some(list) = self.curr {\n if let Some(result) = list.heads.get(self.idx) {\n self.idx += 1;\n return Some(result);\n } else {\n self.idx = 0;\n if let Some(tail) = &list.tail {\n if let Some(tail_list) = tail.list() {\n self.curr = Some(tail_list);\n return self.next();\n } else {\n unimplemented!()\n }\n } else {\n self.curr = None;\n return None;\n }\n }\n } else {\n None\n }\n }\n}\n\n#[derive(Debug)]\npub struct Int {\n pub integer: Integer,\n pub span: SourceSpan,\n}\n\n#[derive(Debug)]\npub struct Float {\n pub float: f64,\n pub span: SourceSpan,\n}\n\n#[derive(Debug)]\npub struct Tuple {\n pub entries: Vec,\n pub span: SourceSpan,\n}\n\n#[derive(Debug)]\npub struct List {\n pub heads: Vec,\n pub tail: Option>,\n pub span: SourceSpan,\n}\n" }, { "path": "util/libeir_util_parse_listing/src/grammar.lalrpop", "content": "//-*- mode: rust -*-\nuse libeir_ir::Integer;\nuse libeir_intern::{Symbol, Ident};\nuse libeir_diagnostics::{SourceIndex, SourceSpan};\n\nuse super::super::token::{Token, Float as FloatToken};\nuse super::super::ast::*;\n\ngrammar();\n\n// Comma-delimited with zero or more elements\nCommaOpt: Vec = {\n \",\")*> => {\n let mut vals = vals;\n vals.extend(last);\n vals\n },\n};\n\npub Item: Item = {\n \"{\" > \"}\" => {\n Item::Tuple(Tuple {\n entries,\n span: SourceSpan::new(l, r),\n })\n },\n \"[\" > )?> \"]\" => {\n Item::List(List {\n heads,\n tail: tail.map(Box::new),\n span: SourceSpan::new(l, r),\n })\n },\n\n => {\n Item::Atom(Ident::new(v, SourceSpan::new(l, r)))\n },\n => {\n Item::Int(Int {\n integer: v,\n span: SourceSpan::new(l, r),\n })\n },\n => {\n Item::String(Ident::new(v, SourceSpan::new(l, r)))\n },\n => {\n Item::Float(Float {\n float: f.0,\n span: SourceSpan::new(l, r),\n })\n },\n};\n\npub Root: Root = {\n <( \".\")*> => {\n Root {\n items: <>,\n }\n },\n};\n\nextern {\n type Location = SourceIndex;\n type Error = ();\n\n enum Token {\n atom => Token::Atom(),\n integer => Token::Integer(),\n string => Token::String(),\n float => Token::Float(),\n \",\" => Token::Comma,\n \".\" => Token::Dot,\n \"|\" => Token::Pipe,\n \"[\" => Token::SquareOpen,\n \"]\" => Token::SquareClose,\n \"{\" => Token::CurlyOpen,\n \"}\" => Token::CurlyClose,\n }\n}\n" }, { "path": "util/libeir_util_parse_listing/src/lib.rs", "content": "#![deny(unused)]\npub mod ast;\npub mod parser;\nmod token;\n" }, { "path": "util/libeir_util_parse_listing/src/parser.rs", "content": "use std::convert::From;\n\nuse libeir_diagnostics::*;\nuse libeir_util_parse::{ErrorReceiver, Parse, Parser, Scanner, Source};\n\nuse super::ast;\nuse super::token::{Lexer, Token};\n\n#[cfg_attr(rustfmt, rustfmt_skip)]\n#[allow(unknown_lints)]\n#[allow(clippy)]\n#[allow(unused)]\npub(crate) mod grammar {\n // During the build step, `build.rs` will output the generated parser to `OUT_DIR` to avoid\n // adding it to the source directory, so we just directly include the generated parser here.\n //\n // Even with `.gitignore` and the `exclude` in the `Cargo.toml`, the generated parser can still\n // end up in the source directory. This could happen when `cargo build` builds the file out of\n // the Cargo cache (`$HOME/.cargo/registrysrc`), and the build script would then put its output\n // in that cached source directory because of https://github.com/lalrpop/lalrpop/issues/280.\n // Later runs of `cargo vendor` then copy the source from that directory, including the\n // generated file.\n include!(concat!(env!(\"OUT_DIR\"), \"/grammar.rs\"));\n}\n\n#[derive(Debug)]\npub enum ParseError {\n RootFileError {\n source: std::io::Error,\n path: std::path::PathBuf,\n },\n LalrPop(lalrpop_util::ParseError),\n}\nimpl ParseError {\n pub fn new(err: lalrpop_util::ParseError) -> Self {\n ParseError::LalrPop(err)\n }\n}\nimpl From> for ParseError {\n fn from(err: lalrpop_util::ParseError) -> Self {\n Self::new(err)\n }\n}\n\nimpl ToDiagnostic for ParseError {\n fn to_diagnostic(&self) -> Diagnostic {\n use lalrpop_util::ParseError::*;\n match self {\n Self::RootFileError { source, path } => Diagnostic::error()\n .with_message(format!(\"{} occurred when reading {:?}\", source, path)),\n Self::LalrPop(InvalidToken { location }) => {\n let source_id = location.source_id();\n let index = *location;\n Diagnostic::error()\n .with_message(\"invalid token\")\n .with_labels(vec![Label::primary(\n source_id,\n SourceSpan::new(index, index),\n )\n .with_message(\"invalid token encountered here\")])\n }\n Self::LalrPop(UnrecognizedEOF { location, expected }) => {\n let source_id = location.source_id();\n let index = *location;\n Diagnostic::error()\n .with_message(\"unexpected end of file\")\n .with_labels(vec![Label::primary(\n source_id,\n SourceSpan::new(index, index),\n )\n .with_message(&format!(\"expected one of: {}\", expected.join(\", \")))])\n }\n Self::LalrPop(ExtraToken { token: (l, _, r) }) => Diagnostic::error()\n .with_message(\"extra token\")\n .with_labels(vec![Label::primary(l.source_id(), SourceSpan::new(*l, *r))\n .with_message(\"did not expect this token\")]),\n Self::LalrPop(UnrecognizedToken {\n token: (l, _, r), ..\n }) => Diagnostic::error()\n .with_message(\"unexpected token\")\n .with_labels(vec![Label::primary(l.source_id(), SourceSpan::new(*l, *r))\n .with_message(\"did not expect this token\")]),\n Self::LalrPop(User { .. }) => Diagnostic::error().with_message(\"parsing failed\"),\n }\n }\n}\n\nimpl Parse for ast::Root {\n type Parser = grammar::RootParser;\n type Error = ParseError;\n type Config = ();\n type Token = Result<(SourceIndex, Token, SourceIndex), ()>;\n\n fn root_file_error(source: std::io::Error, path: std::path::PathBuf) -> Self::Error {\n ParseError::RootFileError { source, path }\n }\n\n fn parse(\n _parser: &Parser,\n errors: &mut dyn ErrorReceiver,\n source: S,\n ) -> Result\n where\n S: Source,\n {\n let scanner = Scanner::new(source);\n let lexer = Lexer::new(scanner);\n Self::parse_tokens(errors, lexer)\n }\n\n fn parse_tokens(\n errors: &mut dyn ErrorReceiver,\n tokens: S,\n ) -> Result\n where\n S: IntoIterator,\n {\n match Self::Parser::new().parse(tokens) {\n Ok(inner) => Ok(inner),\n Err(err) => {\n errors.error(err.into());\n Err(())\n }\n }\n }\n}\n\n#[cfg(test)]\nmod test {\n use std::sync::Arc;\n\n use super::ast::Root;\n use super::ParseError;\n use libeir_diagnostics::*;\n use libeir_util_parse::{Errors, Parse, Parser};\n\n fn fail_with(errors: &Errors, codemap: &CodeMap) -> !\n where\n E: ToDiagnostic,\n W: ToDiagnostic,\n {\n use term::termcolor::{ColorChoice, StandardStream};\n\n let config = term::Config::default();\n let mut out = StandardStream::stderr(ColorChoice::Always);\n for diagnostic in errors.iter_diagnostics() {\n term::emit(&mut out, &config, codemap, &diagnostic).unwrap();\n }\n panic!();\n }\n\n fn parse(input: S) -> T\n where\n T: Parse,\n S: AsRef,\n {\n let parser = Parser::new((), Arc::new(CodeMap::new()));\n let mut errors = Errors::new();\n match parser.parse_string::(&mut errors, input) {\n Ok(ast) => return ast,\n Err(()) => fail_with(&errors, &parser.codemap),\n };\n }\n\n #[test]\n fn simple() {\n let _: Root = parse(\n \"\n{woo, '123fwoo', {}}.\n\",\n );\n }\n\n #[test]\n fn basic_ast() {\n let _: Root = parse(\n \"\n{attribute,1,file,{\\\"woo.erl\\\",1}}.\n{attribute,1,module,woo}.\n{attribute,3,export,[{foo,2},{bar,1},{barr,1}]}.\n{function,5,foo,2,\n [{clause,5,\n [{var,5,'A'},{var,5,'B'}],\n [],\n [{op,5,'+',{var,5,'A'},{var,5,'B'}}]}]}.\n{function,7,bar,1,\n [{clause,7,[{integer,7,1}],[],[{integer,7,2}]},\n {clause,8,[{integer,8,2}],[],[{integer,8,4}]},\n {clause,9,[{var,9,'N'}],[],[{var,9,'N'}]}]}.\n{function,11,barr,1,\n [{clause,11,[{integer,11,1}],[],[{integer,11,2}]},\n {clause,12,[{integer,12,2}],[],[{integer,12,4}]}]}.\n{function,14,binary,0,\n [{clause,14,[],[],\n [{bin,14,[{bin_element,14,{string,14,\\\"woo\\\"},default,default}]}]}]}.\n{function,16,string,0,[{clause,16,[],[],[{string,16,\\\"woo\\\"}]}]}.\n{eof,17}.\n\",\n );\n }\n}\n" }, { "path": "util/libeir_util_parse_listing/src/token.rs", "content": "use std::str::FromStr;\n\nuse libeir_diagnostics::*;\nuse libeir_intern::Symbol;\nuse libeir_ir::Integer;\nuse libeir_util_parse::{Scanner, Source};\n\nmacro_rules! pop {\n ($lex:ident) => {{\n $lex.skip();\n }};\n ($lex:ident, $code:expr) => {{\n $lex.skip();\n $code\n }};\n}\n\n#[derive(Debug, Clone, PartialEq, Eq)]\npub enum Token {\n EOF,\n\n Comma,\n Dot,\n Pipe,\n SquareOpen,\n SquareClose,\n CurlyOpen,\n CurlyClose,\n\n Atom(Symbol),\n String(Symbol),\n Integer(Integer),\n Float(Float),\n}\n\n#[derive(Debug, Clone, PartialEq, PartialOrd)]\npub struct Float(pub f64);\nimpl Eq for Float {}\n\npub struct Lexer {\n scanner: Scanner,\n token: Token,\n token_start: SourceIndex,\n token_end: SourceIndex,\n eof: bool,\n\n str_buf: String,\n}\n\nimpl Lexer\nwhere\n S: Source,\n{\n pub fn new(scanner: Scanner) -> Self {\n let start = scanner.start();\n let mut lexer = Self {\n scanner,\n token: Token::EOF,\n token_start: start,\n token_end: start,\n eof: false,\n\n str_buf: String::new(),\n };\n lexer.advance();\n lexer\n }\n\n pub fn lex(&mut self) -> Option<::Item> {\n if self.eof && self.token == Token::EOF {\n return None;\n }\n\n let token = std::mem::replace(&mut self.token, Token::EOF);\n let result = Some(Ok((\n self.token_start.clone(),\n token,\n self.token_end.clone(),\n )));\n\n self.advance();\n\n result\n }\n\n fn advance(&mut self) {\n self.advance_start();\n self.token = self.tokenize();\n }\n\n fn advance_start(&mut self) {\n let mut position: SourceIndex;\n loop {\n let (pos, c) = self.scanner.read();\n position = pos;\n\n if c == '\\0' {\n self.eof = true;\n return;\n }\n\n if c.is_whitespace() {\n self.scanner.advance();\n continue;\n }\n\n break;\n }\n\n self.token_start = position;\n }\n\n fn pop(&mut self) -> char {\n let (pos, c) = self.scanner.pop();\n self.token_end = pos + ByteOffset::from_char_len(c);\n c\n }\n\n fn peek(&mut self) -> char {\n self.scanner.peek().1\n }\n\n fn read(&mut self) -> char {\n self.scanner.read().1\n }\n\n fn skip(&mut self) {\n self.pop();\n }\n\n pub fn span(&self) -> SourceSpan {\n SourceSpan::new(self.token_start, self.token_end)\n }\n\n fn slice(&self) -> &str {\n self.scanner.slice(self.span())\n }\n\n fn skip_whitespace(&mut self) {\n while self.read().is_whitespace() {\n self.skip();\n }\n }\n\n fn lex_unquoted_atom(&mut self) -> Token {\n let c = self.pop();\n debug_assert!(c.is_ascii_lowercase());\n\n loop {\n match self.read() {\n '_' => self.skip(),\n '@' => self.skip(),\n '0'..='9' => self.skip(),\n c if c.is_alphanumeric() => self.skip(),\n _ => break,\n }\n }\n\n Token::Atom(Symbol::intern(self.slice()))\n }\n\n fn lex_quoted_atom(&mut self) -> Token {\n let c = self.pop();\n debug_assert!(c == '\\'');\n\n self.str_buf.clear();\n\n loop {\n match self.read() {\n '\\\\' => unimplemented!(),\n '\\'' => {\n self.skip();\n break;\n }\n c => {\n self.skip();\n self.str_buf.push(c);\n }\n }\n }\n\n Token::Atom(Symbol::intern(&self.str_buf))\n }\n\n fn lex_string(&mut self) -> Token {\n let c = self.pop();\n debug_assert!(c == '\"');\n\n self.str_buf.clear();\n\n loop {\n match self.read() {\n '\\\\' => unimplemented!(),\n '\"' => {\n self.skip();\n break;\n }\n c => {\n self.skip();\n self.str_buf.push(c);\n }\n }\n }\n\n Token::String(Symbol::intern(&self.str_buf))\n }\n\n fn lex_number(&mut self) -> Token {\n let c = self.pop();\n debug_assert!(c == '-' || c == '+' || c.is_digit(10));\n //let negative = c == '-';\n\n while self.read().is_digit(10) {\n self.skip();\n }\n\n let c = self.read();\n if c == '.' {\n if self.peek().is_digit(10) {\n self.skip();\n return self.lex_float();\n }\n return Token::Integer(Integer::from_string_radix(self.slice(), 10).unwrap());\n }\n\n // TODO Float\n\n return Token::Integer(Integer::from_string_radix(self.slice(), 10).unwrap());\n }\n\n fn lex_float(&mut self) -> Token {\n let c = self.pop();\n println!(\"{}\", c);\n debug_assert!(c.is_digit(10));\n\n while self.read().is_digit(10) {\n self.pop();\n }\n\n match f64::from_str(self.slice()) {\n Ok(f) => Token::Float(Float(f)),\n Err(_e) => unimplemented!(),\n }\n }\n\n fn tokenize(&mut self) -> Token {\n let c = self.read();\n\n if c == '\\0' {\n self.eof = true;\n return Token::EOF;\n }\n\n if c.is_whitespace() {\n self.skip_whitespace();\n }\n\n match self.read() {\n '{' => pop!(self, Token::CurlyOpen),\n '}' => pop!(self, Token::CurlyClose),\n '[' => pop!(self, Token::SquareOpen),\n ']' => pop!(self, Token::SquareClose),\n ',' => pop!(self, Token::Comma),\n '.' => pop!(self, Token::Dot),\n '|' => pop!(self, Token::Pipe),\n 'a'..='z' | 'A'..='Z' => self.lex_unquoted_atom(),\n '0'..='9' => self.lex_number(),\n '\\'' => self.lex_quoted_atom(),\n '\"' => self.lex_string(),\n c => unimplemented!(\"{}\", c),\n }\n }\n}\n\nimpl Iterator for Lexer\nwhere\n S: Source,\n{\n type Item = Result<(SourceIndex, Token, SourceIndex), ()>;\n\n fn next(&mut self) -> Option {\n self.lex()\n }\n}\n" }, { "path": "util/libeir_util_pattern_compiler/Cargo.toml", "content": "[package]\nauthors = [\"HansiHE \"]\nname = \"libeir_util_pattern_compiler\"\nversion = \"0.1.0\"\nedition = \"2018\"\nlicense = \"MIT OR Apache-2.0\"\n\ndescription = \"Utilities for compiling pattern matches into optimal decision trees\"\nrepository = \"https://github.com/hansihe/core_erlang/tree/master/pattern-compiler\"\n\n[features]\ndebug_table_print = [\"prettytable-rs\"]\n#default = [\"debug_table_print\"]\n\n[dependencies]\neither = \"1.5\"\npetgraph = \"0.4\"\nderivative = \"1.0\"\nprettytable-rs = { version = \"0.8\", optional = true }\nitertools = \"0.8.0\"\n\nlog = \"0.4\"\n" }, { "path": "util/libeir_util_pattern_compiler/README.md", "content": "# Pattern compiler\n\nImplements a variant of http://www.cs.tufts.edu/~nr/cs257/archive/luc-maranget/jun08.pdf\n\nCrate that compiles pattern matching into optimal decision trees.\n" }, { "path": "util/libeir_util_pattern_compiler/src/cfg/generate_dot.rs", "content": "use std::io::Write;\n\nuse petgraph::visit::EdgeRef;\nuse petgraph::Direction;\n\nuse crate::cfg::PatternCfg;\nuse crate::pattern::PatternProvider;\n\nconst DOT_BREAK: &str = \"
\";\n\nfn format_label(label: &str) -> String {\n label\n .replace(\"{\", \"\\\\{\")\n .replace(\"}\", \"\\\\}\")\n .replace(\"\\n\", DOT_BREAK)\n}\n\nimpl

PatternCfg

\nwhere\n P: PatternProvider,\n{\n pub fn to_dot(&self, w: &mut dyn Write) -> ::std::io::Result<()> {\n write!(w, \"digraph g {{\\n\")?;\n write!(\n w,\n \"node [labeljust=\\\"l\\\", shape=record, fontname=\\\"Courier New\\\"]\\n\"\n )?;\n write!(w, \"edge [fontname=\\\"Courier New\\\" ]\\n\\n\")?;\n\n for index in self.graph.node_indices() {\n let node = &self.graph[index];\n //println!(\"{:?}\", node);\n\n let label = format_label(&format!(\"{:?}\", node));\n write!(\n w,\n \"node_{} [ label=<{}: {}\",\n index.index(),\n index.index(),\n label\n )?;\n\n if let Some(bindings) = self.leaf_bindings.get(&index) {\n write!(\n w,\n \"{} {}\",\n DOT_BREAK,\n format_label(&format!(\"{:#?}\", bindings))\n )?;\n }\n\n write!(w, \"> ]\\n\")?;\n\n for edge in self.graph.edges_directed(index, Direction::Outgoing) {\n let label = format_label(&format!(\"{:?}\", edge.weight()));\n write!(\n w,\n \"node_{} -> node_{} [ label=<{}> ]\\n\",\n edge.source().index(),\n edge.target().index(),\n label\n )?;\n }\n\n write!(w, \"\\n\")?;\n }\n\n write!(w, \"}}\\n\")?;\n Ok(())\n }\n}\n" }, { "path": "util/libeir_util_pattern_compiler/src/cfg/mod.rs", "content": "use ::std::collections::HashMap;\n\nuse ::petgraph::graph::NodeIndex;\nuse ::petgraph::Graph;\n\nmod generate_dot;\n\nuse super::pattern::PatternProvider;\n\npub type CfgNodeIndex = NodeIndex;\n\n//#[derive(Debug, Clone)]\n//pub struct Leaf

where P: PatternProvider {\n// bindings: HashMap,\n//}\n\n#[derive(Debug, Clone)]\npub struct PatternCfg

\nwhere\n P: PatternProvider,\n{\n pub entry: CfgNodeIndex,\n pub graph: Graph, CfgEdge

>,\n pub leaf_bindings: HashMap>,\n}\n\nimpl

PatternCfg

\nwhere\n P: PatternProvider,\n{\n pub(crate) fn new() -> Self {\n let mut graph = Graph::new();\n PatternCfg {\n entry: graph.add_node(CfgNodeKind::Root),\n graph: graph,\n leaf_bindings: HashMap::new(),\n }\n }\n\n pub(crate) fn add_fail(&mut self) -> CfgNodeIndex {\n self.graph.add_node(CfgNodeKind::Fail)\n }\n\n pub(crate) fn add_leaf(\n &mut self,\n parent: CfgNodeIndex,\n leaf_num: usize,\n edge: CfgEdge

,\n binds: HashMap,\n ) -> CfgNodeIndex {\n let index = self.graph.add_node(CfgNodeKind::Leaf(leaf_num));\n self.graph.add_edge(parent, index, edge);\n self.leaf_bindings.insert(index, binds);\n index\n }\n\n pub fn get_entry(&self) -> CfgNodeIndex {\n self.entry\n }\n\n //pub fn add_node(&mut self, var: P::CfgVariable) -> CfgNodeIndex {\n // self.graph.add_node(CfgNodeKind::Match(var))\n //}\n\n pub(crate) fn add_edge(&mut self, parent: CfgNodeIndex, child: CfgNodeIndex, edge: CfgEdge

) {\n self.graph.add_edge(parent, child, edge);\n }\n\n pub(crate) fn add_child(\n &mut self,\n parent: CfgNodeIndex,\n typ: CfgEdge

,\n var: P::CfgVariable,\n binds: HashMap,\n ) -> CfgNodeIndex {\n let child = self.graph.add_node(CfgNodeKind::Match(var));\n self.graph.add_edge(parent, child, typ);\n self.leaf_bindings.insert(child, binds);\n child\n }\n}\n\n#[derive(Clone)]\npub struct CfgEdge

\nwhere\n P: PatternProvider,\n{\n //_provider: ::std::marker::PhantomData

,\n pub kind: Option,\n pub variable_binds: Vec,\n //pub pattern_node: super::pattern::PatternNodeIndex,\n}\nimpl

::std::fmt::Debug for CfgEdge

\nwhere\n P: PatternProvider,\n{\n fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {\n if let Some(kind) = self.kind {\n write!(f, \"{:?} {:?}\", kind, self.variable_binds)\n } else {\n write!(f, \"\")\n }\n }\n}\n\n#[derive(Debug, Clone, PartialEq, Eq)]\npub enum CfgNodeKind {\n Root,\n Match(CVT),\n Fail,\n Leaf(usize),\n}\n" }, { "path": "util/libeir_util_pattern_compiler/src/lib.rs", "content": "#![deny(warnings)]\n\n// Implements a variant of\n// http://www.cs.tufts.edu/~nr/cs257/archive/luc-maranget/jun08.pdf\n\n#[macro_use]\nextern crate derivative;\n\npub use petgraph::visit::EdgeRef;\n\nmod pattern;\npub use self::pattern::{ExpandedClauseNodes, PatternProvider};\n\nmod cfg;\npub use self::cfg::{CfgEdge, CfgNodeIndex, CfgNodeKind, PatternCfg};\n\nmod matrix;\n\npub mod simple_pattern;\n\npub use ::petgraph::graph::NodeIndex;\n\n#[cfg(feature = \"debug_table_print\")]\nuse log::trace;\n#[cfg(feature = \"debug_table_print\")]\nconst TARGET: &'static str = \"pattern_compiler\";\n\n#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]\nstruct LeafId(usize);\n\n#[derive(Debug)]\npub struct MatchCompileContext<'a, P>\nwhere\n P: pattern::PatternProvider + 'a,\n{\n pattern: &'a mut P,\n\n cfg: cfg::PatternCfg

,\n\n root_matrix: matrix::MatchMatrix

,\n fail_leaf: NodeIndex,\n}\nimpl<'a, P> MatchCompileContext<'a, P>\nwhere\n P: PatternProvider,\n{\n pub fn new(pattern: &'a mut P) -> Self {\n let root = pattern.get_root();\n\n let mut cfg = cfg::PatternCfg::new();\n let fail_leaf = cfg.add_fail();\n let leaves: Vec = (0..(root.clauses)).map(|idx| LeafId(idx)).collect();\n\n let root_matrix = matrix::MatchMatrix::new(&root.nodes, leaves, root.variables);\n\n MatchCompileContext {\n pattern: pattern,\n\n cfg: cfg,\n\n root_matrix: root_matrix,\n fail_leaf: fail_leaf,\n }\n }\n\n fn root_matrix(&self) -> &matrix::MatchMatrix

{\n &self.root_matrix\n }\n}\n\nfn matrix_to_decision_tree

(\n parent: cfg::CfgNodeIndex,\n ctx: &mut MatchCompileContext

,\n spec: Option,\n matrix: &matrix::MatchMatrix

,\n introduced_vars: Vec,\n level: usize,\n) where\n P: PatternProvider,\n{\n #[cfg(feature = \"debug_table_print\")]\n {\n let mut buf = String::new();\n for _ in 0..level {\n write!(buf, \" ==\");\n }\n write!(buf, \" MATRIX AT LEVEL {}\", level);\n trace!(target: TARGET, \"{}\", buf);\n }\n\n let edge = cfg::CfgEdge {\n kind: spec.clone(),\n variable_binds: introduced_vars,\n };\n\n // Matrix is empty, no specializations can be done.\n if matrix.is_empty() {\n ctx.cfg.add_edge(parent, ctx.fail_leaf, edge);\n return;\n }\n\n // If the head of the matrix has only wildcards, none of the other rows\n // can happen.\n if let Some(node_id) = matrix.has_wildcard_head(&ctx.pattern) {\n let binds = matrix.binds_for(node_id).unwrap();\n let node = ctx.cfg.add_leaf(parent, node_id.0, edge, binds.clone());\n\n let new_mat = matrix.without_head();\n matrix_to_decision_tree(node, ctx, None, &new_mat, vec![], level + 1);\n\n return;\n }\n\n // Select the variable we should specialize on.\n // This will be the column with the most consecutive non-wildcards\n // at the head.\n let specialize_variable = matrix.select_specialize_variable(&ctx.pattern);\n let specialize_variable_cfg_var = matrix.get_var(specialize_variable);\n\n // Add new CFG node for current\n let cfg_node = ctx.cfg.add_child(\n parent,\n edge,\n specialize_variable_cfg_var,\n matrix.binds_for_head().clone(),\n );\n\n // Find what pattern types we have as children, so that we can\n // specialize and branch to them in the CFG\n let specialization_types =\n matrix.collect_specialization_types(&ctx.pattern, specialize_variable);\n\n // Specialize on specific matrices\n for specialization in specialization_types.iter() {\n let (introduced, specialized) =\n matrix.specialize(ctx, specialize_variable, *specialization);\n\n matrix_to_decision_tree(\n cfg_node,\n ctx,\n Some(*specialization),\n &specialized,\n introduced,\n level + 1,\n );\n }\n\n // Specialize on default matrix\n let (introduced, default) = matrix.default(ctx, specialize_variable);\n\n let wildcard = ctx.pattern.get_wildcard();\n matrix_to_decision_tree(\n cfg_node,\n ctx,\n Some(wildcard),\n &default,\n introduced,\n level + 1,\n );\n}\n\npub fn to_decision_tree

(pattern: &mut P) -> cfg::PatternCfg

\nwhere\n P: PatternProvider,\n{\n let mut context = MatchCompileContext::new(pattern);\n\n let root: matrix::MatchMatrix

= (*context.root_matrix()).clone();\n\n let root_cfg = context.cfg.get_entry();\n let wildcard = context.pattern.get_wildcard();\n\n matrix_to_decision_tree(\n root_cfg,\n &mut context,\n Some(wildcard),\n &root,\n root.variables.clone(),\n 0,\n );\n\n let cfg = context.cfg;\n assert!(!::petgraph::algo::is_cyclic_directed(&cfg.graph));\n cfg\n}\n" }, { "path": "util/libeir_util_pattern_compiler/src/matrix.rs", "content": "use std::collections::{HashMap, HashSet};\n\n#[cfg(feature = \"debug_table_print\")]\nuse prettytable::Table;\n\n#[cfg(feature = \"debug_table_print\")]\nuse super::TARGET;\n#[cfg(feature = \"debug_table_print\")]\nuse log::trace;\n\nuse super::pattern::PatternProvider;\nuse super::LeafId;\n\n#[derive(Debug, Derivative)]\n#[derivative(Clone(bound = \"\"))]\npub(crate) struct MatchMatrix

\nwhere\n P: PatternProvider,\n{\n pub data: Vec>,\n\n pub variables: Vec,\n pub clause_leaves: Vec,\n\n pub leaf_bindings: Vec>,\n}\n\n#[derive(Debug, Derivative)]\n#[derivative(Clone(bound = \"\"))]\npub struct MatchMatrixElement

\nwhere\n P: PatternProvider,\n{\n pub node: P::PatternNodeKey,\n pub variable_num: usize,\n pub clause_num: usize,\n}\n\n//fn chunks_len<'a, T>(entities: &'a [T], chunk_len: usize, num_chunks: usize)\n// -> impl Iterator + 'a {\n//\n// assert!(entities.len() == (chunk_len * num_chunks));\n// let ret = if chunk_len == 0 {\n// Either::Left((0..num_chunks).map(|_| [].as_ref()))\n// } else {\n// Either::Right(entities.chunks(chunk_len))\n// };\n// ret\n//}\n\nimpl

MatchMatrix

\nwhere\n P: PatternProvider,\n{\n pub fn new(\n nodes: &[P::PatternNodeKey],\n leaves: Vec,\n vars: Vec,\n ) -> Self {\n let binds = (0..leaves.len()).map(|_| HashMap::new()).collect();\n MatchMatrix::with_bindings(nodes, leaves, vars, binds)\n }\n\n fn with_bindings(\n nodes: &[P::PatternNodeKey],\n leaves: Vec,\n vars: Vec,\n mut leaf_bindings: Vec>,\n ) -> Self {\n assert!(vars.len() * leaves.len() == nodes.len());\n assert!(leaf_bindings.len() == leaves.len());\n\n let data = if vars.len() == 0 {\n vec![]\n } else {\n nodes\n .chunks(vars.len())\n .enumerate()\n .flat_map(|(clause_idx, clause)| {\n clause\n .iter()\n .enumerate()\n .map(move |(variable_idx, pat)| MatchMatrixElement {\n variable_num: variable_idx,\n clause_num: clause_idx,\n node: *pat,\n })\n })\n .collect()\n };\n\n // Insert all bindings\n if nodes.len() > 0 {\n for (idx, chunk) in data.chunks(vars.len()).enumerate() {\n for (elem, var) in chunk.iter().zip(vars.iter()) {\n leaf_bindings[idx].insert(elem.node, *var);\n }\n }\n }\n\n MatchMatrix {\n data: data,\n variables: vars,\n clause_leaves: leaves,\n leaf_bindings: leaf_bindings,\n }\n }\n\n /// Selects which variable should be specialized on in this matrix.\n /// This will always select the variable which has the most consecutive\n /// wildcards from the top, as this will minimize the amount of\n /// comparisons we will have to perform.\n pub fn select_specialize_variable(&self, pattern: &P) -> usize {\n let mut sums = vec![(0, true); self.variables.len()];\n\n let clauses = self.data.chunks(self.variables.len());\n for clause in clauses {\n for variable_pattern in clause.iter() {\n if pattern.is_wildcard(pattern.get_kind(variable_pattern.node)) {\n sums[variable_pattern.variable_num].1 = false;\n } else {\n if sums[variable_pattern.variable_num].1 {\n sums[variable_pattern.variable_num].0 += 1;\n }\n }\n }\n }\n\n sums.iter()\n .enumerate()\n .max_by_key(|&(_, s)| s.0)\n .map(|(i, _)| i)\n .unwrap()\n }\n\n pub fn get_var(&self, var: usize) -> P::CfgVariable {\n self.variables[var]\n }\n\n /// Constructs a set of all node kinds in the given variable in the given pattern\n pub fn collect_specialization_types<'a>(\n &self,\n pattern: &'a P,\n variable: usize,\n ) -> HashSet {\n let mut types = HashSet::new();\n\n let clauses = self.data.chunks(self.variables.len());\n for clause in clauses {\n let variable_pattern = &clause[variable];\n types.insert(pattern.get_kind(variable_pattern.node));\n }\n\n types.remove(&pattern.get_wildcard());\n\n types\n }\n\n pub fn specialize(\n &self,\n ctx: &mut super::MatchCompileContext

,\n variable: usize,\n on: P::PatternNodeKind,\n ) -> (Vec, MatchMatrix

) {\n #[cfg(feature = \"debug_table_print\")]\n {\n trace!(\n target: TARGET,\n \"Specialize variable #{} on {:?}\",\n variable,\n on\n );\n trace!(target: TARGET, \"{}\", self.to_table(&ctx.pattern));\n trace!(target: TARGET, \"binds: {:#?}\", self.leaf_bindings);\n }\n\n // 1. Determine how we want to handle the different clauses\n #[derive(Debug, Copy, Clone, PartialEq, Eq)]\n enum ClauseMode {\n /// The clause is included in the kind we specialize on\n Expand,\n /// The clause is a wildcard, expand into wildcards\n Wildcard,\n /// Clause is not included\n Skip,\n }\n let clause_modes: Vec = self\n .data\n .chunks(self.variables.len())\n .map(|nodes| {\n let n = nodes[variable].node;\n if ctx.pattern.kind_includes(on, n) {\n ClauseMode::Expand\n } else if ctx.pattern.is_wildcard(ctx.pattern.get_kind(n)) {\n ClauseMode::Wildcard\n } else {\n ClauseMode::Skip\n }\n })\n .collect();\n\n // 2. Expand nodes\n let expanded = {\n let nodes: Vec<_> = clause_modes\n .iter()\n .cloned()\n .zip(self.data.chunks(self.variables.len()))\n .filter(|(mode, _)| *mode == ClauseMode::Expand)\n .map(|(_, nodes)| nodes[variable].node)\n .collect();\n let nodes_len = nodes.len();\n\n let res = ctx.pattern.expand_clause_nodes(nodes, on);\n\n assert!(res.clauses == nodes_len);\n assert!(res.nodes.len() == res.clauses * res.variables.len());\n\n res\n };\n\n let expanded_var_num = expanded.variables.len();\n\n // 3. Merge expanded with wildcard expansions and residuals\n let merged = {\n let mut out = Vec::new();\n\n // Because .chunks does not accept 0 as a chunk length,\n // we do this workaround\n let mut expanded_iter = if expanded.nodes.len() > 0 {\n Some(expanded.nodes.chunks(expanded_var_num))\n } else {\n None\n };\n\n let mut residual_iter = clause_modes\n .iter()\n .cloned()\n .zip(self.data.chunks(self.variables.len()))\n .filter(|(mode, _)| *mode != ClauseMode::Skip)\n .map(|(_, elems)| {\n elems\n .iter()\n .filter(|elem| elem.variable_num != variable)\n .map(|elem| elem.node)\n });\n\n for mode in clause_modes.iter() {\n // Append expanded\n match mode {\n ClauseMode::Expand => {\n if let Some(ref mut inner) = expanded_iter {\n let expanded_nodes = inner.next().unwrap();\n out.extend(expanded_nodes.iter().cloned());\n } else {\n assert!(expanded.nodes.len() == 0);\n }\n }\n ClauseMode::Wildcard => {\n for _ in 0..expanded_var_num {\n out.push(ctx.pattern.get_wildcard_node());\n }\n }\n ClauseMode::Skip => continue,\n }\n\n // Append residual\n let residuals = residual_iter.next().unwrap();\n out.extend(residuals);\n }\n\n if let Some(ref mut inner) = expanded_iter {\n assert!(inner.next().is_none());\n }\n assert!(residual_iter.next().is_none());\n\n out\n };\n\n let new_variables: Vec<_> = {\n let rest_variables = self\n .variables\n .iter()\n .enumerate()\n .filter(|&(var_num, _)| var_num != variable)\n .map(|(_, var)| *var);\n\n expanded\n .variables\n .iter()\n .map(|var| *var)\n .chain(rest_variables)\n .collect()\n };\n\n let new_clause_leaves: Vec<_> = clause_modes\n .iter()\n .cloned()\n .zip(self.clause_leaves.iter())\n .filter(|(mode, _)| *mode != ClauseMode::Skip)\n .map(|(_, clause)| *clause)\n .collect();\n\n let new_leaf_bindings: Vec<_> = clause_modes\n .iter()\n .zip(self.leaf_bindings.iter())\n .filter(|(mode, _)| **mode != ClauseMode::Skip)\n .map(|(_, binds)| binds.clone())\n .collect();\n\n let matrix =\n Self::with_bindings(&merged, new_clause_leaves, new_variables, new_leaf_bindings);\n\n (expanded.variables, matrix)\n }\n\n pub fn without_head<'a>(&'a self) -> MatchMatrix

{\n // TODO move to actual new instead of this\n // This just removes the top row of the table.\n // Since data is unrolled, remove the n first entries\n // where n is the number of variables\n // Then remove first clause leaf\n let mut new = self.clone();\n for _ in 0..(new.variables.len()) {\n new.data.remove(0);\n }\n new.clause_leaves.remove(0);\n for entry in new.data.iter_mut() {\n entry.clause_num -= 1;\n }\n new.leaf_bindings.remove(0);\n new\n }\n\n pub(crate) fn binds_for<'a>(\n &'a self,\n leaf: LeafId,\n ) -> Option<&'a HashMap> {\n self.clause_leaves\n .iter()\n .enumerate()\n .find(|(_, l)| **l == leaf)\n .map(|(idx, _)| &self.leaf_bindings[idx])\n }\n\n pub(crate) fn binds_for_head<'a>(&'a self) -> &'a HashMap {\n &self.leaf_bindings[0]\n }\n\n //pub(crate) fn iterate_clauses<'a>(&'a self) -> impl Iterator])> + 'a {\n // let iter = self.clause_leaves.iter().map(|l| *l)\n // .zip(chunks_len(&self.data, self.variables.len(), self.clause_leaves.len()));\n\n // Box::new(iter)\n //}\n\n pub fn default(\n &self,\n ctx: &mut super::MatchCompileContext

,\n variable: usize,\n ) -> (Vec, MatchMatrix

) {\n let wildcard = ctx.pattern.get_wildcard();\n self.specialize(ctx, variable, wildcard)\n }\n\n pub fn is_empty(&self) -> bool {\n self.clause_leaves.len() == 0\n }\n\n pub(crate) fn has_wildcard_head(&self, pattern: &P) -> Option {\n assert!(self.clause_leaves.len() > 0);\n if self.variables.len() == 0 {\n Some(self.clause_leaves[0])\n } else {\n let has_wildcard_head = self\n .data\n .chunks(self.variables.len())\n .next()\n .unwrap()\n .iter()\n .all(|p| pattern.is_wildcard(pattern.get_kind(p.node)));\n if has_wildcard_head {\n Some(self.clause_leaves[0])\n } else {\n None\n }\n }\n }\n\n #[cfg(feature = \"debug_table_print\")]\n pub fn to_table(&self, pat: &P) -> Table {\n use ::prettytable::Cell;\n\n let mut table = Table::new();\n\n {\n let head_row = table.add_empty_row();\n head_row.add_cell(Cell::new(&format!(\n \"{}*{}=={}\",\n self.variables.len(),\n self.clause_leaves.len(),\n self.data.len()\n )));\n for variable in self.variables.iter() {\n let var_str = format!(\"{:?}\", variable);\n head_row.add_cell(Cell::new(&var_str));\n }\n }\n\n for row_idx in 0..self.clause_leaves.len() {\n let t_row = table.add_empty_row();\n let leaf_id = format!(\"{:?}\", self.clause_leaves[row_idx]);\n t_row.add_cell(Cell::new(&leaf_id));\n\n let row_start = row_idx * self.variables.len();\n for col in &self.data[row_start..(row_start + self.variables.len())] {\n let node = pat.get_kind(col.node);\n let cell_fmt = format!(\"{:?}\", node);\n let cell = Cell::new(&cell_fmt);\n t_row.add_cell(cell);\n }\n }\n\n table\n }\n}\n" }, { "path": "util/libeir_util_pattern_compiler/src/pattern.rs", "content": "use std::fmt::Debug;\nuse std::hash::Hash;\n\n/// Length of `nodes` should ALWAYS be `variables.len() * clauses`\n#[derive(Debug)]\npub struct ExpandedClauseNodes {\n pub variables: Vec,\n pub clauses: usize,\n pub nodes: Vec,\n}\n\npub trait PatternProvider: Debug {\n /// A reference to a unique node in the pattern graph.\n /// Every `PatternNodeKey` should belong to ONE and ONLY one\n /// `PatternNodeKind`.\n type PatternNodeKey: Copy + Hash + Debug + PartialEq + Eq;\n\n /// The type of pattern node.\n type PatternNodeKind: Copy + Hash + Debug + PartialEq + Eq;\n\n /// A variable in the output CFG.\n /// The provider is responsible for creating these as specializations\n /// are performed by `expand_clause_nodes`.\n type CfgVariable: Copy + Hash + Debug + PartialEq + Eq;\n\n const WILDCARD: Self::PatternNodeKind;\n\n fn get_root(&self) -> ExpandedClauseNodes;\n\n /// Used to determine if the given `key` should be included in the\n /// specialization on `kind`.\n ///\n /// When passed a wildcard as kind, we are specializing on the default\n /// matrix. It should match wildcards ONLY.\n ///\n /// ## Invariants\n /// * Every `PatternNodeKey` should match on one and ONLY one\n /// `PatternNodeKind`.\n fn kind_includes(&self, kind: Self::PatternNodeKind, key: Self::PatternNodeKey) -> bool;\n\n /// After clauses have been selected for specialization, this will\n /// be called with the set of all nodes that should be specialized on.\n ///\n fn expand_clause_nodes(\n &mut self,\n clause_nodes: Vec,\n kind: Self::PatternNodeKind,\n ) -> ExpandedClauseNodes;\n\n fn get_wildcard_node(&self) -> Self::PatternNodeKey;\n\n /// Every `PatternNodeKey` should belong to one and only one\n /// `PatternNodeKind`.\n fn get_kind(&self, key: Self::PatternNodeKey) -> Self::PatternNodeKind;\n\n fn is_wildcard(&self, kind: Self::PatternNodeKind) -> bool {\n kind == Self::WILDCARD\n }\n fn get_wildcard(&self) -> Self::PatternNodeKind {\n Self::WILDCARD\n }\n}\n" }, { "path": "util/libeir_util_pattern_compiler/src/simple_pattern/mod.rs", "content": "#[cfg(test)]\nmod test;\n\nuse crate::{ExpandedClauseNodes, PatternProvider};\n\nuse petgraph::graph::NodeIndex;\nuse petgraph::{Direction, Graph};\n\n#[derive(Copy, Clone, Hash, PartialEq, Eq)]\npub struct CfgVar(usize);\n\nuse ::std::fmt;\nimpl fmt::Debug for CfgVar {\n fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {\n write!(fmt, \"${}\", self.0)\n }\n}\n\n#[derive(Copy, Clone, Hash, Debug, PartialEq, Eq)]\npub enum NodeKind {\n Tuple,\n ListCell,\n Terminal,\n RootValues,\n Wildcard,\n}\n\n#[derive(Debug, Clone)]\npub struct SimplePatternProvider {\n pattern: Graph,\n roots: Vec,\n root_var: CfgVar,\n curr_var: CfgVar,\n wildcard: NodeIndex,\n}\n\nimpl SimplePatternProvider {\n pub fn new() -> Self {\n let mut graph = Graph::new();\n let wildcard = graph.add_node(NodeKind::Wildcard);\n SimplePatternProvider {\n pattern: graph,\n roots: Vec::new(),\n root_var: CfgVar(0),\n curr_var: CfgVar(0),\n wildcard,\n }\n }\n\n pub fn add_child(&mut self, node: NodeIndex, kind: NodeKind) -> NodeIndex {\n let res = self.pattern.add_node(kind);\n self.pattern.add_edge(node, res, ());\n res\n }\n\n pub fn add_clause(&mut self, kind: NodeKind) -> NodeIndex {\n let res = self.pattern.add_node(kind);\n self.roots.push(res);\n res\n }\n}\n\nimpl PatternProvider for SimplePatternProvider {\n type PatternNodeKey = NodeIndex;\n type PatternNodeKind = NodeKind;\n type CfgVariable = CfgVar;\n\n const WILDCARD: NodeKind = NodeKind::Wildcard;\n\n fn get_root(&self) -> ExpandedClauseNodes {\n ExpandedClauseNodes {\n variables: vec![self.root_var],\n clauses: self.roots.len(),\n nodes: self.roots.clone(),\n }\n }\n\n fn kind_includes(&self, kind: Self::PatternNodeKind, key: Self::PatternNodeKey) -> bool {\n self.pattern[key] == kind\n }\n\n fn expand_clause_nodes(\n &mut self,\n clause_nodes: Vec,\n kind: Self::PatternNodeKind,\n ) -> ExpandedClauseNodes {\n if clause_nodes.len() == 0 {\n return ExpandedClauseNodes {\n clauses: 0,\n variables: vec![],\n nodes: vec![],\n };\n }\n\n let base_len = self\n .pattern\n .edges_directed(clause_nodes[0], Direction::Outgoing)\n .count();\n for node in &clause_nodes {\n assert!(\n self.pattern\n .edges_directed(clause_nodes[0], Direction::Outgoing)\n .count()\n == base_len\n );\n assert!(self.pattern[*node] == kind);\n }\n\n let mut curr_var = self.curr_var;\n let mut exp = ExpandedClauseNodes {\n clauses: clause_nodes.len(),\n variables: self\n .pattern\n .edges_directed(clause_nodes[0], Direction::Outgoing)\n .map(|_| {\n curr_var.0 += 1;\n curr_var\n })\n .collect(),\n nodes: vec![],\n };\n self.curr_var = curr_var;\n\n match kind {\n NodeKind::RootValues => {\n for node in &clause_nodes {\n for child in self.pattern.edges_directed(*node, Direction::Outgoing) {\n use ::petgraph::visit::EdgeRef;\n exp.nodes.push(child.target());\n }\n }\n }\n NodeKind::ListCell => {\n for node in &clause_nodes {\n for child in self.pattern.edges_directed(*node, Direction::Outgoing) {\n use ::petgraph::visit::EdgeRef;\n exp.nodes.push(child.target());\n }\n }\n }\n NodeKind::Wildcard => {}\n NodeKind::Terminal => {}\n typ => unimplemented!(\"{:?}\", typ),\n }\n\n println!(\"{:?}\", exp);\n exp\n }\n\n fn get_kind(&self, key: Self::PatternNodeKey) -> Self::PatternNodeKind {\n self.pattern[key]\n }\n\n fn get_wildcard_node(&self) -> Self::PatternNodeKey {\n self.wildcard\n }\n}\n" }, { "path": "util/libeir_util_pattern_compiler/src/simple_pattern/test.rs", "content": "use super::{NodeKind, SimplePatternProvider};\n\n#[test]\nfn list_merge_pattern() {\n // fn ([], _)\n // fn (_, [])\n // fn ([_, _], [_, _])\n\n let mut pattern = SimplePatternProvider::new();\n\n {\n let clause = pattern.add_clause(NodeKind::RootValues);\n pattern.add_child(clause, NodeKind::Wildcard);\n pattern.add_child(clause, NodeKind::Wildcard);\n }\n {\n let clause = pattern.add_clause(NodeKind::RootValues);\n pattern.add_child(clause, NodeKind::Terminal);\n pattern.add_child(clause, NodeKind::Wildcard);\n }\n {\n let clause = pattern.add_clause(NodeKind::RootValues);\n pattern.add_child(clause, NodeKind::Terminal);\n pattern.add_child(clause, NodeKind::Wildcard);\n }\n {\n let clause = pattern.add_clause(NodeKind::RootValues);\n pattern.add_child(clause, NodeKind::Wildcard);\n pattern.add_child(clause, NodeKind::Terminal);\n }\n {\n let clause = pattern.add_clause(NodeKind::RootValues);\n\n let list_cell_1 = pattern.add_child(clause, NodeKind::ListCell);\n pattern.add_child(list_cell_1, NodeKind::Wildcard);\n pattern.add_child(list_cell_1, NodeKind::Wildcard);\n\n let list_cell_2 = pattern.add_child(clause, NodeKind::ListCell);\n pattern.add_child(list_cell_2, NodeKind::Wildcard);\n pattern.add_child(list_cell_2, NodeKind::Wildcard);\n }\n\n let res = crate::to_decision_tree(&mut pattern);\n\n let mut file = ::std::fs::File::create(\"cfg.dot\").unwrap();\n res.to_dot(&mut file).unwrap();\n\n println!(\"{:?}\", res);\n //println!(\"{:#?}\", res.leaf_bindings);\n}\n" }, { "path": "util/libeir_util_prof/Cargo.toml", "content": "[package]\nname = \"libeir_util_prof\"\nversion = \"0.1.0\"\nauthors = [\"Hans Elias B. Josephsen \"]\nedition = \"2018\"\nlicense = \"MIT OR Apache-2.0\"\n\n# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html\n\n[dependencies]\nbumpalo = { git = \"https://github.com/hansihe/bumpalo\", features = [\"nightly\"] }\n" }, { "path": "util/libeir_util_prof/src/lib.rs", "content": "use std::time::Instant;\nuse std::thread::ThreadId;\n\npub struct Event {\n instant: Instant,\n thread: ThreadId,\n kind: EventKind,\n}\n\npub enum EventKind {\n Begin {\n },\n End {\n },\n}\n\npub struct Tracer {\n start: Instant,\n events: Vec,\n}\n" }, { "path": "util/meta_table/Cargo.toml", "content": "[package]\nname = \"meta_table\"\nversion = \"0.1.0\"\nauthors = [\"Hans Elias B. Josephsen \"]\nedition = \"2018\"\n\n# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html\n\n[dependencies]\nhashbrown = { git = \"https://github.com/rust-lang/hashbrown.git\", features = [\"raw\", \"nightly\"] }\n" }, { "path": "util/meta_table/src/lib.rs", "content": "use std::{any::TypeId, marker::PhantomData};\n\nuse hashbrown::HashMap;\n\n/// This implements `Send` and `Sync` unconditionally.\n/// (the trait itself doesn't need to have these bounds and the\n/// resources are already guaranteed to fulfill it).\nstruct Invariant(*mut T);\n\nunsafe impl Send for Invariant where T: ?Sized {}\n\nunsafe impl Sync for Invariant where T: ?Sized {}\n\npub trait MetaEntry: 'static {\n fn get_type_id(&self) -> TypeId;\n}\n#[macro_export]\nmacro_rules! impl_meta_entry {\n ($typ:ty) => {\n impl $crate::MetaEntry for $typ {\n fn get_type_id(&self) -> std::any::TypeId {\n std::any::TypeId::of::<$typ>()\n }\n }\n };\n}\n\n/// Helper trait for the `MetaTable`.\n/// This trait is required to be implemented for a trait to be compatible with\n/// the meta table.\n///\n/// # Memory safety\n///\n/// Not casting `self` but e.g. a field to the trait object can result in severe\n/// memory safety issues.\n///\n/// # Examples\n///\n/// ```\n/// use meta_table::{CastFrom, impl_cast_from};\n///\n/// trait Foo {\n/// fn foo1(&self);\n/// fn foo2(&mut self, x: i32) -> i32;\n/// }\n///\n/// impl_cast_from!(Foo);\n/// ```\npub unsafe trait CastFrom {\n /// Casts an immutable `T` reference to a trait object.\n fn cast(t: &T) -> &Self;\n\n /// Casts a mutable `T` reference to a trait object.\n fn cast_mut(t: &mut T) -> &mut Self;\n\n fn vtable() -> Fat;\n}\n#[macro_export]\nmacro_rules! impl_cast_from {\n ($typ:tt) => {\n unsafe impl $crate::CastFrom for dyn $typ\n where\n T: $typ + 'static,\n {\n fn cast(t: &T) -> &(dyn $typ + 'static) {\n t\n }\n\n fn cast_mut(t: &mut T) -> &mut (dyn $typ + 'static) {\n t\n }\n\n fn vtable() -> $crate::Fat {\n let from: *const T = std::ptr::null();\n let object_ptr: *const Self = from;\n\n unsafe { $crate::Fat::from_ptr(object_ptr) }\n }\n }\n };\n}\n\npub struct Fat(usize);\n\nimpl Fat {\n pub unsafe fn from_ptr(t: *const T) -> Self {\n use std::ptr::read;\n\n assert_unsized::();\n\n let fat_ptr = &t as *const *const T as *const usize;\n // Memory layout:\n // [object pointer, vtable pointer]\n // ^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^\n // 8 bytes | 8 bytes\n // (on 32-bit both have 4 bytes)\n let vtable = read::(fat_ptr.offset(1));\n\n Fat(vtable)\n }\n\n pub unsafe fn create_ptr(&self, ptr: *const ()) -> *const T {\n let fat_ptr: (*const (), usize) = (ptr, self.0);\n\n *(&fat_ptr as *const (*const (), usize) as *const *const T)\n }\n\n pub unsafe fn create_mut_ptr(&self, ptr: *mut ()) -> *mut T {\n let fat_ptr: (*mut (), usize) = (ptr, self.0);\n\n *(&fat_ptr as *const (*mut (), usize) as *const *mut T)\n }\n}\n\n/// The `MetaTable` which allows to store object-safe trait implementations for\n/// resources.\n///\n/// For example, you have a trait `Foo` that is implemented by several\n/// resources. You can register all the implementors using\n/// `MetaTable::register`. Later on, you can iterate over all resources that\n/// implement `Foo` without knowing their specific type.\n///\n/// # Examples\n///\n/// ```\n/// use meta_table::{MetaTable, impl_cast_from, impl_meta_entry};\n///\n/// trait Object {\n/// fn method1(&self) -> i32;\n///\n/// fn method2(&mut self, x: i32);\n/// }\n/// impl_cast_from!(Object);\n///\n/// struct ImplementorA(i32);\n/// impl_meta_entry!(ImplementorA);\n///\n/// impl Object for ImplementorA {\n/// fn method1(&self) -> i32 {\n/// self.0\n/// }\n///\n/// fn method2(&mut self, x: i32) {\n/// self.0 += x;\n/// }\n/// }\n///\n/// struct ImplementorB(i32);\n/// impl_meta_entry!(ImplementorB);\n///\n/// impl Object for ImplementorB {\n/// fn method1(&self) -> i32 {\n/// self.0\n/// }\n///\n/// fn method2(&mut self, x: i32) {\n/// self.0 *= x;\n/// }\n/// }\n///\n/// let mut table = MetaTable::::new();\n/// table.register::();\n/// table.register::();\n///\n/// assert!(table.get(&ImplementorA(12)).unwrap().method1() == 12);\n/// assert!(table.get(&ImplementorB(13)).unwrap().method1() == 13);\n/// ```\npub struct MetaTable {\n fat: Vec,\n indices: HashMap,\n tys: Vec,\n // `MetaTable` is invariant over `T`\n marker: PhantomData>,\n}\n\nimpl MetaTable {\n /// Creates a new `MetaTable`.\n pub fn new() -> Self {\n assert_unsized::();\n\n Default::default()\n }\n\n /// Registers a resource `R` that implements the trait `T`.\n pub fn register(&mut self)\n where\n R: MetaEntry,\n T: CastFrom + 'static,\n {\n use hashbrown::hash_map::Entry;\n\n let fat = T::vtable();\n let ty_id = std::any::TypeId::of::();\n\n // Important: ensure no entry exists twice!\n let len = self.indices.len();\n match self.indices.entry(ty_id) {\n Entry::Occupied(occ) => {\n let ind = *occ.get();\n\n self.fat[ind] = fat;\n }\n Entry::Vacant(vac) => {\n vac.insert(len);\n\n self.fat.push(fat);\n self.tys.push(ty_id);\n }\n }\n }\n\n /// Tries to convert `world` to a trait object of type `&T`.\n /// If `world` doesn't have an implementation for `T` (or it wasn't\n /// registered), this will return `None`.\n pub fn get<'a>(&self, res: &'a dyn MetaEntry) -> Option<&'a T> {\n unsafe {\n self.indices\n .get(&res.get_type_id())\n .map(move |&ind| &*self.fat[ind].create_ptr(res as *const _ as *const ()))\n }\n }\n\n /// Tries to convert `world` to a trait object of type `&mut T`.\n /// If `world` doesn't have an implementation for `T` (or it wasn't\n /// registered), this will return `None`.\n pub fn get_mut<'a>(&self, res: &'a mut dyn MetaEntry) -> Option<&'a mut T> {\n unsafe {\n self.indices\n .get(&res.get_type_id())\n .map(move |&ind| &mut *self.fat[ind].create_mut_ptr(res as *mut _ as *mut ()))\n }\n }\n}\n\nimpl Default for MetaTable\nwhere\n T: ?Sized,\n{\n fn default() -> Self {\n MetaTable {\n fat: Default::default(),\n indices: Default::default(),\n tys: Default::default(),\n marker: Default::default(),\n }\n }\n}\n\npub fn assert_unsized() {\n use std::mem::size_of;\n\n assert_eq!(size_of::<&T>(), 2 * size_of::());\n}\n\n#[cfg(test)]\nmod tests {\n use super::*;\n\n trait Object: MetaEntry {\n fn method1(&self) -> i32;\n\n fn method2(&mut self, x: i32);\n }\n\n impl_cast_from!(Object);\n\n struct ImplementorA(i32);\n\n impl_meta_entry!(ImplementorA);\n impl Object for ImplementorA {\n fn method1(&self) -> i32 {\n self.0\n }\n\n fn method2(&mut self, x: i32) {\n self.0 += x;\n }\n }\n\n struct ImplementorB(i32);\n\n impl_meta_entry!(ImplementorB);\n impl Object for ImplementorB {\n fn method1(&self) -> i32 {\n self.0\n }\n\n fn method2(&mut self, x: i32) {\n self.0 *= x;\n }\n }\n\n //#[test]\n //fn test_iter_all() {\n // let mut world = World::empty();\n\n // world.insert(ImplementorA(3));\n // world.insert(ImplementorB(1));\n\n // let mut table = MetaTable::::new();\n // table.register(&ImplementorA(125));\n // table.register(&ImplementorB(111_111));\n\n // {\n // let mut iter = table.iter(&world);\n // assert_eq!(iter.next().unwrap().method1(), 3);\n // assert_eq!(iter.next().unwrap().method1(), 1);\n // }\n\n // {\n // let mut iter_mut = table.iter_mut(&world);\n // let obj = iter_mut.next().unwrap();\n // obj.method2(3);\n // assert_eq!(obj.method1(), 6);\n // let obj = iter_mut.next().unwrap();\n // obj.method2(4);\n // assert_eq!(obj.method1(), 4);\n // }\n //}\n\n //#[test]\n //fn test_iter_all_after_removal() {\n // let mut world = World::empty();\n\n // world.insert(ImplementorA(3));\n // world.insert(ImplementorB(1));\n\n // let mut table = MetaTable::::new();\n // table.register(&ImplementorA(125));\n // table.register(&ImplementorB(111_111));\n\n // {\n // let mut iter = table.iter(&world);\n // assert_eq!(iter.next().unwrap().method1(), 3);\n // assert_eq!(iter.next().unwrap().method1(), 1);\n // }\n\n // world.remove::().unwrap();\n\n // {\n // let mut iter = table.iter(&world);\n // assert_eq!(iter.next().unwrap().method1(), 1);\n // }\n\n // world.remove::().unwrap();\n //}\n\n struct ImplementorC;\n\n impl_meta_entry!(ImplementorC);\n impl Object for ImplementorC {\n fn method1(&self) -> i32 {\n 33\n }\n\n fn method2(&mut self, _x: i32) {\n unimplemented!()\n }\n }\n\n struct ImplementorD;\n\n impl_meta_entry!(ImplementorD);\n impl Object for ImplementorD {\n fn method1(&self) -> i32 {\n 42\n }\n\n fn method2(&mut self, _x: i32) {\n unimplemented!()\n }\n }\n\n #[test]\n fn get() {\n let mut table = MetaTable::::new();\n table.register::();\n table.register::();\n\n let t1 = ImplementorC;\n let t1d: &dyn MetaEntry = &t1;\n\n let t2 = ImplementorD;\n let t2d: &dyn MetaEntry = &t2;\n\n assert_eq!(table.get(t1d).unwrap().method1(), 33);\n assert_eq!(table.get(t2d).unwrap().method1(), 42);\n }\n}\n" }, { "path": "util/scoped_cell/Cargo.toml", "content": "[package]\nname = \"scoped_cell\"\nversion = \"0.1.0\"\nauthors = [\"Hans Elias B. Josephsen \"]\nedition = \"2018\"\n\n# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html\n\n[dependencies]\n" }, { "path": "util/scoped_cell/src/lib.rs", "content": "use std::alloc::{alloc, dealloc, Layout};\nuse std::marker::PhantomData;\nuse std::ptr::NonNull;\n\n#[derive(Debug, Copy, Clone, PartialEq, Eq)]\npub struct BorrowMutError;\n\nstruct ScopedCellGuard<'a, T: ?Sized>(&'a ScopedCell);\nimpl<'a, T: ?Sized> Drop for ScopedCellGuard<'a, T> {\n fn drop(&mut self) {\n unsafe {\n let inner = self.0.inner_mut();\n debug_assert!(inner.active);\n inner.active = false;\n }\n }\n}\n\npub struct ScopedCell {\n ptr: NonNull>,\n //phantom: PhantomData>,\n}\n\nimpl ScopedCell {\n pub fn borrow_mut(&self, fun: F) -> R\n where\n F: FnOnce(&mut T) -> R,\n {\n unsafe {\n let inner_ptr;\n {\n let inner = self.inner_mut();\n if inner.active {\n panic!(\"ScopedCell already borrowed\");\n }\n if inner.inner.is_none() {\n panic!(\"Tried to borrow ScopedCell outside of creating scope\");\n }\n inner.active = true;\n inner_ptr = inner.inner.unwrap();\n }\n\n // This guard will take care of setting active to false when we\n // leave the inner scope.\n let _guard = ScopedCellGuard(self);\n\n fun(&mut *inner_ptr.as_ptr())\n }\n }\n\n pub fn try_borrow_mut(&self, fun: F) -> Result\n where\n F: FnOnce(&mut T) -> R,\n {\n unsafe {\n let inner_ptr;\n {\n let inner = self.inner_mut();\n if inner.active {\n return Err(BorrowMutError);\n }\n if inner.inner.is_none() {\n return Err(BorrowMutError);\n }\n inner.active = true;\n inner_ptr = inner.inner.unwrap();\n }\n\n // This guard will take care of setting active to false when we\n // leave the inner scope.\n let _guard = ScopedCellGuard(self);\n\n Ok(fun(&mut *inner_ptr.as_ptr()))\n }\n }\n\n /// # Safety\n /// This may only be called by internal functions.\n /// A reference to this may only be held while control flow is controlled by the scoped cell.\n /// Only one reference to inner may be obtained at the time.\n unsafe fn inner_mut(&self) -> &mut ScopedCellInner {\n &mut *(self.ptr.as_ptr() as *mut _)\n }\n}\n\nimpl Clone for ScopedCell {\n fn clone(&self) -> Self {\n unsafe {\n let inner = self.inner_mut();\n inner.references += 1;\n }\n ScopedCell {\n ptr: self.ptr,\n //phantom: PhantomData,\n }\n }\n}\nimpl Drop for ScopedCell {\n fn drop(&mut self) {\n unsafe {\n let is_zero;\n let active;\n {\n let inner = self.inner_mut();\n inner.references -= 1;\n is_zero = inner.references == 0;\n active = inner.active;\n }\n\n if is_zero {\n debug_assert!(!active);\n dealloc(\n self.ptr.as_ptr().cast(),\n Layout::for_value(self.ptr.as_ref()),\n )\n }\n }\n }\n}\n\npub struct ScopedCellInner {\n /// Number of `ScopedCell`s that exist at any given time.\n /// This is incremented on creation/cloning of a new `ScopedCell`, and\n /// decremented in the drop implementation.\n /// When this reaches 0, this struct is deallocated.\n references: usize,\n /// When this is true, a `&mut T` exists\n active: bool,\n /// Pointer to the thing this ScopedCell references.\n /// If this is `Some`, the creator guard of this scoped cell is still in\n /// scope.\n /// If this is `None`, the creator guard has been dropped and any future\n /// borrow attempts will fail.\n inner: Option>,\n}\n\n/// The guard must not be dropped while a borrow of a related cell is in\n/// progress. If this happens, the whole process will be aborted.\npub fn new<'a, T: ?Sized + 'a>(value: &'a mut T) -> ScopedCellCreatorGuard<'a, T> {\n // Because we are using the value reference in a `PhantomData`, the\n // reference will be concidered used, while not actually existing in a\n // usable form until this guard stuct is dropped.\n //\n // This should make things sound when we create a mutable reference from\n // the pointer we have stored in `ScopedCellInner`, because that can only\n // be done while the actual value reference is tied up in the PhantomData\n // of this guard.\n\n unsafe {\n let inner_layout = Layout::new::>();\n let inner_ptr_u8 = alloc(inner_layout);\n\n let inner_ptr = NonNull::new(inner_ptr_u8 as *mut _).unwrap();\n std::ptr::write(\n inner_ptr.as_ptr(),\n ScopedCellInner {\n references: 1,\n active: false,\n inner: Some(NonNull::new(value as *mut _).unwrap()),\n },\n );\n\n let cell = ScopedCell {\n ptr: inner_ptr,\n //phantom: PhantomData,\n };\n\n ScopedCellCreatorGuard {\n cell,\n life: PhantomData,\n }\n }\n}\n\npub struct ScopedCellCreatorGuard<'a, T: ?Sized> {\n cell: ScopedCell,\n life: PhantomData<&'a mut T>,\n}\nimpl<'a, T: ?Sized> Drop for ScopedCellCreatorGuard<'a, T> {\n fn drop(&mut self) {\n unsafe {\n let inner = self.cell.inner_mut();\n if inner.active {\n println!(\n \"FATAL: ScopedCell borrow active while ScopedCellCreatorGuard was dropped\"\n );\n std::process::abort();\n }\n inner.inner = None;\n }\n }\n}\nimpl<'a, T: ?Sized> ScopedCellCreatorGuard<'a, T> {\n pub fn clone_cell(&self) -> ScopedCell {\n self.cell.clone()\n }\n}\n\npub fn scoped_cell(value: &mut T, fun: F) -> R\nwhere\n F: FnOnce(ScopedCell) -> R,\n{\n let guard = new(value);\n\n let cell = guard.clone_cell();\n fun(cell)\n}\n\n#[cfg(test)]\nmod tests {\n use super::{new, scoped_cell};\n\n #[test]\n fn creation() {\n let mut a: u32 = 0;\n scoped_cell(&mut a, |_ac| {});\n }\n\n #[test]\n fn basic_usage() {\n let mut a: u32 = 0;\n\n fn inner(a: &mut u32) {\n scoped_cell(a, |ac| {\n let ac2 = ac.clone();\n\n ac.borrow_mut(|v| {\n *v += 1;\n });\n\n ac2.borrow_mut(|v| {\n *v += 1;\n });\n });\n }\n\n inner(&mut a);\n\n assert!(a == 2);\n }\n\n //#[test]\n //fn miri_fail() {\n // use std::marker::PhantomData;\n\n // struct Guard<'a>(PhantomData<&'a u8>);\n // fn new<'a>(_val: &'a mut u8) -> Guard<'a> {\n // Guard(PhantomData)\n // }\n\n // let mut a = 0u8;\n // let a_ptr = &mut a as *mut _;\n\n // // Should be sound:\n // {\n // let guard = new(&mut a);\n\n // // Compiler is aware that `a` is borrowed mutably at this point, but\n // // no actual reference exists. Therefore there will only be one active\n // // mutable reference when we create one from the pointer.\n\n // let inner_ref = unsafe { &mut *a_ptr };\n // *inner_ref += 1u8;\n // std::mem::drop(inner_ref);\n\n // std::mem::drop(guard);\n // }\n //}\n\n #[test]\n fn raw_usage() {\n let mut a: u32 = 0;\n let aco;\n {\n let sc = new(&mut a);\n let ac1 = sc.clone_cell();\n let ac2 = sc.clone_cell();\n aco = ac2.clone();\n ac1.borrow_mut(|_i| {\n assert!(ac2.try_borrow_mut(|_i| ()).is_err());\n });\n }\n assert!(aco.try_borrow_mut(|_i| ()).is_err());\n }\n\n #[test]\n fn double_borrow_fails() {\n let mut a: u32 = 0;\n\n scoped_cell(&mut a, |ac| {\n let ac2 = ac.clone();\n ac.borrow_mut(|_i| {\n assert!(ac2.try_borrow_mut(|_i| ()).is_err());\n });\n });\n }\n}\n" } ]