From 3783937cb51eeb80f9f7e2c0369fd193ab56ff88 Mon Sep 17 00:00:00 2001 From: rsv-code Date: Wed, 29 Mar 2017 21:12:49 -0700 Subject: [PATCH] Initial code commit. --- .gitignore | 56 +- README.md | 30 + cali.lang.base/.classpath | 7 + cali.lang.base/.project | 17 + cali.lang.base/LICENSE | 202 + cali.lang.base/build-cup.xml | 23 + cali.lang.base/build.xml | 94 + cali.lang.base/docs/img/logo.png | Bin 0 -> 5943 bytes .../lib-depends/java-cup-11b-runtime.jar | Bin 0 -> 20368 bytes .../lib-depends/java-cup.LICENSE.txt | 9 + cali.lang.base/lib/JFlex.jar | Bin 0 -> 144582 bytes cali.lang.base/lib/java-cup-11b.jar | Bin 0 -> 105472 bytes cali.lang.base/src/com/cali/CallStack.java | 111 + cali.lang.base/src/com/cali/Engine.java | 478 ++ cali.lang.base/src/com/cali/Environment.java | 175 + cali.lang.base/src/com/cali/Lexer.java | 1136 ++++ cali.lang.base/src/com/cali/Main.java | 62 + cali.lang.base/src/com/cali/Scanner.jflex | 236 + cali.lang.base/src/com/cali/Universe.java | 116 + cali.lang.base/src/com/cali/Util.java | 98 + .../src/com/cali/ast/AccessType.java | 23 + cali.lang.base/src/com/cali/ast/astBool.java | 76 + cali.lang.base/src/com/cali/ast/astBreak.java | 45 + .../src/com/cali/ast/astCallback.java | 67 + cali.lang.base/src/com/cali/ast/astClass.java | 451 ++ .../src/com/cali/ast/astConditionBlock.java | 85 + .../src/com/cali/ast/astDouble.java | 66 + .../src/com/cali/ast/astEtcetera.java | 45 + .../src/com/cali/ast/astExpression.java | 963 ++++ cali.lang.base/src/com/cali/ast/astFor.java | 213 + .../src/com/cali/ast/astFunctCall.java | 135 + .../src/com/cali/ast/astFunctDef.java | 368 ++ .../src/com/cali/ast/astFunctDefArgsList.java | 81 + .../src/com/cali/ast/astIfElse.java | 130 + .../src/com/cali/ast/astInclude.java | 79 + cali.lang.base/src/com/cali/ast/astInt.java | 66 + cali.lang.base/src/com/cali/ast/astList.java | 76 + cali.lang.base/src/com/cali/ast/astMap.java | 102 + .../src/com/cali/ast/astNewInst.java | 105 + cali.lang.base/src/com/cali/ast/astNode.java | 217 + .../src/com/cali/ast/astNodeInt.java | 37 + .../src/com/cali/ast/astNodeType.java | 49 + cali.lang.base/src/com/cali/ast/astNull.java | 45 + cali.lang.base/src/com/cali/ast/astObj.java | 270 + .../src/com/cali/ast/astReturn.java | 61 + .../src/com/cali/ast/astStatementList.java | 74 + .../src/com/cali/ast/astString.java | 67 + .../src/com/cali/ast/astSwitch.java | 124 + cali.lang.base/src/com/cali/ast/astThrow.java | 53 + .../src/com/cali/ast/astTryCatch.java | 141 + cali.lang.base/src/com/cali/ast/astVar.java | 67 + cali.lang.base/src/com/cali/ast/astWhile.java | 97 + .../src/com/cali/ast/caliException.java | 46 + cali.lang.base/src/com/cali/ast/expType.java | 46 + cali.lang.base/src/com/cali/cali.cup | 1612 ++++++ cali.lang.base/src/com/cali/parser.java | 4860 +++++++++++++++++ .../src/com/cali/stdlib/CBuffer.java | 1044 ++++ .../src/com/cali/stdlib/CClass.java | 111 + cali.lang.base/src/com/cali/stdlib/CDate.java | 133 + cali.lang.base/src/com/cali/stdlib/CLang.java | 35 + cali.lang.base/src/com/cali/stdlib/CMath.java | 196 + .../src/com/cali/stdlib/CReflect.java | 137 + cali.lang.base/src/com/cali/stdlib/CSys.java | 197 + cali.lang.base/src/com/cali/stdlib/Lang.java | 580 ++ cali.lang.base/src/com/cali/stdlib/SBool.java | 29 + .../src/com/cali/stdlib/SDouble.java | 71 + cali.lang.base/src/com/cali/stdlib/SInt.java | 46 + .../src/com/cali/stdlib/console.java | 84 + cali.lang.base/src/com/cali/sym.java | 80 + .../src/com/cali/types/CaliBool.java | 99 + .../src/com/cali/types/CaliBreak.java | 37 + .../src/com/cali/types/CaliCallback.java | 113 + .../src/com/cali/types/CaliDouble.java | 110 + .../src/com/cali/types/CaliException.java | 201 + .../src/com/cali/types/CaliInt.java | 142 + .../src/com/cali/types/CaliList.java | 281 + .../com/cali/types/CaliListComparator.java | 120 + .../src/com/cali/types/CaliMap.java | 181 + .../src/com/cali/types/CaliNull.java | 54 + .../src/com/cali/types/CaliObject.java | 122 + .../src/com/cali/types/CaliRef.java | 122 + .../src/com/cali/types/CaliReturn.java | 54 + .../src/com/cali/types/CaliString.java | 189 + .../src/com/cali/types/CaliType.java | 263 + .../src/com/cali/types/CaliTypeInt.java | 24 + .../src/com/cali/types/Members.java | 58 + cali.lang.base/src/com/cali/types/cType.java | 34 + cali.lang.base/tests/interpreter.ca | 944 ++++ 88 files changed, 19774 insertions(+), 9 deletions(-) create mode 100644 README.md create mode 100644 cali.lang.base/.classpath create mode 100644 cali.lang.base/.project create mode 100644 cali.lang.base/LICENSE create mode 100644 cali.lang.base/build-cup.xml create mode 100644 cali.lang.base/build.xml create mode 100644 cali.lang.base/docs/img/logo.png create mode 100644 cali.lang.base/lib-depends/java-cup-11b-runtime.jar create mode 100644 cali.lang.base/lib-depends/java-cup.LICENSE.txt create mode 100644 cali.lang.base/lib/JFlex.jar create mode 100644 cali.lang.base/lib/java-cup-11b.jar create mode 100644 cali.lang.base/src/com/cali/CallStack.java create mode 100644 cali.lang.base/src/com/cali/Engine.java create mode 100644 cali.lang.base/src/com/cali/Environment.java create mode 100644 cali.lang.base/src/com/cali/Lexer.java create mode 100644 cali.lang.base/src/com/cali/Main.java create mode 100644 cali.lang.base/src/com/cali/Scanner.jflex create mode 100644 cali.lang.base/src/com/cali/Universe.java create mode 100644 cali.lang.base/src/com/cali/Util.java create mode 100644 cali.lang.base/src/com/cali/ast/AccessType.java create mode 100644 cali.lang.base/src/com/cali/ast/astBool.java create mode 100644 cali.lang.base/src/com/cali/ast/astBreak.java create mode 100644 cali.lang.base/src/com/cali/ast/astCallback.java create mode 100644 cali.lang.base/src/com/cali/ast/astClass.java create mode 100644 cali.lang.base/src/com/cali/ast/astConditionBlock.java create mode 100644 cali.lang.base/src/com/cali/ast/astDouble.java create mode 100644 cali.lang.base/src/com/cali/ast/astEtcetera.java create mode 100644 cali.lang.base/src/com/cali/ast/astExpression.java create mode 100644 cali.lang.base/src/com/cali/ast/astFor.java create mode 100644 cali.lang.base/src/com/cali/ast/astFunctCall.java create mode 100644 cali.lang.base/src/com/cali/ast/astFunctDef.java create mode 100644 cali.lang.base/src/com/cali/ast/astFunctDefArgsList.java create mode 100644 cali.lang.base/src/com/cali/ast/astIfElse.java create mode 100644 cali.lang.base/src/com/cali/ast/astInclude.java create mode 100644 cali.lang.base/src/com/cali/ast/astInt.java create mode 100644 cali.lang.base/src/com/cali/ast/astList.java create mode 100644 cali.lang.base/src/com/cali/ast/astMap.java create mode 100644 cali.lang.base/src/com/cali/ast/astNewInst.java create mode 100644 cali.lang.base/src/com/cali/ast/astNode.java create mode 100644 cali.lang.base/src/com/cali/ast/astNodeInt.java create mode 100644 cali.lang.base/src/com/cali/ast/astNodeType.java create mode 100644 cali.lang.base/src/com/cali/ast/astNull.java create mode 100644 cali.lang.base/src/com/cali/ast/astObj.java create mode 100644 cali.lang.base/src/com/cali/ast/astReturn.java create mode 100644 cali.lang.base/src/com/cali/ast/astStatementList.java create mode 100644 cali.lang.base/src/com/cali/ast/astString.java create mode 100644 cali.lang.base/src/com/cali/ast/astSwitch.java create mode 100644 cali.lang.base/src/com/cali/ast/astThrow.java create mode 100644 cali.lang.base/src/com/cali/ast/astTryCatch.java create mode 100644 cali.lang.base/src/com/cali/ast/astVar.java create mode 100644 cali.lang.base/src/com/cali/ast/astWhile.java create mode 100644 cali.lang.base/src/com/cali/ast/caliException.java create mode 100644 cali.lang.base/src/com/cali/ast/expType.java create mode 100644 cali.lang.base/src/com/cali/cali.cup create mode 100644 cali.lang.base/src/com/cali/parser.java create mode 100644 cali.lang.base/src/com/cali/stdlib/CBuffer.java create mode 100644 cali.lang.base/src/com/cali/stdlib/CClass.java create mode 100644 cali.lang.base/src/com/cali/stdlib/CDate.java create mode 100644 cali.lang.base/src/com/cali/stdlib/CLang.java create mode 100644 cali.lang.base/src/com/cali/stdlib/CMath.java create mode 100644 cali.lang.base/src/com/cali/stdlib/CReflect.java create mode 100644 cali.lang.base/src/com/cali/stdlib/CSys.java create mode 100644 cali.lang.base/src/com/cali/stdlib/Lang.java create mode 100644 cali.lang.base/src/com/cali/stdlib/SBool.java create mode 100644 cali.lang.base/src/com/cali/stdlib/SDouble.java create mode 100644 cali.lang.base/src/com/cali/stdlib/SInt.java create mode 100644 cali.lang.base/src/com/cali/stdlib/console.java create mode 100644 cali.lang.base/src/com/cali/sym.java create mode 100644 cali.lang.base/src/com/cali/types/CaliBool.java create mode 100644 cali.lang.base/src/com/cali/types/CaliBreak.java create mode 100644 cali.lang.base/src/com/cali/types/CaliCallback.java create mode 100644 cali.lang.base/src/com/cali/types/CaliDouble.java create mode 100644 cali.lang.base/src/com/cali/types/CaliException.java create mode 100644 cali.lang.base/src/com/cali/types/CaliInt.java create mode 100644 cali.lang.base/src/com/cali/types/CaliList.java create mode 100644 cali.lang.base/src/com/cali/types/CaliListComparator.java create mode 100644 cali.lang.base/src/com/cali/types/CaliMap.java create mode 100644 cali.lang.base/src/com/cali/types/CaliNull.java create mode 100644 cali.lang.base/src/com/cali/types/CaliObject.java create mode 100644 cali.lang.base/src/com/cali/types/CaliRef.java create mode 100644 cali.lang.base/src/com/cali/types/CaliReturn.java create mode 100644 cali.lang.base/src/com/cali/types/CaliString.java create mode 100644 cali.lang.base/src/com/cali/types/CaliType.java create mode 100644 cali.lang.base/src/com/cali/types/CaliTypeInt.java create mode 100644 cali.lang.base/src/com/cali/types/Members.java create mode 100644 cali.lang.base/src/com/cali/types/cType.java create mode 100644 cali.lang.base/tests/interpreter.ca diff --git a/.gitignore b/.gitignore index 32858aa..ce1c12c 100644 --- a/.gitignore +++ b/.gitignore @@ -1,12 +1,50 @@ -*.class -# Mobile Tools for Java (J2ME) -.mtj.tmp/ +.metadata +bin/ +tmp/ +*.tmp +*.bak +*.swp +*~.nib +local.properties +.settings/ +.loadpath +.recommenders -# Package Files # -*.jar -*.war -*.ear +# External tool builders +.externalToolBuilders/ -# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml -hs_err_pid* +# Locally stored "Eclipse launch configurations" +*.launch + +# PyDev specific (Python IDE for Eclipse) +*.pydevproject + +# CDT-specific (C/C++ Development Tooling) +.cproject + +# Java annotation processor (APT) +.factorypath + +# PDT-specific (PHP Development Tools) +.buildpath + +# sbteclipse plugin +.target + +# Tern plugin +.tern-project + +# TeXlipse plugin +.texlipse + +# STS (Spring Tool Suite) +.springBeans + +# Code Recommenders +.recommenders/ + +# Scala IDE specific (Scala & Java development for Eclipse) +.cache-main +.scala_dependencies +.worksheet diff --git a/README.md b/README.md new file mode 100644 index 0000000..9187dad --- /dev/null +++ b/README.md @@ -0,0 +1,30 @@ +![alt tag](docs/img/logo.png) + +This is a base interpreter implementation of the Cali language. You can run the interpreter from the command line, but this package was built to be embedded. + +## Building +Requires ANT and a recent JDK. (1.6 or newer) + +``` +shell> ant +``` + +That's it. In the dist directory, you should now have a .jar and a couple license files. + +You can run the tests from the dist directory: +``` +java -jar cali-0.8a.jar tests/interpreter.ca +``` + + +## Embedding +TODO + +## License +Cali is licensed under the Apache 2.0 license. See accompanying LICENSE file for details. Much thanks to the authors of the [CUP Parser Generator](http://www2.cs.tum.edu/projects/cup/install.php) and good people at Georgia Tech. See the java-cup.LICENSE.txt file for open source license details. + +## TODO: +Probably quite a bit. Here's the current list. +* Test/Fix java exception printing. +* Implement security model. +* Implement/test concurrency. diff --git a/cali.lang.base/.classpath b/cali.lang.base/.classpath new file mode 100644 index 0000000..79d3daa --- /dev/null +++ b/cali.lang.base/.classpath @@ -0,0 +1,7 @@ + + + + + + + diff --git a/cali.lang.base/.project b/cali.lang.base/.project new file mode 100644 index 0000000..6e29a70 --- /dev/null +++ b/cali.lang.base/.project @@ -0,0 +1,17 @@ + + + cali.lang.base + + + + + + org.eclipse.jdt.core.javabuilder + + + + + + org.eclipse.jdt.core.javanature + + diff --git a/cali.lang.base/LICENSE b/cali.lang.base/LICENSE new file mode 100644 index 0000000..e06d208 --- /dev/null +++ b/cali.lang.base/LICENSE @@ -0,0 +1,202 @@ +Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "{}" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright {yyyy} {name of copyright owner} + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + diff --git a/cali.lang.base/build-cup.xml b/cali.lang.base/build-cup.xml new file mode 100644 index 0000000..16d737b --- /dev/null +++ b/cali.lang.base/build-cup.xml @@ -0,0 +1,23 @@ + + + Build file for parser CUP. + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/cali.lang.base/build.xml b/cali.lang.base/build.xml new file mode 100644 index 0000000..7b39a7a --- /dev/null +++ b/cali.lang.base/build.xml @@ -0,0 +1,94 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Main target + + + \ No newline at end of file diff --git a/cali.lang.base/docs/img/logo.png b/cali.lang.base/docs/img/logo.png new file mode 100644 index 0000000000000000000000000000000000000000..b74a414a6f6d673c15206885de13f2e9e9a93593 GIT binary patch literal 5943 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 Z{69EaPXG{=uGIhl002ovPDHLkV1fb~Dv1C9 literal 0 HcmV?d00001 diff --git a/cali.lang.base/lib-depends/java-cup-11b-runtime.jar b/cali.lang.base/lib-depends/java-cup-11b-runtime.jar new file mode 100644 index 0000000000000000000000000000000000000000..8150475861ca8a83c2d8a4eca83ac101360247d8 GIT binary patch literal 20368 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 R#>FKHyvV?>MY{>>+uw)G#;yPW literal 0 HcmV?d00001 diff --git a/cali.lang.base/lib-depends/java-cup.LICENSE.txt b/cali.lang.base/lib-depends/java-cup.LICENSE.txt new file mode 100644 index 0000000..e316927 --- /dev/null +++ b/cali.lang.base/lib-depends/java-cup.LICENSE.txt @@ -0,0 +1,9 @@ +CUP Parser Generator Copyright Notice, License, and Disclaimer +Copyright 1996-1999 by Scott Hudson, Frank Flannery, C. Scott Ananian + +Permission to use, copy, modify, and distribute this software and its documentation for any purpose and without fee is hereby granted, provided that the above copyright notice appear in all copies and that both the copyright notice and this permission notice and warranty disclaimer appear in supporting documentation, and that the names of the authors or their employers not be used in advertising or publicity pertaining to distribution of the software without specific, written prior permission. + +The authors and their employers disclaim all warranties with regard to this software, including all implied warranties of merchantability and fitness. In no event shall the authors or their employers be liable for any special, indirect or consequential damages or any damages whatsoever resulting from loss of use, data or profits, whether in an action of contract, negligence or other tortious action, arising out of or in connection with the use or performance of this software. +This is an open source license. It is also GPL-Compatible (see entry for "Standard ML of New Jersey"). The portions of CUP output which are hard-coded into the CUP source code are (naturally) covered by this same license, as is the CUP runtime code linked with the generated parser. + +Java is a trademark of Sun Microsystems, Inc. References to the Java programming language in relation to JLex are not meant to imply that Sun endorses this product. \ No newline at end of file diff --git a/cali.lang.base/lib/JFlex.jar b/cali.lang.base/lib/JFlex.jar new file mode 100644 index 0000000000000000000000000000000000000000..c3cd34a483550479d4f7004a4df7009254e0d1af GIT binary patch literal 144582 zcmbTe19WEFvNqhEq+=T$+qP}nw(X>2+qP|+9XsjRww*t{_qhlExMzRo+|)?DHEPuu z?;5M-tU2dX&w6FV0fE53{Qf&F)1~^u_?rUz{FD?_;H4Cm5~7y*3`6_^`YHeaFvNcj zljM~W6%v$Jppq22ksKS95T~S?h7zYFn;4s{lcSlV-@KL_8=G~U5T&4Ml)JPW6|I;8 z46$KFDIiMBFFa&ZR3l~CPxz9MdWdFc`}K>AI0$I{&;}C!=T``P{{Oy-|NUNpKd*`j zSs1$faijlx%x~|XF~*Lje-Q`$_c&cE2M1ky^S_Aw{fx|XopiPJ9c}(14DO%9>>RBe zOf3!n2>SQr*x62x%uiSu1b zp;33aS{``P?^;-ILRfbUHu+K?I7M0&&2u=Zf>~M~WZ_WTwas|a+;Q?C{d7k)h{C=GH9ZA69p~Y{HI}o8J$46@p z4JF1)BH1+_mDH3ln$H?=?(1GRt3R$r<&C}H-nW_}v^zK0J=R>BQElGB@#+^}+(1Ag zE*s+kz*@T*7ml@$u}`sG(JYJ?gF>g$F`ws1cAh~ZE+Vx$48Ff-51YHY7gsrN_N{Mu zxoWi*qdk>>wBo5PC@M14y0dS*w?8y>aC+t~N%_l!X(Qe*&d&`fx!m}bg%rGA2eBPUL+*^3?ik8dUW=( zJ@!;dhUVpXH#7Bv0ck$7XS!_84htg;y%s47SEkRgL}CZqciJZ=$DHB*j`}5haqhIi z7XbYiEyqkBhn_+kP(^`@syCC=VBLL2Jp`1<&@2l3!+7ogFm#B5`*@A&QqxE z?x}G{pD~DAl{T~Q%JMJ8&Xfh}I1L0J94*S1r$AvIx^!j9Ojm?t&e&Sj)W`3*0WQCO2xPb$Cu(h2oY49#jvJ zx6tu*GaYlxGOZ_fD1kyjFX0Ez^A9Rdz+9x?ptgfq$chkvYot$^g8}W>Nbc-niHVv5vv`RX{#5*JhV z%-T52k|5MtvMVU1*;-2DgrSb}Nu{4dMXhERt1#!etjyxs(N7i%pBqGxXYrKP%|5ne z<5pJ)qSUZC(fZ?)l^Wj`Vf3>;Xq2>XvSnDZWs7HJ$}Bx(hMQ=Y(O%H5YYPiIA9IIM zIB{9|?EH5@e;26Nt-8k*D6o~TRNrxw^C@uZg+rb=bhlB_5{bGm@3w}l1q zpwisb;JFfcrtb88wZ(W*%J&?T%O?NsuydlZGV%Ouh;29VfC1+E;RIDJFmk&4P{+d1 zLf^vpROi&-RPR*x)bP6j#{f$|%a}{*Ki>htA=+4Kg}wNN<+A)bhYwVqV=gok6Fk+ha)VSz-vTEv)w zUdtJ~Oxh=Tv4*%^_+aIB@lT3`S+M1(BW=CyQvs~qu73vo zvw9P_ShuQGAqW%v3+3Mq>Iip?Hz!yeCWDegB{ppYWR35FQL|#vI$rpxG?`d}dRQSR zbZwyh>`~MEHopTO(ENukWhNIN3FKh|pBdy~qfbR*`A>=hW!P?Ob5y#+;m~-u_41ZH zzL_Tk;vY)RL-}nwQ0grvV!;XX;+)M%g38L=MJCyY0nik91~MN_gg)9xCY9F|xFE&u zQqtEN-Xm@^4QPYlk*J3mtW)&2Yh*L>xEm8{@+7OQlR&e2#}^ajv{`598#~KC3DuHq z&xEDX0aKlQ+OMnLPjd*0-D=6UPfE>crZz6IL!%EdS3Xz@mo4D%4+D-v@Di~{eqb|8 zA^&--#(0zrp;#iD&SwPZUkpTXFB#O?EF6#UOWNKcP;C5v7!q$z(~h;_sK%2l?t{PR zCo*mC!|ROGId@Lcj3-@KAAx(AK|6Ubp?s}jJ^VH?fHrV`yGDANKsyC5DSfTsJi<2B zfj00Sk$<}stwJLTmrVYq#+jH_mMrw^B7PhHD5*gqTBw9Yx@BVvk5rL}Si38m#GYSZ<(rh>Dfg-DX*imE05 zbV!%{wq=D-cZvfuk)z>uVn86@`h*MXACd}gbv04YnUV2 z73c4cs7sFAo8Sq2wy48Dj55v=cIDUYHv5`p* z?fE-|nAArui(Pu_-)xoNLS37-$@et{F7Owm>LrxQy+6A1%4VwO;{HNgg z#6c-z#^HZa{6i&pe|Sw!u3kK)yl`?`c2URe0xQ^ zbA%WA8^g2d?d)OEv~*sU5cj`0%AVD^6gJo;u`OI>9@RK^H>Cwj1N*!aK!m$1eKo(e zEnmZREB+|^qWrZIK;v68xDC=K**`m;z2B{~&&A5rsozmqkL=G_YkRy zV5M-=`B(yMz_$>4N&V$P|HV;~8-vYlu|xb3W%)WD)j%5(Au13TOav#Xrw@-22TBYl zg_kbC5@G|tMbIni|1XYwvz<;K;#VlIFSp=JNH*k~O5GJd)W0?XSbduVFGi9f&sO58 z_@VZ-A@_Y&-h8+35`*iu^Vf>y0_}zK#|IULjl}uR%i{YNj=3(OWonv3b;#$&!;0IJ$@KS@@Ccv( zP)HfY#=VO_mKWyC5d)IcDm+SlahNhdT?;BdOe8ifuUEilON}o>uT2DcKKn(ut2HU9 zE;6Tk@2WM3Zd?w!dDPvX=Jnq}RdH%5FFG_Al-*7Bp=eWR#Rp9)S1vMVm~lS&r&uX@ z>iW$YB@AV}RT24}ukveI)Rrw1NxDZp&v@8!2DCmjwJWwij+(Kjau<_GcK~uN*Eh_3 zW!#Mu_Gd76FRPc;KP0ERx7M0-&~UX=Mx1VcvTeX~;(Si2z*}C#F1K`9U07Frno{Q) zSZzFt*$fn(jPS(3u5DEI>@Q`8*3@$ETvj?eGPAtOv9jIkn1&OaOTaQUW1AHBnk^)5 z*XS(gTC$+xVmiZSBgA$X87cuB9JPC}`AC=)+U;8%|9UW4W>%5sx9IlL$->Ox(C{b{ z)9&Qp^?G@u`lO-t9nrmC3s(TM>ZRW+@_tyj@c4xHP7xnF?7DO~D7U@Q)T5+D<7@IidQMr_zi1VGd1yT*DHCvd>NR9g%UonoE6X4ekDmU z1_dMfyig8hNR69X(RLiEB!6v%Hr%L*;3RU{OGscD( z@I+JoUPg1Uu6rPMN=4^PPv4CDQudGit&G%>jEPcq?ILML^M_&$dJ%WD=X{fL3wa&} zvK%P3z}N|)gUDd}0*!T&wY!L8%?(cq(%Tc?@fo+h#$x$%&<;E2KJ{$d3d@LNc3I@x zz(+yR+Y~t;Izdf7R5I%y+?FEJO-lQ&S4MYlk_j)$W#``F?V8IMMKVxTMNuDZCeXog zL*B6C7nvf#l)TeRwI`V-PihuP=Y#_0;^d1fsAmrXLyLTiGriZXfG_^YN7nvIPl;{Z zWXlQ3OBDqD^kQo5*{kw5hg7u--&rZw;Vw#BGLSDq9%Sh*Qyk@9;hB-H${HvpYw)Zs zHI*znl95-ykrek8?f?gp86DSBTPyP`5l|M^hr8tLxB7VOwJo|-RvLGDIcw;t%*2b@ zLW@#oj?TADH5KlpV^`+h*!z*!r(fcgA8l59MnKGry56yWBW0a3tA*(BU%uQE{fU(Q z@7NN?-_fn#D43+Ksg;nOuB9OX!=Dh7r|gOtJ}v6|j8YM1+rrJSySXs6Y0~WsyigSx zBS+pVu8ct@!&IM?xjucc(Cq-2P5uyXJ=+I88=Rk6+#9B`4^fNE1~nm!D1gb7I6>84=W{HQdG9!wVHH~+dnI%Pv^P#II|xx6BEhgRNt(@S6L}#)m1; zH1qgIEFW0i(^L*w;W>>hkX6=B@5uMGK%sq85PmBGO#eT|1+DK(<@SbJg~rzmg{r+4=c^XA&EnLs#SG$GsY zA8@|RT81YYMo(c95QbkcK?6lHn+1S^MiyB>zwrf)+Fp|QlESEiQaKk+uL;=n@f<4c z*nMr105WgO9gixrDy9PMSWbftQ(7hBBY>eu!y}(}zcjPt#{@4)OM^{fdTA%)G9uH+ z54B1jKIK$ANh^4b2lacQQPh5KS9!eqk~4|Vo$zZ_dOguBaaIUc4ROCGx-(PM>_**B zu#u77plK^|pQ@!O<;IEOBK9Q}WVa*mfe||zh7mg^3WIB!BmYL>v-XBfjy`YyFLsS-t9!MM2 zcMAoXK}M9c=JRdf#<9~vKXqs;b`zTTI{~8zroO#PS88P89v33NB#lz7k)qr_nWHXc zH@y1r;8y{%k_XgdFDiHUZkb~u{GRIXVuV`bh5Rw+H@XtTX2}8^SeFW^ci$<{+<|Fa zCgb5vnfFzRKuZqL7_jO|r$dp2-MV*D4yBsW!{GV~v9T`su`Zq2V1xLMbh22a$3GVy zg9b0AfSxnrItF-7Q$ETJ^z&4B7_4)b;%-Nq#XinQ=tfS4>1!KocF2a;;`lkXK}0$i zP7c@@qorXmxDg2mHV*!2X45iOH^dm>nBm&N9VXJIiRK>zXc0Ejp)LYNWp92?aYrix zF|2;{$jdyC=I`wbg=Z%UrMAYp&&6-iIdRs{-kOn!jfa?Q4wDBZ6{%UGJKvJ4c*gq# z)u^W}q85N{(>8iiE2>C58q*DrNBh5W=>$A4gFz%!8!4`~5Oo+VvroIxE|xNNW$P@{ zhHl8P4Yn{t$S%rp$rVd`gDFb~lr{UZfg#(>FO(wym@78EJOcinhlt?KyE~tQ#TM|d z=Hb7qtc?GttbH`7@3oR`^G6(6ljnL;^?+AmaDv}S?!JURs79b4$(ho_L=lpNqHz6y zA$$+v?;t^reSNygNcHgO?7$B*q-Z|uR{6>r-j>{*??(zU3vGnTc9$SA!Wf9_-GvqE zeo;%<0Z66Dxi48WA;aP-^DJh92J6C4R>F)XL|$?@Kp(g&vJ#P{G7|+ai zeETBX-A9ilUT4j0KbZLya)7fypdI0w0B#OVl%AwYHX9zMK76hwm^!zabOOzY?47Y| z536f7vl&UueFeGJ+zcZ$W`5Tj2l#=&Y`~{j9HH!B$ZjAy)P`2w->==T1#f>^@F5{J zDrd3PUqjPPIKuq1td{(9S>^eASye03O~k79t1OKZ>iVCuI&Jt_RwaLz)o zCP9{h3=WUjOf*A&2>B&o{Wg3EGU8Ww#d8ef1PVI~gLDAvIdd4L0<7mR9Ef^G z=2pezi29}KL#Sh~zd3jdl)8#lo5if2T zG9Xy&3yg2#AKD+#m79gGeL5N_=GGcpO;;`G%>FkIXeW=z~w@R&O|!I!#wH_p8;3P@8M=J)D; zUn>lm6Y8`>qK@OqFyU%=85x6nv90l`31mN{FenpgnF}5S*l&|ob^ipAn^@r6E zv{OV-rY*U|fEPre-cVx6Qk^B4lO_Ywi_@XRT5*><@b46x;tfm1ex}&{FUvdH|DNK% zC00pYUVRbior!IRR~W=XZnZa?j|-QiBiBu5LsDJ10e=J2ANhD7mzsA zFFAb1N=!g0v2v_XupQ5Y6@gy1KL$k>mX^F1iI#L51VDj-);NbZ*gz)M{stM@X01P0 zaEuVwwXe7AF=qh3Dx~LxXr1N?AHkXo6(L|X-4}hkUZr`WBql>_+)ibR-y%0UiyTSb zsEyEUXa)Ne^-wqBEib*S{V!h`Z#KcNYe|vF)`T|pl4By9nd?Z7Z(rWU}*6+)@xZr$%S2C zf`F)lbWN~p>#b+x^3@uy@GWs`R)zp4XO=%g^* zL9i4#+nb&}>d_TYgHwBh1i?M)bTPxQy(m z-&tQrd_Bhg={N`36j7DS)Dn8EczPL_u}EiLjO3Y71 z7>PzcvWNGbd7yfQoGhVX{H%3|Or{GAVt1LbqcbCh=a zYU&@BUx#lVkiDHBU-=LjfVB$E#-EqPk*@C}r1J0vMd zo5kH%7;`#uB!e6{=sZl(WCl|ZkL?NE+2OUe`v@;iyR69A@?W<{0(QL|PZ+(?7{+Us zM-o3>Plb^HoJXSRv^|==x`Cu=ovl!URg3KQi3=`<`{TY(ArU&Da;Lw zIuA8J-nc%*WTVVT7s#b_Wjta);OW8Y-RF%ejeYUN<+KeML#bD{=gwFa2}h1+&A5P# z0eV-St!%fnnN%uk{g|+eWSLQZV!zk5S>r<_I~S@~rF6RiT@na_a=FpvW|)d)GP9R* zp5$21QL(7xs#Zmw6>Y8dwCr+>1s%yu&3qM^_Kvt}0`u~PW^x|j7d2fY;prB37obZ- z$Cl&1863(L5!DV+<&|HGA>-sVzH8XVaMa`Y$qXu+8TX0eV|>%vP&(?PzcZC;)aD}F zBCcN3i3Y~4jm!a!#3;n=)?Evh+NgRc!OGG^qtm3b>09P~%TOISn}R@-{(F!fCf9*} z#MM1yBrTJEA1J1(@QqS842xIs*SJj6FQ{=BZC0+dPs8RXs3lP}ptg2Don!AY>MAlA z<}g-Vo`Q+JWv5lny2CJCY5=L9Km4uA8}E%xyz@G{(4ONQ7N@lNS3&24nrt6wquxum zt;_&|7=8LuyLF+gf7+|`rI{~=6i-+7E#DYp$cG1dsgwyb=d-Zl-bT=nG4gy z{f$eM{2V%1VXsvghz+BXK#cCo48~Yna`(_Qp zixj=_DO$G-hm2UiJFYZ5Z$=G+-!=c8OJ!C)e}8;P}~<|CLbD`Z|bL62*b1WM?VuV3Fu zc23ux;7KLf+Ujn`#^~wW9(E2EFGTbq1tBn-lLXn%&98XEe3AQ>H&sx3iUpf(5h?>H zi0bJ|qOjFm{7DgJiLla=bxk;tb%)9E3=XL}wyax5H%OhO(@W=hE?oo5wdIK!8>j#S zD^X?lv9e%q+D<~2BOJ1$(065)JsI2)5NP#FZFph$9!+|)%2D~ z83Z*Xru^pwr!KktYWA_=1MXvQ`)`)7d_eCXeTe22uSeTkCjm?DcBf>7W6iK0g9ZvO z1-cWkPcdZ^`SsGE&9Hv@LQf8pW@UfiFiVYY3y5yuS2vt2`qlBQ!isUDLQ`X+4>k(vq)>FLi7C%cy`s`n8c~GGP-CQzi2>=E zWUF`BRnHO_*(LevIfo2>hZpUIGw*&Zqbt6c5utxNXHts%l}X#mQaIwAk^wE^zFH54 zQvsc&MZlR@*@UZcL2N7>&xt5Hf15?6xH&c_*3gqbO#>~}8s0~YYUT_)sz1l*!_5V| z=}6My3(cYQc;LHiR~}i@ExAarP{xoGgOpJGEnq95r)yau0W+b5*L4x{)?F{u=q#1Mp``xomFw(4v?KCiu6Qp(8fT#{*M;jCjmJ za=wDkvqToqUlp)_Jx}}{F8Xt;9L{|gh;^-w45S)s@`cw-N z`$T_%ZkD8@{yFzYaY0YB)Tt-) zW_@%_Joz^6+Oy>#(|wZjpv%~uS@)yo1?vX{Zk! z6}EF|`Na1;Qi29+lhLryiQNXv7<@*MQV(+EJK#}ehT2B>*7i$VNL7z_=^mDlI?uaFXq|N`{ApQY9oDG z)R{o_Yt@!-&q5Rfv7l@4P{eCnu{g0{oQ`bye(JOs(sB;#eG9S5^atI0-%$>@J8RGs z&2wr9z(qHwXBM=mfun^NSFzj+kFaRPMb`t$dlM3{mb$M$scF=4Uut)$$46a94M*!; z2|E{P>iHsuiJa;yWS|(H(bL*+pAQGkD1Z;f*{fyiEEEtv(W^NCL6L+VG6=uscUK;X zmgCqHjD;MI>7jKXj$#-EeTw9G6yiwRAs;nxD^q5RoJUrc9+RN1dwUqutQ+`)&oBLW z6&-C6fgIniY^v5Kxkkwf*}2$hYE0o0nr3>K%t@_X-Plu%8BP$ax0Tt|cAy%Ba4hAq2v3`JK7R2;JKgS&DZjOx*j_onn z83K%VM~>Ui>S~|&Kl^C9-3Jr1K6wy8BVX#KfPSG%4zf91!RsmrO-sn;Z2_cLZCQ9o z_AwjWE2f{~BDY_rLWkv7gR|GO?{%r8ucV`SX&7k9d z{~2gQgSEKh0ql-cx=IQPqu99W$9j=-4!;Vq8`!StA;LI%&Ih&8--O5}lqc9MmFK25rpjI% zyHq1NEyA#laXQ71jwvqAz!nL@)uE7QSnq)vG`3LeqXb#UYMgx6(pNr-VdVKva{>{l zs$D!Srp7q7Pph%Z%0K#3F*YwK7($61a0zwGEy}z;5S@`NQ)*LSkVfQ8Ty$5>XQlUW-|5KQGA5by?*`b;%Ov$zE69diGxJ|>r% zYTmvk+Z;X&#$^IQS*H4hBx3d!PcnyGp|4a-@7tER5~>-dPDmL}O=Z>Yn#OeB*Lw== z;4>&@G;9c=k963zg<;0$Z2Sn0Nt>l|>)d(JJ$~bDh5SMrZmKl$;<61Pv z<%Q-r@@-L!>spgBb+Jzw*hPJ;jfh`(^Q1~=ip8Z8cZcDP!%qXY%a>Ah2oMvi%uEd< zxmu=E1k%DqNLnMLLHKda&zZNuY=Lym3>!(0jqM=KLBx|wS2aqEhYvc{=fZz}H(Bf9 zFiDx9m)L5=5PKjwDIL?47z+Iljh)C8}f6Apae$%Wmq3gvig$Kbq$p*`*l@;+a z%o802zQYP?guC{HL<2i%tGX0kJZ2e~u&#JxJxG$uWvt-`dXk+s2~p45uVGC$Q&rjq zBd~j(ib=QKN!A5_9 zKM`dqB%+4MI8w)WqkvcbmMb0p-Fj~IPBC87vQE4D=}LfRFh$lRWxH~;D$a;o*`vBi zIcc|YLa{uELN!8)jsdPgiJ+Jjo7?VZgwQI@?Aq6#WE_zY9OzO+x1Sxw1_l4ekxD3hc^8g8iudtL3fRtm=?so1@GlZi6$UeP zmLo85ap(0%Eliw~g>4oiFqCmxI`Uqo$?;tn65>nH-W4vdRQBpy`)D$IH>Gc=TQ_E& zHfj2qRoM8Rrs3e11`gnYors}NL+(K(r|uk50YO88Bs_$GSzoC?j#UHoT|2(cJ~2yR zD{a3-Kctxgpls>goDu@=->m!feu+-HXhR?*4cB!q_-d`nJ$SF1J`m2F0){MaMTbDS z4;q)!Keo#QmsfQN$m(3k;;b$`&BC@JQM|GGyOQNcnen|C@YTFnUk`vlRVGYNo?4zE?WMJVjgVH4> zCzh^qVRfmREm$q0k}|oKkHy6Gx6Cn(N<6{{#;?};+>z2-{$@$++Wkw6?`HN)1Bjzd z1F69M;A4_>1K_)C6p2FiI1vp#Ue$5xspjn`rjbJD@;%ACuNkaIfMC? zUKV3S3zF#)Jov;zV5orHh1p>A(_=>s$mZ417*oDZ}FTfw5)4U$yy|TRDOvb8h#;;ShZqlMKdlFi1J zy?vn#WftP)RqSqdyqy-e)OjB%2RmVae4Wh55_>lwMg9|^0$}Hk7BHM#ng+aB>9*vQUVVuu4qQ~kg6~3y~kSowCkGyE(i!$ z$ljbAgC6ZWmumnRLbMrku%EoLm}W>CuQ*gn9;`UzNS;`>_7{p% zUTgn8QNN!2)Ifv$@}=SP2=VV(H({u|Tl#V!a40(RSe8MI{x&<+59n;1nj=4EH#m{mf#&K6X{cRqwat7<4bdGyh ziioUl;(?!i#|ixcfmJZqSkO?41Gu@1xNNfDeMbnmuF&loRJwBJS5L2Q&3B=;Z61;{ zE(v)oGRNgZmG!EF_Z*GUzWS+A5+W~H&^BPi6 zE4d&`K0DPL(wV@{Vho-eusK0J7%c@u?XrTk^pIS{viwZjI%c2~*HM>a5uc?ymSlmT zpBTT8`TFf5B*2(*He(q0lVYvYFf&}+6IA)HXW!l;2II(ky1g$KHktPYI~2WY60)a| zag~vKkY!oA^Ql>~G$)_~RV0{OW25?290Qe88$j*E?J&*3QQkIlQY>aFIrKu)YHH44 z5Tx{ujGRN(zlYEH%=76$jJyJmwQwo@2UrTGm0)#DVK|aN_EBld2QzA>ghg`p|QqFALz!_pjt;C zP8?YbIT5YaR$2%{G4R*EX&=giRTK3ZJ(VKGMr>30A@E*ZEd`Wvy;9^+^#<^l*OjL>hG2Y{zqq09pxjB=_Qy`Jx~-#$`q_ zWmmpqq$6#@m0Oq)*_XV;7uiu=;JQFgV-`UPRAi{d)j#{u$J5lZj-T1{|I23OznlCl ze}mHG)UE$cMXAuo!0_t5g)*>VOipJqUHfd$nkSPa3c#ay?P0hDWchwEE zDU8eIJ`au;W-!FXwZS@+q}}EHDgf8EWWS}8=SyeRywop=(o}6I)P%WeTYZ*2D6@c{ zGM@^$*o%^(k`B}t0twx$kP#mx7?v~RS#>L7f(G|gq9AucU;fl`nt{b%k^u?S=RuO- z!ie@D=r;U9iz}`Rf7LuBZ@MpEZSV<~ZgMJ%<)0-Rr{EYcPG;Zx15ldS=DKra2Hyvl z<)G47Ja55q?|=0!0<@)whlUQh84I@{5|TPWkw;y%q7%iRjv<;|ZP~~qz1rNW3r18su6hy1n}Nh&MdM2`LNK5fDtCrSSCSMX*k#dx`&mXAN zdGz7PDz}uYd^km^UD#+a5&N#J(+R)`qio70oadQ}(O=;WQpVhwd-=<5zl0hAAOU^d0F6aaYG2-%N zfE;Ot*396OW~4m+F~1Elz;%%;)Hk5eFBU~9d;AZD-o67_t5KHgQ`020itIko#*sDIFO+Rn2T}|sst1TLXc&c zU4=pq%+o=;!g;kF#m6XFlJVX!_uCsCf1?>)WIm`I1r`vVC>h2b8}i{- z_rp>*Q^+)idSsnWNGKG~ee{y$oQ|`(%x<$X@0ce`+BXIaDjT1#sY9*p@FhJ;9}J`r zLTzf?ziEDFFm#i{@5*+TAF(XT+H==gX0Gv{Z?^6v()-|!<_b3*JpS>H^TrD2arkFa z|C;Cb?+O6xU$6e{U%*TK@$h`c1jUdtnI~ec_R3>ANcSL`U!mZWLP5BGMDdNaDgpM+ z%~Tp08BegXv%f!`yucvVgjjyQ!N&#&VgA{FSsO&sU|e9V(`=GyvgzxU46I#`6J66+ zxy^Fmw>^v`n(-VdI3Dz%ScatUXcD{l%(IvmPQn~JBzeT@X#^L42?EqN{`n*^j_M8kOyp1*GWu$>!7wepEz^8i>~I z*t)m@JilgMMgrk8eb7z49$qRT5mG2CBBWjFFo6fjC66c{0ozL?wWA4Bhqg$so3g3) zDGW&TTUm0b{yKmj!eG*+N;cD|n=v_D$`Uu|S^x6^5%~8~8gzmd34h#urc!xe8eA>yt=9 zT!L=usWFY=7W6{(jFTN4DU4O#Aj=kB!+lkSNxTG)K#jGq-1kVG0^W%>Ik!B!1wCH< z@|=2Q`@l13LlyEZ9-`P`lBW|FMrmA8zT{sU!Pk=txJ_uca*V|>rdt{)+h6~Y4d9(fw7*eOu|X!?qmniJ&eYE;jy})W4Z2n85-IWoiNS8n3~e zkEcO_xP^0}Qxi;hE88XaMhm%2hO4Z+E_x#bl&Z_rP)&_Md6xVQo(KZgx$a)1V(>qJDSoRZ8$x3#@_iyMKBsYkP7~P zRs^iSci8w%bnWV1W|Ox6wA62+1Z8`hidrCUJ?RD>``)_`EVZ|7LJS%MwDhesm@=tZGXa3GL5 zOdn}R8_|-+dB6+yHAo6RdGR`v>9%l+isvao5;)fUXs_6Ysl}A*H+5vEi+JY6Wrn%AnV z`&aRa@Gy&OW~Pzil}~;oRFE!s96-Xy-ui7+l%m9qS8YuQa3B5kv4hj0N2BaOd-tg( z6okZUoW};2Jf>Ra*0q`4^){ciO&?~Ko=0^(0(#Z)vvcPF{F*UXb{p^{uvdCa#tajn z+V?^*^4);lG=tG~Mt@~YoSktP9Ty0|=NZkOhuR1|=&a&O&rB|VITKb8(TF;zV zdQ!@yC#`(+mFd&r<`{?tmJwv$(-~jXnTNgFg(iN&=(=vipyh5N%3INNCE3NbNO}an zXn!~*&Z1j85<8VL9}DR48go8F{oVk4SC=W6_#7Fpf4N!w2XR?mU)Soh^D5|~Z)oFS zYHjtmxgKk6JtKoSn5C|U3R&!jbfDAvWSm$VVLN@vvUW&$E$kf6jUEo_Vl-zj%So9n;GNZ8xk(9EP;IzXc8B?E2Y+ zg>GXlJvY`dl9}w*li^%+MpX&IU4v=Anlc`S%$Od=nrd`AcZ&~QlfFl3I|3eOs!(Tm zUblMcD1c;q4I5VxZq?4u|4u*|Y`D#5t5yqJU5 z?2KfdKg?s-TRP;jcAv=qb+XcV;Xf4DdBbW4*fl_$F4`|m4JtQ@7+b(8hWNdjT+=xM2Xdx>}=m1wObP?gvD05Co8}erHBR2ajKi;EDo8lx2U_+-a1fL zgWbY!T&S8@6xl}uD!rSO(?mNqP-b66-e-{i>SYVWehX;8>+CBQqX7^PVM{fba?Z;N z6@XFXn4+X@noy`wcTd$_K8P6Fz$iFEH%F>4I#oE;DXZPXHXuoB&c~loPl3mzGo`L@ zgw0rNPoP@7$%aE#`BR|52SZ>B=^+jt$+E`lMyuF(b@k@6n%=vY@#mMXgC zIu>Cq$l*F>s&e>9ppC>KSw~5KUtF&csE&7RS=W;E28=cfe7`Y0Q&($Ucm|2LigHSS zsKM}-YFhf8H!0G!A$6)r@0mTftZuz2ae4#xts-09?wNa?+EI@0z^HsDI#Nhg+5yrr zB$_{HGGGdjH52qGB>Gd;z*d28=h3gi_n&e99-Tf@_96hySi4H-+lnl%8W1-zaq>u)c2v?%D z+xWxZ`Ydj;($J@1X;1uRbK}yxcq1i6QA}KSymLI$v(x&*^ZKEyi#x#A)}vyJt`PpP zuO5+JZp;i3Tilkv?>kq>R$(AZ;dV3OU6GtY!LVs_M0?<*4RPQTDl(9OIF20U)DnWs z>I4;~n<``;9=m8)}`_lfDXZ-24%LkG$;4*Web`aZHtBS!N7T^d~9Gv>y=+9 zBFITe==VJa19cqk^LERE#v7yH{pD_&tpKulGSPbhea1nPUpLOx&an3}pnU3OE3{N{ z)!x=Y=Cko__MlWLtS=nXgLb=NfEDp|P2q657hl>3~T+AW!K_T)}wO%jZX zH0zSSXKl9RBCs#;iw_~S7vy0BvH=%}=!p!GNMK&<_@N>@dPGtK1sYr%^w~89m!CDO zLu7!!Sj~pwj-&-uc*lA<@X{>pUD=oj3bedUHl5C8Su zE(kWy(Y>y3ZdVYNX`-g|`?)*QBAsr-%7SjiFE&IP?RSdo3`z~y?O@t*cU!d0GoN&{ z-3^^$R#q`2zR37%OE>f2DS*n1E+7|y#Od&1Vs9C-AKyrCm<47KN`wz{3i62qv9J8I5Mv6vE!OkoF0%R_u&6m{1mkCKi!O1EY$2GdhqFT9t+v(O z;LFf9!D__J{a5|1HS>_RKG@2j;98>9vFKcdy24s3<%cPBtT} zj4UTt8E57(*ALPOAF|=UETY|>h{)`NzA?4N92B2d``kQ&LJ-sqn?O6esuR3=eA)i? z3J{|8u!WLr{dk$g_qb-^M^IFoyA>C9O=)c{awPp+i*`bK=QVcmau250!VTNy94^r1 zX}H7h+uj*%TMu6(r?zM5@YIaziKe%M3Trb-YG?_3m4 zp@jAns1%Uad_Uu`pgpC2Q26r*^%bvAGExS8we_nv8^SwU+{d5qK;V;Y#eE(+={|pI z>E9!ixPRY~eExFL@1=)8RaINw;gj)WDQab8{kO$OZuFBfkH{HkaNWCQNfIB=?4JXB z7$&IBBpV|qSU`pZU(FLqkLah5KU6Yo?5L}FoQpk0eO!9nfna@@o4B8Df6+eCv7_zn z^(uhO&O(ysI}T4VhuVmW*vHf-ABg$?@%7HZnM6^$@5B?^n%K5&+nLz5Cbn(ojqOZ~ ziT%d5Z6_xm?m4$^-Sbs-S9SlpYjv-^*Lt4c3e^kc9v~R-1(}BRAX3DEqbIp=aUo^g zY|FuZ}D?{Py?jx#^JD1C$zdaZRy0F>< znf0#6I+Zn9trDP1ay~O_OxM06(zCWWYhHSxV%C7(9_x21N-%86jQQJpzs$+a%@aih zwtaG&8UT|ilwTBjb?=o~Qd#{Z(cN9!djAn|2L5dta1N61_uW4wiHmCjs&&}R^@Hkb zV-2QZCP+&j4ZZ+ zq(H6JNg(QhD3%DZ_Y!h3@n+nrj?Gc6QB4DQvzW2jWc8sTVjxr_^5S1(;Kaib7uNj)Sm|u_+xww(8E|5@1?|T^m+nWr())eW;=N zE;TkEMem*#E9v@eQr5H?pe^aLMs_GON4_bSpf1In!B=JS&oKyIYA}9b{ztNjLJ}<( z{Z2Od|6?r#^?!$?vZ=Y4hr@r@Kw?y^?STepzMB}wgLc2x(j(KR{%Ub!1#&ak$eZg1 z60ta%MG(TeR6z#J8y%K@kl7nYkbnO0OTNiYMM~E(O3Lj%;+=N3v-SIWxq)SdSq3tJ z$%x=^v9|=G<1_8Aps7|_fn%=xEh-3Zi0q)gtoO?cv8E;{^C(MllItUZh=U;QA!XF_ z{=4CZ7*)Hm7&V|DQe+zNuYKtzkOH(sEr(Rr>n~rx@}1ory5wSKY{#76Z}$%l`7XHx zm+Cc#RqxoVdI7khK(H&Y#^JkU8aSU*Wcmuwo7^i`&;ZlQ$ElZNv^DuswRL#P<%<1J zc<7M;l_M{6L93aVDbU8n45L4-YfreBEyEYs1EJ~}76t_9V2$Z4@qO8XhfO|}Jv~>i z6FMAqAlm8u#_6~v0cUM}^>Ppj@Vo-~u!sIVku6G-4Cg&Ym19|HbS==OOU^uU0q=g*G*%ghQ_6{VN^}*^6$)2EtL26P-PzbbP&S&7u2Z1% zm>+oJWK0;6mPo~;bE$Z|K@E@Mh*m<3M}7-mpf{W#{T9t0TB;8wP5q|Q;Ga04FZG{O zZT>PnK-Ea@M_t;FY-%4yy?Y`$ z$e4hv6dG~7^;4_$3-mu?&da9nC(C!t5&n-God2JL+5cw)?ixQXJs^k{`eivMYTTq< z9myk9pl*XfPqP8u5x?Cp{WQl3AW4eYC;mgH0r8)Huw1F2z(K9-Grw-<^y%6sL{`U; z8dzBGAs4)J9!`TgdqC=7c)?0XIn>NwO!S}e#ApwShVT8H8E0sn2b{*kycFpJB>@48e>0Y6Xju%#!)HJ+`Bg6T4=0w zDQ&X^ESbh5iyU4?76R?Mm>aCvua1Drw*!IX_V|cr%iU!Dp+HY~#vqb2MK`(J1p9|H z1A8^^peh*x&Y}co8|D3KQPnMC`ycx7SP4Lji_Zg;n4Vw|s*gyAHsu9yR9oXx?adl9 zw;quHSmVzq=vu7rBTo1C{eMq2i2wV$mKPWLuf&q04eg`4upn^My>f^0i?KHzoVbBB zDVR)hzK#++UJ@n#2TZt`BqTEy^T|Z;Wc!|WrI-%7E>de-K5+;%8+}vDvUZx4?ZuIP zv+Gj(Le1e@-rJ@udDO@2+kKk%Rmb>W^WT@(^Bjl*;*crjbAOuRFuhNN^ob{_fV8g8 zUH9Ybow~2+z-;PCOS@Hu4{5^M-35LAoTcYyIR3e?zmQr#r5e>U#Vs=d(Br4vmWyv~ z86?cB+dGZXckLY=fA$YC0$P+xbWG76W{K^_cdr~|{fAAH9h^JjhHl7L>Q-dZZZWWJ zQ)bz*b1oqAuU?<=_?L!{ZeHxVdnJ-Q>cbe4KZz|{yq}E_e-jVL{PDs5eMv&`n9p$GW`+0ozlB9Drt3dLh1W=b^@;Xj@NC1U zXeRKJoN&P@D9k?9+dd(uBP9FGbgjCVIC@J5M7 zfZCiOX_gMidwDnjx?O7bnGweh3!8U+Jn(mP2AgF-kuJZ$$V`l|5f z9rJTyGSB-N7SZpdsN;o(<4X;^OVdH~{IGW8orBz*xT%F~BDurMb#fF|yI+TVi9$HS z;SVQM&?vrLl!SI+wX6uFcFaFaQEd@AS*r(X^53N00KUym_IVGCB%1m3@R2^D@*wAX z@K{fsH4ZCENAeo8+wG3_=4!q^6C+L3%|vb2u)T=a5q5*4RV=G$F{Tt_k;;XwKv82E zN`kZvk&EJrL&d7G%;X0T< z6CNyCA=5cC>Q0PpIeJOoN5;NIgbgUjrCfpsDY9Mvzl$)Cev3_)ziEEQYtRQJ9xw_uK2$n~(hd^9?@0)A>?5#T3WY7&~S{Rp^ zicw-D*n0yLEMm7aX>q&SA)J5oRFt(NO1v@_a8yEV*Zg88ou3CM)yWc`NxBBQ{hgvr zL^ogW-J|nt#j3drEXo_I^=9qoJPlf_6KW9K}(4}{5J+{voQKSKPI4DYdcyKa@!(stY{5u zRe72fZtbEmqZFGuIms1lB2by|5BALOYXp*&!Q?%b~_Z+3TT z{_%Y1QImE(lOF*!8b$yj>~#0Lk~rdX4DY_`$b+HCn{-`7aF za6N=xeL9`?iP=UM&ga|Cf$L1$wn}AHCxQ9ke)LiB+MDKJqf%B3;jdN{TNoZHLTlkV z3+LZGbUf6OdM$1t6?ISo)BbBG zt5hq<*b7mUe$nUbb%o||Cah9jgLfPL0AGEuT(qlF+}CbyW*mjT?DH`DsA=pGpicW; z_9W$HJ@NEf0SuRo10(>R>Fo~I_AKlt!!AD#6HgjsxkUw-PJWTeohBa=tzI4WWW6JP zmS%mK0+ZhDIsA;BT8aPeLnP(q=Vjf)avK5nT$TZOz-d`8)ysGPP1Y0GS77zBs`TSm zjK0BG_a~_(lf~*xP9m8rn8;BVOI_C5bNz?SPf^72X18SAO$!n?v2d*@Es#S zItuSlC!>oSi72FldZ-4Lo`$9tW&BWvRcEFFu=bcrMJ{+*6*+tx8*VHLLKMj)Xu&?S zY8eRuAATM3x*}ZT&jl1rrdx$z5%p?2^eVNcpb8A?tnh?2tF%A&+y1SxnpuUERYQ46 zxXYK&7wdwmnjNsmlvPfAOR=>)R%uR7tss_d!7*_ErUIp3okf-{X}mX8swA_xmoVJ8 z=Yl!oaDqTM&SOn@bmJKECI-V5kUU(5BFp_>Lw{9hAZH~N3Qe|}W+U2*+Rmwma~WOqbcqEII1np>ttD7USAKeI^*EJn22qXd zK4lV;YO{ZVuAq4*Rm-?Q%8KCLiZ&LmKjGhE>NTy0`#+zZ8LpDdT8#8l(&ib}1uGDw z(*pxp*9L8q3LK^YZ8h_XK?}|(Lspq4S!r3<$n>Gw!MeQELu{rP^AoNl-yq~X11fAZ z`|{_gbA5sl)d$`!)o~Bs?@U>uU84@bk6@#M;hoz*(KU1;(*S7JOv*YLY6dKym7lUE z1?eUNH{e)UJ*m?=7Nk|Gl`H$=b01z(?Fs&NK2$9pA1?M^r?Q){Io4PFQ+L2l&}k9{ z1cTG(hBvQuUwF>`OW0CR1H_1V-@*A{)NcH+J{4)6*IKq%&=QICqWBnGIN5MZ_;tg> zhb&ZXXv*$zCIXc%US_ed5J3+^+WAmP>;Q7hV6t^`wIlX1P^Cs`U|ivb1x&Ik35u&K zy<^iN%&)i&t`>}>3n<*RuO@v5qZjm=EbyR1sd=%a%!k#Ips%U1v$e5|D_WP?i6^Uf z^`&-rn(C+3`YBxZhF*~RSf>hd^Eb-6s{JRUTyK>SI!mdR#06aBoaJBah%zQWIRHAKeZ;%ykByu`#BmmgdY3aoQnruy2% zVAZSC9hw!t%vC&W-@FobeqjCpi&Jxs#C7X80Q6($ziQ1wiDZR;`41p5`WTx0apr`y z$BQ`uI=Cp==RTnZpw=*vDyhR%sL!_~niq%I{aA>8t(34`=Qg!SaFW;X9ftQm^%Li> z7UHKuRl$6PBK8bXRZt}F2u&5{%C0*TFB_?t4~@QM+*BbrEFpwZ=0(zJy0DNZo?G-H zIjn0M*JMD+y!IO*{sSZCn4-@56!{`^L|+q@^> zrOSRxp?eYgL({7t$MqS2rV2AH+9WO=Q4ufbhNgzDp*2*_m->K2(zxJt=2XsJRb3|$2Bq28Xk)$zxe64n>B?1@JEyt&QG#M>Qh9& z#v8EHe%0i?f7mX;{;lOW|5WPmo48B}KO^|tc9~FkMxe#5od+mwml%uCmlDo@E4}!{ zhL?~s%YWNCzT!1$7t+6Vx*4swDc6if2EAVjh$BNiko=`Z^o@Nu*Y$fMCf< zqW)ILfWAIp5G$#sTf9>c$TlY{){oDDz{k{}eMIgcsFAI8seudRk#iwGP|w*K$T4gG zTWr?QDZtIVAX!r?byeb2ByP*d^DyG4Px~~sX=Wk0G^Kjj3`OP*vn7`+s}S({2F{%uIhYWGr)eC zI_wltG49toL4J+-{&j5diJJC{kZeyp-(!Jj43&=m z^kC+fBiWYsgKSDd9)ExUqrc$+iSsD%??|gHFDkIO^4H#g5bMO9=*A4*k|^qHb951q zD}l1$*1h9xJMiK>Y<3vm3NYp;l)pu3+o$PUx89Do_vh(`pha2CwX6R%xw>&*U{(#= z!4Hh&hYNhur1APe`vG2u*LLIcibg_lxgqWcB8zDk2Q+V6fX5@g=em6OF@$=cBd+}cbYSg8dPjI>w0(}{>80xt zd1u4Q(8&Gm3w}9Gu=`$*&)WZaPJAQ{rzS*!udy{STHh-dsDOQ51v+I(zP?0UwgKa@ z#uzxE9-KkIQAanKW7~ooKdX_+!~9x#C=b#3wA6z8tiyf0j!-cOt$uJ|Eo=rAFm??Z z1*1^cOWdCVg#xJ)^$&uZ`xs-PLJ_i=(zj z7TvdlFUJdxdE4J_Kf8k!*dCj8vw%}tib4|;E%S9jLy=NC$H_}6LOarVqzYQLP@M)^ ziSlJ~hELKb-J1zewC;_>3_KQa9Tv3S7AS9J*^Om^a+!TxtWb9pcQbH*7XbA&_4SV^ z4IIym5M?46Oo8kBf9T{QMDC3Ge7Wlv7jdCLcO6}er7~4AOPfzEqL0)$rJF@=dB&1d zQvjZPzwhe!{WP8`P5D^C`!sf;_qQWhgQG^Lg>VLoReO_=OUHzUSu;bfJbiRSM`Z4wC?QBW#{_ssRhmHL0p`tJkDNs`-arRiJmnk=cPxh;ikN0D*T)MJQ>g=A22 zTu|cW>pzR&7OhctP)GK;SksSyKWq9;@5+9DsPa>hAZDeCyW)u6B_rITu2d?i-S%4) zxwhv=@NcCzA_H8Adwz3>SXL`2_Tr$n-B9kn|Cs{lC!5`f0!WB=nUM2TFw422x znlrqWnER(u_Thx1G{_|J;ce|M+0aceOy_^-8DcE*SQ_FV-b>+)E;KYFn%I2RRn?~E zO3{n{v(blj!6jO0Rvk0sPFV}7|S(gYsy zMkO9n8kA}o^N_63E(3Z=kJG9gH~=JF$kWDgps>`+*xHk*=O_Opi6PHvGLPM z(WvaHNomKpICX@55S%UYZQ!rrZ?qxdRiV{toQx|DNV`LQbj)AL0#Cvcz}uoDs}Q_c zwnLIZyZvPv*9os9<3afi{|d;o(Hk>lI8g8{H$+zJb#n4NbgCSVo2!2 zmV}_0^!E%7O?}Dvtn!ce$0%j)ra0hhwJeppK0~ApOAW3-WMydTCiSZWQKNxP!$J4i zsiZ`JCx~GM+h?@pd3V~0RaYh9U>Zf}{Dgk_(j?n`eYX1C8kZ;mj_s9im;c60a~%U` zbd7RktC*QTtmN90@fr5mqdQ%GTgHOuw|MEzfeWNx+~Um>)sV*QUmrHTKAz*ZWoHuQ zBOMQliyhn(`tFF!y$zS}Cq>LHd5LFvugt5`qZg1@FagQhYyMZP4~@>e&q1i=?V$5r z(zjVm2h6ym0p1Y5p}ChM-n_hhvUjwlI~E^Ef#K?RT={EQANsG<+HK4i?oa%!A@^Hf zU+mJSYm#>y`Oboc4{8}pTUU-3C4vc&eRCAwaA#zH^s_`!JsmejJ=d2$frwSsQccn~c{GryN-YlqSo zglbdwYebNE)i70m_H`$&KRmWhf7+#9C8~}@FMF>0t{NQJH&Bah7%}|>m`OUxOTssY zD#+#W(WJaK8_YDCyD?}&%#5r+r1JAqrjlg*{>wIVO%B+xZR$M^*%WM{nQC2s&}>^c z;e*jF4|yl>dZov7Kf_|QGh#Xf3~rrpLy>5^%>F#XW3lS?kk$FrP7=BDA3 z2XduMA!y_H!{#aNNEcMFUFr7T4uqvW74PxNq=iPD@e=N>!@i=BZ*R9fmE@A==V3-X zMhr1DK|W3%eBB(b!}dVj&OLhnw7^RnIxFIN762L zqACmps0p%y5;gb(JB)dZ)@X72-V27FVdA*@I-Y4*LX@TQgb zUPRdf6qHf9B5%yt0vS|`eUdWgRh0V;*W7+kSgiEf?4zgRuSdQ=xaxVXhm0N2T+rs_ ztF1n8C4AC~=B|YJm|)l_PZJr^G#ut93(?op9qGwXQITe6*me=Cao)NCZ;0v9bk~wx z97EX%q;PiJUvfGMxNN?U6p`U7U$W};j`5-COcL!_A~d-gzO zCUQ{%r`)1aQ84KBC&sKwf|X8pI~I*{*X4|;wO(A%zKS%&(KwyehkTZs#;MG=uWLbf z=GQ$2D<@7clwFTC2Q?kvg}lPJcbw0N;kR`)qN^eWkN+f+Z$o35mfGTYkTgfBBB>9c zJ*Mo+DoIy@Yy};oQ98rgoLr&GSFJ>20lU~*sg|iFLstl#SWPfnM93W)wlLGPWEl^_ z>GN{L4X}D-s{=-y+O?Zy!9stCPO{IV-dfjG)A+S)?JdHrnQ65%ckD~y5Q?fMB(BdI zpdavO2x`#-4lsY}^+TpFK2eh)r>qMIY+v(Gp#NkbrGnuk5V_oH>_H@)0w=^7Q5~sL zBYBzEHF2;8MQ0TnBqPs)q)l_kWQO|Xks7`WWL%Q*tv`l*#Ffn znv0EVCiR%7#6EAD46n@`y6A@Kra)VJpA5mv4dJ#*<&i35(k_d=vtpXSc=#gbyFC_Z&yy(=( z;@|T$k9v|-KfZRUr?(k(L=B>D%x+NQ{=(>*T~XXg+FVdfK>xQw3K0#{7z7FR!QXT8 z6j3Mpn1vA^XUZ;fHF}wUkWbGerq?adQP7X>0E?J(AEXEFK<{lY4;3-M@=@dDC;yUk z+k1I?q}l7doM#N;=j_e?)(A1+%~Zel6F%{hY3JQGxztb9fpz?fgok-(3H(C~>O}ja z;YH--&w)hWyL`L+{Mgll`2(;L^B4=RmZS^1vlf)xAA%D)Slg8kwj3HPcd;78?FoVgo|r zS!o8?nzEXz} zn4Z8$>i3R*Ok#3Z<6BImP2 z^IEarQkg}UG}gNzKkA#}$??QEHmzYPv|^(k6BLCLutuKbD+$Np7Q2AoP2;Gr=&$6- zbPOJy4=+2lkIF|J0`d5j1kz{$*xV&=XqYMW%`kY{{5S~ZzR6?yNI(D)FZ*z4d;ireWmqo+qq-uIX)p4RAz|&pz3AbY&mxE0SLgw`=iRRDGJh*5K_a^?O~vrg zwqUJ#*3G<-?hVvQI4L=RPqFMGrr(b$LQJZ?`ROS4j}XbnADu)y1t9)gVC<&~U&o~^ zP%lHL%08Z%)wu#p^Wv6VezDr$eUh0W2m;G%zAtSy%JQXX-GQ<&v z4NJx{s2WuFtwS$1?=^3i@|c zAST8JOKFOI)gu^rk4ZdRCfbdEak(Eh+E&**dy*#Fxvh^gjRWiGj(ktJd!{Yj9V_j2 za_GRP$B~SXz2@*J8vi}f5x&PvcibLVVE-xR>{(^c>$Af#h&lRf{@0#3TYsArzUg|E zbhOSq>z=xr>A8|j%-RC>P)@}{n@*1LdT9+SfnrBY*u3wa|7*r(d;(6{1yD>yCkuRjHdi!fJ`z@yL#-kaIky6B~8Il44sn z?O(Q@NwH4J+}dXnRrlJnvb~+m`^I^fj~TiBtHLg%sSkmYy@P;;B!XwA9Ln7EW=W@W zKicge37pW}zv}-6UBCX5i7FOXT*&cFY#QbIpL*{9M@#dqGyf0S=6|cqmE`Qdji-Nb zdFoN|5;I$T0D=X-tto6N`R*0}fdHh13VuaWr=Vud+v-A4a3Y-k-dV&=!xJnl2S*8{ z5rARpXeo^UDRWoP(rCY_^YwXm0mWKnOcTbN+Avd3yAc_n24>9#s5c25KbAboq|7QC zaoOmF6luqdU^FsdgPeqo#bSv;Ifoe%)ag%35`qQpXXNtKF|HW^6T^&T3~ z`Q@B5Jv$?x(>yME^j2%<5TTS!0ARN?6=g}2y^sTJV+fYQMVbx_ed|C7<;#AECWg~f zT2CE4O`@Ji+QpyI#0Y_g_KN|Cp?Z5dT7C6+7W9lr|_iX#tK*7_`@ z#M#DSmLs814MKG&$$lw)cO$+6Kas}|@@Dd6>R?v5Y$D{!-4H~+!1Zt~f}pY0u?e??b_`iY8)2HMvK zQX*1rAhMz$Yl=D%bi;fLOiLLpI_^y5uhmHj55Zrah>btzR~PNv>RnHanzL*LIOib1DUhpxB;QW3=zN>bKx= zUvKL`pgcUO5$$*a~p`_#~ga$+36?s%X2q|k8QgSgq6_q zNa)jd+A-zlKJ2HF?>zly4H{d96N&8@u)7`ZrCBXU-k-3FZ{@>T@F>wl4&u#R10TPh zT1OzyOCGPHwjr~QVJwJB`7_kDng;t~$;ewvzZaEN*b1N#6XI#lbP=(`n4yWYzCtid zZpBk9)$bPk(1s!NQ&l}o}Fn?^^d=S3mdf@Z6dk@qD9cT z;qnY7oK`z%O&JdEMM40YIn&^Ftiw8*1F0*^KCt4nDZA-pvfQr>B&E-43?<eYMtv=#ZvIMh@X_tylQ- z=s>9Y1m=X|3$*zHeIYQ0+9HuYT+W(pxsuKPHPCSkGKD@KP9nv0EjWm)!i9(@wCsQ7 zFLzC}l$MZ5eQq`?b*KuI$NlsWgu5gaK)n}52aHJ=esSj^=oepv zBXplY1&Bx>w}2XXK%%T)3k4KZGgh&Jv=_Qh=ronS{m2X|^#(@mDZE@Lr^xSZQ1fe< z(>XViazqc;fer_#&LHs#@8AaSc^-b*@~6xTL5y^oSnB0STTq&$*D|~4GatOUUB^XP z*;q^9wFcl4{!E{XNY=mYUR$bX$eqkpUb>wz1F%YF-Qc>@#O2%hsre$2L4!FV==)c#qoM(izT3!70+ z=b@^t6Ei#`3kP$g z7A+W>lLqe`ULqQ!O?W|%zPjY5X!E51)~8CtS~MZdZY3JhN?@U51t1pfuQDD;rP155 z#^}(uk94s&C0U2;ukR&`;990gwK_|>Lz@-`QPX>X>wwraGZ&6XOA|(wFasTF>F}kg z|Kk$69Uz~TPk_|;n=nfW-xpPOJ6&2ZClRCUgFxnkbq(R6!~E^Bk?^HKY{lSqVasmH z1(eB?5SlB>PD?{{QM)#6$=de`E3lR9)}|@V@f9JMUD+Iy@=J7vT6j6j3JlWiBDY^d zmDJzjV#n6W@XnZm6)rMZ_#R{oqO#wG?OD1wB3~inC^;AA-JB^&79XxuO($#r?X%I2=Lx zV7oOx2Cbz_GPhkJxt<5#=(SdHsg-^;x5#8`T((2}OL?zqJ2kAcz8TW>Jnb<6rZFiL z>Kfn87>2Jc*jG1Hh+_w-#t6^(K5tjz_01uM;5N?@q(||@Z_vIipvM9AYukOjFRwqK zCj_?D6xlt!INhGMu&PfmnG4HH(y2AuelLB9z(wU{N}1-I?5}P=LV_qu^QLe;gjaFT z+vk7E+SiCWjI_Qb?Iz#wjsLsW5b6Jwm@NMv3zZhEPx3;Fz|lDAR?f~I8zs{I4Kk9E zK{#k6q$n6PiX>>_k3hui2_Gp)a+ZM!4nf5mI;%hGIuLmlY?aN`zu?Qu<5tymbl&Qk z*EVchtJhK&7Wv(*-J7c){Vq9b!5MpgPjzi^9pyS-dTw|pEeUviicuFK^`PeuA6xi; zW^FQ^Z2WMLfOww*Y(bR;#!`DJ3<>;vE-DlleKt4zB24<^5G*=oAnzi~XS&w_`7#H7 zL0RDaF#v`|evWJ*fNy-LmwgOHmE;Od$+AiB^$fvHlmo2mxhjML_Oi27sH zqvx0N0udQuDmzjBkx!$mj_i8|RM`eC1RcurOUnDAHW>Ta|WGjt4%@m~@x;grl zVyDUt{a{z5J59InO-f{~a;L=2LS(IyPj$LOPF0V7FZ``%(I^MRG0|uVSf>VD$I8Br zZ1=*x0#gQ0whMWxEF(l#Yp8p$_1=!ChHX|>ELl4SON?%=tjW4V{{~X5x#5$oYWo;D2-9O7Omx1f zO~+0sI$n6KJlKQ%WZTYZ%qePlEg;gV6h)fM?Odr2+Kqhp^6h-<$nO8XG0J#bNbqWlP-4jpIs$zt@ZI_tTUOU}X|+0tG2AhtVEkwk#@cU3S*<9s zMLAAF_b%!QkR%TOjcIt*Tg+Loph8pR3s&7@W#;JF_68IaqsyBIvzAC|(@@TcTXdae zJE&sG;}ot81V$7XtRg8}1N9On$O~gSh~>w`{`I;#1r&XI3%hA&u|o^9FBj1t0;5uQ zaaif?J&YA5T$?u|xMZ_hTa^p;U^im`NyWjVWD$+zXEi4_j$Vl;n?o+#RKyeqi+bB) zBpLiu2=}YXK4L?TxJK90qYJ|&#iG;EL%?do2rv?F+KVeTFE$iIw}-)Dt%HIFJ6ipY zzKFI}&flCH%|Vvyj?W1zIoIALir69=PH>ehYuTJ7Ig*EH7=O=LcIeYtKigi(s=ebg zM<&P;Jm@#TY)5UlcRehR(^(E27L==k{OidF2a#hTLkM(5T&J9>@pPD5{sB2Pw< z>qX^lQ_x)&2}ON{W6dv*Uqaq9T{v8wZu9wxL`p>z>FNbCXxzDCIeeAj^6n1 zD1R_abaN!;B%S7SG@?Q~sD?0h_(B)9(K$!iS|oPG)d0uuUEbiv`95$kY!LM~#tef2 zA)ychkA4uNXYX$9b(bvaDXN>wMW$jAW`iVYmRq6r0sxf*3Hif^A3C%JItt3vS=|y+ z8iU0D_W`D&skUH_UI@K1gx^X8z&gy96+v&H>yFkpp*|%o_%HRa?#P_vs*q3AdSV3w zD(5hqJ*2ESrPb{ct#3$=-7N?0C%J(AY#doFjWAKIMDp3}u7=pk^UfHl-=KVvRqkl5 z);k>)CrR+sK4J(`WvmJ0h0sAMhMx}e{7+kn%uwOAMy6qOy$~tN%nPXqWqa^`p2o2U zi<`5Cb<_*|&k9cbt=Iw8_2MGSJSO{{RMl0jUr{35(>|L&3O3|<$;@29=G}DeX(FJm z>qX6#pG}*dc>+T+B23~~dtmI1X470ALWHT-p@Mb9qY!3QGS?nrA0yvI`;vH!?EpGu zgV@2Y!L6RkO!de4k_YjFTL&ER&Rh!SsB0*rInbQi6kJ9xe4qS}+?_lJU;*BfvKtd; z=hZp8p=6t56UyEZcFaV7*z*JO+UwV(c*tDlqc(PyN5OsP*io=a5W+(W%DMpYax%7S zn-PUBx5Z)7Gq&S$sZLBGo!|{=Kh@M%R-%o0Iuv(+(7}go%Lx+Z+S@O4^q$ru{o=jGX3Vp)D(U;n?7+W7HW*C z@{L37Mae*f?1VKZ%5TQj<9q6zNghgkdDpA(iBI^_9-ufx#IC7ZmaN3OR5_cvlPbOLBLp z=#~gv%tqK87^C5yFNx!|K#reX)x1On_T7?%I`nPf`V|`dF5=7!ULop*OG)u3Vr5?E zT#pr@3oQ-+@BYmKE|PgZ8xhZ(`ar0eZS_!hPK)FSP4Ewfb)JpFJYbL3JJ@Hzp#5ze zt(X4l9B1vCyQ%SOe;0AgT6+9u%k!}EO~9@x?-pwp!d5-{ik@aIY!lhhpJdPat^HW* z?4O){NTkDhvEvXZgf<5brrMc`oFS27kkfpdd^cFh?h@L((Ho7&Ny{l&_l%tT6>$e( zVdZ?-X>Zau)d?L_XK&OKPxPLBr-suIL}_QyV>!V(#4D<{I67ie^Fwnww{a0pe1_a) z=KV*ybO=$9obk^IEb1IGwZwU zymV@9re}n{6M-5{v*S@M_Xuc<#$sO@Tyw28?s%9j7t#F2&kC!Vl@ovLlzFu2&q}-q zF&EakG!TY!U=}@?W0_f>X|r3&Y!RomwYRdQwGkh;24aT!(_c;urLX-7g!*Lz9b7a! z)Hb(Ax{iuPi#&SF*-s_6+_hJ~bOs@!T%`yRU=&qy;^I#*AhzwuT%O1;p;LxuWTW;a*!}aC$3?4u!E8oinKYhrif>uD-SVv?V8UffQS3u&ToKqX8eM)^x zJVZ!h)c;Eky!^J9n`PQ%EFy#Y&j;%Zqnu|($)XzEOp}PoRgu<9$XuUac*PGIn!3#_ zD-afh*@-`_?G3~p)OSB7PfJ(+ilv~3mAB`~!!Dw+vtfE;fHApG3phk1~UV%1~@jsFlz+WX2=()OZLQ{THv!O;&!isEQxGE zT6Blk6w1x`Kv%pe&)Z>zpbHUk-T$5!yHe!nQqb{a9rVO|xF(gpR+YXLUY(Mm95_-+ z?XaYvu)w@3+2{5*u~HgyRz z1nLc;wd3-14|9fH4#r-wsLy>Y-++l{6a0%MWU9%RsNWl|U!#ceE}!;5QkT9F5HT+9 zJ*m70?H0#!pNqOj8S~3_gzbvX5Td~KKC!-s>13X53+R^L`bC&yq${%p(3mCQ-Y#7_ z*0G@UwuCg>5;y1R&$;LR6GrWUk~Zsp0?%xC$Cd9Jm#ie#!Su$jhBdy^xO5C7KIPhiX^;@W#4afZG*V|HA=5~k*K($p z38EWzfzH=?Qu#TM`7sD#eFqzBOXHkd1RJ&Ci~&c~WNg`IJmYhe55XWfUL9tb=1&qS zzZ!EL6*TNE4pf*qFYd4_@C!NN&jca zDk|r|;{AI#2xbzK5t(=mKLd#bWnr8*OQVY!U@Z`nctYNl-_>TIZ5Qwe+<&=Nv6g(J z@;AKmtr)xdG_v6)?dSp2d23I7&BANXVwF%2^qn z{Fazk%b>rsc>91QPr;6&ee=E3CsEzeB6whN+#V7({p=IkI_genUXS7XbhSwJ)ij}Z z8v|EVNcAs}$JuTO`gFe^bu>No2rrN(9zI+Ky8AQGJC)=|M(;pm60x&*?8ry@nmq|) z(t~bFx{dhGC(ZxWKg5sM`suPCt@x-pAjK$+DHqsAi;kyBg-MGB+O#=j+@IRod@25MnKl`(e|8ysRj-|~(`Oy6t;h5QaHhT>x zEQx#hVJE8KfQ{G?_j}jLHw67F`Qx1h;hMpNv}d~L8H`}k?k{9lA}Y7Xu^@0}0t7&fgotN4(b@f)rw1V}>XMy_0Y| z|8pz*zNeZ~I$}ECDOUkRU$DqAIp?3bGFhIOiYM~qc4K+wbODkPa~|d#F`l!`vu?#v zaT6$$_T};kqP~en8O;C|(4OBO3dxTBr1u#Macy4#u#}g)@?+K1tjGGaHkJi*jgx4!m;zeqb-bS5GpS#VLXj1>O|Xw>D`= zIXWtvB+;Hy(3vDDtBT7~;l)zyyj2BAe9ZLk9K3r#do6>X|Rb_HJFr zer<=4GNMRDFMUrB@m^)lRC0G*eae1%@yJWMoZiaoK@x|AfPju3!%{)&x4^sbAl@qv z4A+T{x`4)>7G)~`6-!lrr^~wkZ>>pFKio-ts4AK(w9M3+y%mca)_b)(wR)vJK@V7^ zr?bZH5ld8)C01m1@|I1sbEb79)}f3JZ&uxTm{7;dB!5<7H_aHFRPG9C+1(&AvlwW1 zyP)lvr6KUsOh}!|YN%a(LF~d-`myFRT}z+!S*WEK(Z$N?M2e;&3!`=wPETqnvLK`Q zJX3FBQrT`Ufu;GjSmlc;s6t1l+j5z_857?fzx%P%@(#tFoW^mjd4dt^S2~QSm>i<; zoeCbZVYv9Ie2LEqog!+jRf|3obmFgq_mKK1+LUJLYVG}~cHC5f2ty%2AugW@-}b7i z%QmEl&Yf-fv1nRkn#bUb?_ft{RvVe-ky__aV5C^5Qhjh|q^XH&)h`hz5KQNS{rIkp zO%l4$RHMNrw)R?dUrEfQ1voJVym2S00&IKa>FcjF*aAvp|1O)$Fq9jL(VL z{i%4mXYLrvI+Mr~CQO&)0h=$#Q)ZaxVK&`Y#4>paxzR9DVhE7otegVkG9xb^+-}@o z^d)8w!V<^t$EqxT0X28awTE*Wg-V$*cl?Xe)J(%En#HM<;5~ZgXOhg|AL&EX&q zDsk+234`FjmL^QmT*E?ZDz~_y&F`)|E$KbNyu``gFa|&YQ!SEx?SGF>NJ+_WK6JjK zUSfhR77Wzwf3$6M1^b^-G0x%Nt<=lGi-gL)Zi(DaVW<=$FB)O@gU7h-q}D2lTQ)?= z^LtkM5g-hVJ2kTHH-p@2lvo}R`~#CeJcUd<--)ws@c$o7{$JwkzZ?huO`IhqNn7EF zVh;Q4uWSvh@@8;b_xC3%;Zn$A|AJxlni1DV$!ugrRE{N#Zm?tLw6tuXr+SzHMU#-| z1nl%BNvjYc5efa6C8iI>F-6dBvELa19^g2y!hsABtgt=G_~N+Fxn_Gp^znX#m&G+? z7h^a@=XM+0k&vlv#Ltd~wpX?k&u|l)p2p@~{uybs#$5hqAA&;D?6|O(D&W}2(T;lv zYYIEl(u7tF5i8(6yw>HraqdD3vHOOz)peo%=5S@(!ecnd8Mv;Y z)-tYrxk$_&9HKwq!OKkQmX*`E$HOCrEMGJaq*WX53>nj3CohS;JGoYL{p}g-A*WZ( z%=AzZZ`*uEt`oty5G!s>jr1J7rNz^*YE!nmR~=e1H>H)!K|A*BH1Xl}wOC;h7*I@0X#PxXjIWI4&Z`XfeBq zA0;a$D~EhyTBd7_Ukbku{^dR|*`nI3$w1+m;)u)QWQBpQTGZY zO1$FArqMil_(1UyL`uYh>YKaK>tXaIwvsvUAVA#$HtFo$f5x;P=C(HS@{W7AHWM>1 zh&5(}T6c4@fV5|swW33))!e6t3mGtUJ>%#WannN{w?M9##?HiFbt~>wBWJxIwd}gj zI|ZDhwnnqVN9XYnw&mO0u7PTcv{qOIeCw98Qi%^8nq<>Qts_xFOspXGYvayV1=4ut zJy@hV%#$!4trczMD*S`gy<(z!e1m9C6|EA;Qg)Ms-N`IK6?!AFRd)J5?sYv19@{1d zcO!QnKWn(p!>MaxULxldWKLbZ&2WsA*^_q} zA2jfi(%T2puf38lh`Y7dk0bx#`0ipK1dsU6e>eSq8Fc>N5sUvZ==>MUm0r-UKSZBg zRh*_B<)=y0vW=rN1BIbL!9smU$T;$~?WtV#B|t=o41@)5MGlY-;@`UrTCM|s8Kc_o zwNzyMg zfpKacHE9?G;~`@ZV`;^nQGgtV#x;^riP@_i^a*4aCZ^1eC{zZq`ih-4hEC`T(whK< zZqXRaS5#ZVwr4O+=!)L^i`oOhGFymgnnXQt2Rw*wNur$68@U$+Od6S1xE8lp8cMa) zifk_hx$>5_<#FqxCK*yG#Ouxz z7YZwKQ5&PqyS2{Jfw*nC^?a$TG{{m=cNfC7dPa~dLWKxKoRNfubtD&*O2e_-)wQVD zSfg@#J#s{xm%bOoU_3|{;BPW%C%Iijt{Kb-NSJb+n#!_cU$ zh(_`Dg~#rr_>ZeQfcL6^EhBY=?{F`51uwvZ35Y28)l=8)75A01GDCt-8Z5$8%#LWQ zMsP1vRqB%5uh1EL==>Jw)9@7jEwHqbaX|s&Ax%=Tvi{wR9!x;=hUMUs%iksLosZUo zpn-t!k;q?<@`A+bRXU2+h`?x*Lj8lvUytfyS$+8PibMSwODTus1*F$jv7I6AEo;oX zre1*X70vlkyzp<}qL0|wH^V&!n9tzFHj-z+&NcNrXd(7D1h}N&& zl`e3^xKLunDBKjxi2zceEK-tMqFNFKWl7Ns!CWE$F@PvEAiBsE3>s=fy|^MCk|nHm zrjS(jPKqDQTNH+K1(*s8Ju5L^s%#`7nC!GX5tt-FvrMU&`j2W6J3_vcbzN5$`R0&! zzSJdJ8K@kxyI*3F6doE?sZ>_3>RF|fj)HL$wbS65&CXl|1fjZrE`ATJ4Ojy5g~$z+ z@1O=$IFh#D4FeDZf=De~?>SJiD-y3S(DG=!9;iCD2qT6Nm;V=#Iy>gK*=zyT@`e!Uss>gcN7{(ehxc~@s+1P`ZergL<&C(LgbOB5+=8Ir8M%WG zc8>G`*AvVNHjj)ebc5y_#fQWjv;*NQ>kL+aR4IN#?>mVFb%%^Ad_w`G(9vP15RhwX0%#ZK~q)HB5nWkSRmv{M7*{3uil zCB){tNe{Mw9$p69<`Qi!u>k|6z;G#07ShTKE7DD}~T&NrF7()E0TF65c zmcjgcEpRU0e}ju8!sN%VJ!}nSWd&wq=c^7k@O#QS*)(RW3xL##gg%~z>Idr7hSg94<8mIIr#wHZ*X&Fwvg#L z8q4D=)x3WwhJZ)+M-(ob#Y(79L9rdU0tK}rHjDGxi4bbY23^aLY&zh1M@aZ8E1AXh z0O}xKUo0;ZHl5wQ4@wG!AhMX889p7Vf!#G8b6a0{)qmr|9|egX8x7qBZ(2Gx3}$f$ zp$J?7_Ta*w0`}hCG(&X7_3Zmxqi zKVK=^1$vaMXeEVFSxB*K#Fx($104;je`<_w*Zlx(I$NMbqBK#9+x3DHuu^7{{9ZF8 znx7HisRL)?ZN6(&3uFddU}s1%$WnZWQ2_YuPQOBdSo+ej$K@bc2k>LzsA;TiF-xEM ziE5Oo@bbg>04u1WPI5)Hp9rzuS{>oD{QkIij(Q3*TQETqa{?T=nFJ9dNB~2KvyeXX3%{wp9V~qsX91?iOd!5$vB&lH*$042)9%O z0Rv@v3%~}rIUng5&uJQvnowOZFqYaAVc?HuaPPJo+KXprFQjYEl=DTL8VPNPMm8}z zNkfIN$p}i3gBX#|2iJ=Vdklz?+zJ1)A9Q&{mx=lWxYFfKF4%yEjgT@$OU%#98nVY3 z%u*ja<3uUIdoBf|#bNQ8dhm}AYxUISD+m|*9Bm~FO67n#oYM%pkLBSVg5I&VM^)X&}bAfA@0cF^`QBAgE$k}X0AbE6m}CjRdSg3C6}HtEjwWnz^AT@|J0)fOcw~I0dvc3z<-RrSPRynA=^)Z zKtQ(a&@QWHHWWf3D_3Xq=&tL0MFf0)})&yY58SKP#bxp;Jd)+(|WY6c9M= z5lXB+(RGS}0UNws1xJ(g*%TWd%-hO{vA3;AF)d32Ul2?6kqOaic(OG)j&O`dO?teRK zt>5l8XEuC=vWUA@g3|6I>@dI(;C{}#Di@Hl(JYns=``}XClg*q^TO&Yg8bl%zd;6t)rJp&_yt<0VkE~VXCpXP zik(wq?f?su%Munta4+f^zXxXxTQYsDnDx`TBD9CSxW$n(eZ^wewLb*n5DUCI4ZH|- zHq)^GCOxivHoggq+~qcw-&)L|_rmjpbDtc{0rk*c?&!w>Lcp|dOm6Y({7gG#8zjHZ?2QREe9WnA+mlvR0k&HLJUcMSlgMD zkz+9l?5v4QLH;llGAW<}+5%m(T40bYqRjiBVQmh>`DXPHI=AyQs}b>1`n`_U z)`#17OB8ZWs8IlKqf7wSk_^$$JD9l|11BGIt;co#gb|!_lmfAYgm4pH?b3zDcNO3+ zzr6dC;8d48{P*mvBiy**GYA{{17=E+=r!o)5D$56m}5M%pIoDCZUT?I?`)B<{IhTj zq9DVmeg+kv*PSxvJyTes~NFZpd9E6<>Y0uge`6S2X5(i zM%VjrDF255OZ~z%7*Z^7Ap&qLFJ>9ALPjv%T&*Z}lZ25Nx(p)Wre7{W;%`B^Ng$OS z^~4lV${eCx@R7I}eTXbc)7hU~1PEj?{dvX+3+S_k+!!~Agh@Tngainy_opBhjVX6^ zC7u^$Y~f~`7=k#3Yb(IKan?`wg|mqD3|7S@C0$zbJMtXpe!@ae=07(1@dQJffU@(Z zr+^-`L23o$Y0wpc7-qr;8}~#nsdz-a8I##X4OLDz=qS>&ewL3_8ct}T(NrRMz#N=yUQ8teFXaY%~NFY)=Dc@GDZSi&M4AN6S!D@&R%Y znnl;F`=jN9HQo#irh}GScQ4!Mvm7pKKj^Gk2TEA88cjcD;5_L3ut3BaAp8cz23KY< zgIp;IHWKqgc*dzkxh_HVA|J|SKAf-7kRf?Pz0hEkAE)oLaSzCpb0iIs3JP%?9{w3* zw`?Vh-~CxXvjE9mb`aU-LIJTbhPg0?o3kpfDtgSMRoO0a{j3ynw@$YHW?zDHULZLJ5NS5b(SPBCz>@An$@mntZL@@Jz)$o z2Ri&3aYKzz&G&?Sd(fB6{6H? zhO6WHyJIR6RnZpcrRu^YLk-{6DY3RXpgFMhH6jVixhxiKTSf-Gr8=z!n0-+N$Tm`N z9QjEZQ3f`7E0~@I_7xRzYIFm?JCI%+(3Paet;NPK7g!ggPl|tHP3K3NDh@Tco7*NwVYW1Ns}Cp`vZMa9`RzK zn>a{>=oA0uh(R;o)<#UCwOIja>p%nX;s+y=c-S}$>I?Lckze00z=z?rjAx((H8V92OV85?{YH zzwyTSQiGW=7AQ< zIww+s4ZUbp@*i3YH!DRXV%x5RZ;MfUI|^S>OyAPRTK7>H8n64^qrIt(=25L6weVTu zCkmR(R#)Y(v^13Lud0EuPR*H6Gmvd}Vdixa-Sci^6ME@&+f&c<6faDbQK`h(v%L|S zaWF}jfMjDGVCmWr(2qZ9lUj#peqy&?c@7j)m9*Y6W38GO=V5M@XI6NrO0ui6Hi>r| z+ue# zAd?#&j=1Dy=;0WSjY2StTahxr>2Yn6*&KEO4IR6lxE_bOi4k=*W`Kg0g}YGtVO5MG z?Jy#6#CVpO0W~H{UE#CEm3zNm&V1~!XOEf@ejOHy7cVgEE(auxMdgHR^$@kXlq0W?%qy>ht{>xFaRu7Yrf4K73|L8XWqR9eOdd+SJ)8%jzFz0 zvNE9Zr=88ZF%o7g85IxUa2l2o6?_9+=T0|?>NW9-C(s{Bu>oGN`h!as$%5^1CKTw^5<3rGKXc$C_VozFc?{XOp^ud%^&!rnx-YSi@q! z?!au_3mlN?*kSt1VW~6gJZ0E&-i%we$z5K9lO6hpoN}GO) zsgXG8igv{mnb_|1;!@9*@U4}Q!4K4aVu4RggeN$omZ73e~ zierl_N{sBf5$HJPixn3Keh@6Hrb z<_5#EK*?m9(ptYB=T@{(Q@h)OD$EvsyIJYX&?{b-Xl~TIi(W_@tIsXcR7qn$XPu?+ zh&hy>snlh`s6?*--U}+(bdahCvnt&;1p{jU?tE7ki#T`4Hi4Gh;*0pIonflBs`|}> zhSJaFe9@s*#K%W@Bkk@eA**Owb~&Y6QWedLq)qc@c&vs5lBkbRE354>X|UzP}*5P-4;j6Ag)}#JTuu17m_}4iW7kY&K7Njx!b&-vWaVP zPpIY1@nR>`Zcipc&1uopNY8TS%%N^F#PZ$q;!hO515wj3p|pk-y5r>CN_CiOE9N@& ziE@e|PZEwg{cu-*5Q`VtTeNIN4Yq3Q)21BcVoj54cA1RPqyCO-L8 zX_f)wJ{gV9*J5HCA>gra5$;8US9B3g2kx{wzZVsk-bsfaW$`5XS=MUeBORiq=^#j( zm>!_0Ca^7vw1m5-=6c+^(*KbPKzY?#!vP!y84@57l`rF(pXOH&@{qELYh95o6%~Z8 zunilDTQxq0pMH8K&Iro#^-Oz9H)uEeJdZpPBw>t-ITs#3h8gPU^ zo;OhT1eGqSY0GpLmE()Z;r_Fjq4(q@VoqPKzFIpuep+K&jjHCdSbnl-q*?5B%KN=2Xwb?0HSw)PFUI(QvaJ~HP%swq zS85;CYS&=rDq5SQE^!-0pMqA9SV5sOhzMN>_N9vgllYVI(iaJ}gu<{3yU$3Us_9+P za8!HvJfOMXqWrGoE#C;b9evWAPTQ_}IfZUZym%FEtqaBRhwdV`^ger~#LY3Zvkp|C z{zBS=QyPSRm# zc&pe+m+>VB$_pBwFhhvQp{A%JXb~^}5ZPWbrLokn#VUKq3_1@B0w6EWIK|G^P+dE! z`NEp@E#x0XT-|-ilpMtQ=11-I@chqYYv(mIJ?Pu-BoZB*9?3b?c+$bnvM0d-NQ0oR zzZ4@;R{>JPE8f{ly15dGvupNiq*Eo>yb*4fZt|CVrKa8%V=`wky96QjaZ9>mSGFIO zI-RZGD-H1jh#8i%YM{%PYC>%0t}J6Ut2jVHi;QKB0%`T!nkB1!zXThm>P`80_8Qs| z!`VWj5Yt5WSpQ>%VxOn5Earcf6F5O`_zN{!0q(fT9ZS`FEd|bW60-taq-T*7C$_syP-ic_V+KQrbOezoM=N9)89GmYI zq`@n-f)(?RfLQ9s{V0kgc~e|TIS3K=C5|1o=rUbkk2ehiui8?qc5`)}QK}=_&|EVs zwETKAhs`bK{<$Q|;8og$p*INPoC3xWn6ksQ!HmBB$N367h?i=ar(XQVJ_nLJSH=3K zk$jd7mLg7|MXR}v zrBBwiztx82Z-w9{dWT6stQsWEW2O2^ENJBKb~dxes<2K!9}&1TfxogiF& zU!;~Z=Ur3|m3Kz1KQ+HL5ugpVE)9XrS!P+0s;hJ^K-+9M#0J{tA^#*hdUkLH`eFhJ4VTTb zU>I}KPZ0+4Lmc`0LvT<`(*^U(Dc_K1+U6Q;5i?v3>ZBg*28h8=5N_C=V8)3EZp=x1 zkCs=5Xk;00u*pfh%9_pWck=)CJ>>d&DXj=887F|WbHFMId%#I^>E5e#8Q@=gv4+5W zJCAlUckHX-*{YZgR&?28x7;XkqKHy=pf-`I7rURQ<7Zd&SV6^-V#Lj;(>Y>g9o@av zE7!8=;r84}StrMQB;a@-)`fF!jgn9Sd>DXeb;Q_ z{!w2)H=FtQ)i`;Kvf30H0|$G$y-|VCw;64r)c*FK4_0KqkD$|4USPW~MXPGJY8gr* zUq{NB``nG{88YWD`iRtN-tu))d(HNU%CP3kDSFgC{%153c_xW3pMxTG1y2VqF!cFA zhodVJC2JB}ESu$FMCb4MA;C4bn|;CpMFHAjbI^f9k)IWuze$SZd6%*yT=$S$&M@ZR zFycDBp{w+yGQ!p$$NTKoX|Rd3VFF8R#P8)Rdob&7^ODpJcqmMIqTjRguwRPa4%L;q zdD~c}t^bQx9e}|MXQ1#+Q{YW?)IKk6v%$${yP=tY%()&&D2~Ub!PQxao8We$jtl1p zgZ-ZrK;2IFh|?K^ko6~wW;e>}nO^Z@g;`=&p0|^$=}kBUlp64E8PCdu&$3_B>IQHtE0|W9U3ehSBERuZZmmX1SkY>|VXy7TSn9RDVLr-Ecnja-%lk%>HSIReX^VAC zm*9$s5_3&VIqr1Gd%%WTY~E=XQtIuI*oom(5yDxIN?5Ti=~vx8AsZ7!JWgR7((GOG zkFY%d2&?lSVQG~5=#f|9f!nd6W6xXwK~YdslWs}!-)=da4z`}2k~o|;SJyF!>xkM9qdI zy89s=`C|S&h8&t`IR@+N5&R4T5j$2A%pVo~?{P=G3XF2Ya31s5PC zX?Q;izUCdjtZ0KrJcGs8SdvGq693(@8dvL$pH0ubIY@nKYWlF3cv~l^d*K_g4T#{I zFoE2@NWi=LiRUIvj3figOC=D}-riUW;(NqR9d~4KUXxF?L+@2J;D42M$bXtdN}Bj4 za77KXAm^VoW7l?Nil==;C-?@kt{nf`NEnTNGv)_HOTY8D&u%P}$#j(4QzV_8ZQa*`>gu`XKmmoe;cK zvWB?>1v$WOC&Ju0_g8xz?VQ*2NC97FO4Eo1kIUD>FPcbJe&SO)fIuVvQ14jSK$>&s zSKqEbP|L4X80wBs)f|YD&FDBk{X(aTgl?+_<3~|~cg5_Dtw97sQ-4w;O;%7-6P5Z$ z9tjs73iuiZO295Z!^hbXJ}yP56YJkA$M*wR4{sY%L3}VUYNAyYU^mN= z>h4Jnx4VcWt=XmTzY!(jM>pqlGIz@$C7$n}xpBh2_j<2M85Vv1?=d~OE=Bq)dtjeqm|q`{)Z3*V~hM~$Ky5uiMI zlkX%#gkoV_EzwfCqp(&NdlKeI=cIUtuwxmkK{PA_t zv?K#elN1t5ofV0;KUmAVM<%K@{{lk$b5>(Qh14OvCYHJDCm?NBi{T#a8~H(rqvZ0g zMZ0tqH+l|CBbi4w5wK!yf4-v@FL}r4)$~}&FfEr=i;-$}va0*xY&z>h=GD_|{|r!{ z=@>}|uj=pLuYBI-AE9S^AD}6N6>jrJB(I+-d!pt=Nj1%W6>`K|8bg4aIAi%<{#GrtLy!Nu_^nk5dWyN zjbPEGs?Z^evh96h*gRjOT?u)V|;-X2!D73HEqjf+ph);@0QJa9{WP}QHqUku^Y={&Gi zej?s=Mi|->wS?&mO0sA_V7!cps+knu{#~n#_KK2gfQ@LNvt4tX&B@z_OEGCXG2L@Y zXwZIepfqyvznd7kpnoGD`wQ*AteD~Z+BaskAC$Bj{HgO`qT2$=9`8T* zN+y~n3NCNV-k&HM#^y~yWlQ#o9Z>sluIrI<$-NqMPzs=D3r znfKgTjGyEzHLlJCQiT)rI+O-FJx4Tl_}@9L@P{8{X$d!v9cf-IWz11*S*tPKG#J}Z z0zmHJ>euw&NkXdI-2U%I4=E;7f+^s@)-qWn+karbJDFOM`;Y<1eQ0Rt!4o6TcNL+} zIupWSvNN@S_|tPV^w~i_F?u{#d`iw1gjLQ0$;t=MzZw13V%`{W5sODdKR)mhB^?Q) z3i?YU+{=DCr1p`z^K^B^C~^N-b)U^{M8pf!VkmH#;ZfnZymXv*rJe`l4s44n0lgIA znX_68ZYt6-hmbAGGDmdBfuCbdmuv_6MUyT%UzXKWQdJh!6cGPoEd|2Nr(F*9mm@EK zi=t$6ujoJpzjTsTUVPQgXeTR}Qbyn?R(`P47w;-Hp zycM~4^>~u zRkE%0HmzZtCcwoqI2gpn+&ICYM~h_5<1@0*)4(~kVkp)}CkwSgWSd4W5*NUCm0W_& z-!(KR`NWHi{8(gek&^WV8l(nZqxyM2GmU|u{jhB;g-7FU-e49{d&KF|(@6I5tHOjv z%>dXo!QFEDTIgltF18hcNs(kdQGc8b0wA0g0S)15Hnd~x5O7z;xlzgnZnD=%><|q~ z`Wi+iNh6}mJ;T@{Yf*zpPYzQS7zjhJ@A{p14RZYva6LLKAtA4QKD!(b|b$O-EuP8Sy|BQb!e}OiSp4@A0o8{lsHRA zY#a;*!qBE@P-e!El2ZGN+wENO6!kj3PNzhsnt)sbmst9HW3X6cgG4+~MO*BhIb7@_12DwL1IWzif!>+5SDke?|`r?=D}GJc0_669=p8_kxKAhZeS zwA~NoXOwItoh#a5!0a-Goug1_*BH>H>NmANMv1BnZ|>NE))nYp(MD!p0ydyWPR??vjD%xx1MMelt2*+pe&ZlfZ znld62ZEawQ;z*Ck`f(=6YRhz5zc*gGMlcRgqYryl_gX5e-h zQ@0#pzY_%Ic`Aob+v_PN0YKcVp;J?nw|A%Rcq&UvAyHoP7+n`>`(&ImopH?UZ??Na zx7k{z|D47k;fSs}YfWw;>stzGasJ&>MM2QL6s*Ffb_dEBO*X7)tA1h)K%_2&QN;70 zgslgG?Bg9(YAHZi?2bWqB~o6#kmD6@SmMJ2FrrK(DMpc3=#{v|!%nxi9g@2KGEclK zRRq|o<#Le52u4eb%z+rCLm?QJuzFxaHJ4im5w0O`#{S_1!Rb09n6UXY=At5uX zt_?M&T}qu5wf#FiLyNga-?(909xIGrS%G^DP+^uZGD&R;FI2=A72+RMrm)Shsg+DwcRMY`TGDU)VW{N&m+>|#*Q63cCOYi}8Ta-wxUn+2u4`+@wixCJ zA`p;4B^a7SDD`ZNnor*5vc|JH6PAxUaDPA_)C5+spX_z=v z$m5oPjw0Eyn8_;=e|vcvI7e_JUz!yAgL^ujA?WQj`2%D`z+hAW`ZXx|<5#TDTD%X$ z-L&T2w9sESX>a5Mz1jl|;lHBN-p~grns?)b-5c>f(04SnuSu~!tMPi^uZzha*qGaz zZ3rhn-e7cWlM|i^yZvkq4l^R(CX?U(#%>!X+D6S#1lcqkGz)u+2l7)nmXLMB-nF0N z)0;AE4v#<0gW?i^@ehQ+d8VHC-$bJhi^F*?^bEs!ZuC&VdCv8ezg~As>t*h=Z1iBjdye*`oT5e7+&O=rSMI%aszuyehV$(25nu%b`O(08&iAN5RI>x3 zh-#L4oPu>9A-aC=EW>}0fOZ?~5a7JXf_@G3*kZj{gLWJ3t(<)iil8gF1$=x`a=t+9NqYYjrcKB42Qg(u^}Tr+NzHpEREtv#vlbbi!Bq zCCvGm@XbrL3#vb@n%uPgzsmzrV*8*=dOqPl+lef3A4a=ZU6V?GDJkMeL{DLaITy#N z!nRDv^x`F-=6&^u_LTX|`Q(|n=1j%%N3OIWxCcH&46LfZ{6Y_UtOaZ$P2Ch{B1!(r z3xaWyFK7g&tWLqDrKsj-FH7MQxsq*iyF4VVPT5o0Si`r+$!*~y1ywl0--A3@5#G?w za;%vc4vX{%vkVg{(zOp=Nf~hr%W}UQZL&w{zW%0xpq-Bx@VjI19mGH_xfIP`Pe$ps z#u{zx6nR@!jg4zc8RcB3X6|iDm#M2FK@{@Jvj!!&aAk_T(a%B9x-;*OXRr7Di!nyJ zN9u6;@`xCRoHf@&2|71R z+U3|7%7X`=UsS+%&~R!7VhezYRPt_w3#Lv&77rcx=0%almBy4kAAq;7>)l^Ng^cv! ziS+sY#4tBq7xr)JEDW(Gi2NeNLU4Ls{pr~ulqc)jvH!}cZ$GNej{s3{F+NPx%V{-X z6KO=-DBOIrPn(husF-EEAUwrDVKc%m6Abt=68VGI?3%EBqCf^MgN(PAWhDG^A7~eH zwOR&o)C7^dj+MJGbtobLs__REMJ>#9Of){!kxTN7R)Oo5-SM)wZdDF-(m9xPZ7QC1 z-EG|B6bs)$zPNWnNsepKq8H~jm{}U`_nW87Z{Ds{Y`=yzdOxugp@ItZsJB42Gt{Nh zm^|dcnh(qfYu+jF1r^63 zMjL%IR903766=6$=idiS!TwM1#vwag@qePsfDSuF{2nO-TB6n4_%h)k_>f+?g)8W1 zsM{kQ!Rv8iH^(IqVw*u%3nCu^!Pgh(rRgbL^b0RGcba361k_8yNAARTwsKHnWc{5g z;@F$63Ipgu9Gf=f+Sc8_Ss-{ukk+$|Bdwv*%y7htSA!FVtq@~Ho2ZPdtg%;($4NY_ z!4Fz4?UZaP$T_Uo3dd9}?Yhruiz+lga3Lw1Yj|)8f^3KV=3L}X9pfHaCEnN(P6UYP z*R{~&>KGRVkTr+xck> zNw#xrh3v_;^GRphJL~Gt<@-~KZmYpKY#(LVr9+>Up6}1@AjUhgu;$NbFsts6(-+Xz z$tSc^@ZX{xXnXAE^nr7&NClbInGrLr zB~ZZDT0L{AXcsZ{u^JmdyXGC1+14q`x>*UqOPATr!#=9iwjM9_ z<{a0rytcd6%X+7Xx&OijKibyb`-JvC>7|Z+A?I9b#Y1~J27KT-4~4J^I$FSuL!1@& z5+TzwNkk*#;T7T#M1tKX_Jt7kTR6}AFlVv_cRvVqw^%d?qPO)>-F*4AkCFG5(03&aj4Qg9 zFmGAg7Q72}fIx?C^uHHfk+Q#nEfb|uFV*$J;yIBx-G#~ zotzuq68^AOFWx0IT3`j{J#G{e9Js_F5(jx8F2(NALk$&Pk*l@cAnvW_ZNM9{Zq*}! z(}N)1_*z=&@{`uIg*8t|#P)ImQ@Xkz3&gYninK(JjHCpU9miM(3mdz{Fx6lf8Gg9b zV{EkZc|S1H3~C(n#9zqVB27Uvwx1Aw(EN}K(&`5Ot+^NcHvxFIE5WHLfqd{PMXbjK zYVTZvM79@mno;*Qif4FVZ%OFp(0*EU_bpa(1(RH{TW}IU;?Q^jp4ncxb{?ELoyOHK zQV0(?Mid@6MmPn;lb{^Rm6scD2l~X;mtqeJSiUa-dS{d|I2iawIMs{1Wt?`e4kP}@ zyHR1(ryWY;G&$E3*ABO+acw6i1Y1gE^Ovv8pOn~B=W}GPY0SisNFzLTRg&QoC|GG3 z6@vYREA;)g?Tt8Wyq!yVE%I&aktGeJV(nD(1Up)Mu-kiJCL>RdLzdN#jj+)G)}B#VsLH07NnB| z_v5Z2?aT7_YaV6kRg_2;4tX*@8EMlM9;DHdCkxu5^~_j};gP-K4=Rk$en`up+MN-* z)y|3reI|;w9@N@zs=Em92pUy5ru8WiT+X`sF4LX0_MNq=N9S!_8t^2&3I)<7V`NrFe>5;|A_`$}Q*W4C6r=EpWX|;ZW8aDet z&HqKVTNkLqZA$2ep=ij~HsFyo?$nPkU<7q`hCH7{Tz3gpaqVH0Bt+A`pA8U!Ut@^Z z?!qbDQ=MT9$Um+LwfG_l>=Z!l{{CBp@x(b5QX9Wx4waQ0%N3isfu)Gy zx8Jf0r9pj{rU7vk+A_-tMOZ5o)%BrR?G*zG<|Qw)wS zb*-3h2wQ_A?Yj)H?dJ?L@`9~{v74|gR!kBN{=FG1&<*_&4onIOkM|Ua_@=-m1=ox9 zWA(2m5;Ssvgjwm6Xj0yt=8^#Bg9WBG5q#R5^yMKCFx9#Qinh)~-wC+@%rZ(4QM^97 zzUo<#@33#D&>+|YOs#i}Hxbl^Hd7L?7x{?_lZXe~Mr()jMzaiG$b(YVT5uKuFEZQl z<#F(#vt)8!H6srf{h#52RZdtd2H+Gt)CY23=26TbSljEvr#9>9RsH%7>QKA!>E1!5 zfl0XUtp{c(LHEx?Wk6g`ThbzL{TSN;F)Qr#C%X#L*u950=#mecBuouIzOJVib z39jvUV$8;_E^MS<5lF~yAUfnIb6rio9>QnlH-0swnW(=dJg(6Wxo6%=V&g?&4g}Y) zh{^B*+0lIEk>ghg&LDu~qkG@!6ZQPT9{jv*EwC^`1Gsmp zd)o1gkAd-R7S=_i-2L=ZiMGNN5bJr(1;2z6PZt%w0(a!wgh}PTgmwZyeej1_H1zxYn)yu5FdOgCBE*_F?$HUhWI=CAe@Fku%8SNlD6o|1%_VuVP3pS z+>p~UKWu<7TV%Zb)bEy{dzCRHDl~<&n&TnD3sOcXLz&Bn^+sNua?xYq=bSnru)--t z4~u#2kodyD`Ky z;`HS+eA52CB~fWankrA{@b(;0+-YCLHE_YDzy!C+C6*RJc?N?_PjnswM!S*bcS!R5FcTCfRDxeZVfeTx3fZY1u5Xy@>wzp7{1Q8)bz>j&w_&@d@`+ z?=1a(vc*T^!JlaW$EdfpK6=oh(ogP1=RiGP9LJTukYbQ?k0Ig!Yq?QR;6hk3A^o}e zdN1USD-L^o9T)W4l=MN5LaEV>$qDiNyC@BT?(|;AmH4AhuyBY!;%)FtUH?m1jPGJS zyF?_M+hv*LJ!;9PvMtag6-j~i{MV=KhW zc0R&>7Ce+pFTM&wAuYtrZe9YxHyA4*wd=6jFEZ!vXC{iMi-$c6rvpPD5!&Gt_Q&df zl5Y7vkVsq$gJ_ZdMO$KTl=Z*2K+)Et=v|4IBI1LDp30R(+D_2-lmzI+fw4=1=t;Zd zpk(4C+*E=$Js4U+cHi{5b^`Erf>;WlnIsrZ7&7lWYp*)hh*X69+4*OdA(tDwWF#0N zy9{E71T}%op-C|d5TD!$G9A4B4`cTj99j6M4LF#IZD(TJ*2GRGwr#7EOggrWiEZ1S zWMbR4waNZ#_x-l@_J^zQK0a05)z8uMGyBoQHQ~!c+N^ph@BfWy1F;>T?(}{aqYrrN zK7f1zq_BK=ZJ(ZffcN`0n<6-4Ea17@1T2WWwnA0Lf-%m6jJxGbbIx>vLQi0Ta)v|l zgMawfDLB$d=r0&+do@oSh=2)5>SFhMEkre!b#UwUn!p@E)CFIKu#$GwvaIWEP#bBd8u^h|pD`}3TE72K z9KW@#!UWj8p`{F#w$;4>9!OsG?UB_o{(SXWmGy#aDL*blK5h#On4gy3Jz}2b-c9Sp z+6WGxYPq@~zz1^pnn~NZWe@@thTs z#pKk#s6PSzsS7^=5cb#YI=d83d>F8Ny0qY<|MCP}TS#|LL)~1NtK%c=^X7|ZrgM6+ zGi%wH_$5aEAeGI3MHVT}v<(60jmRCz8 zN|w@IXSfCjYb6YsY>m*7H+Y~5hzF}65$xC=T)U3O$X6V4Ui6JjC<3;11DGJ8ndP|D9H zOSx>%V2xcE%m$Y5-uUuk)7U;*rFSz7i>=&^&=R*IM=eT1L)UO7^ikaA+P;}0{nu0d zRz0pI7*UE|(a1N|*{WVoH{4i{EHluA9>iBX!wWNo( z6vaiq&t-)E!nfL?qV;#(|MsLjw52P)5^B;?aLc=C?48gGJoS+!RKx{Hti5Xvug}va z6OUykNkEf03jBq%d!eD!6Kni#V=lE~W+)1@?qUpe>#bZQ6V5s-)i8*r75FFfG-ld@ zqQO6@{=mMNi1Nf~6AiJ(Z`*Hw>t8TK39|H@>p#%$ZVzJ1kqq{pO`3nXLFASKIza?u zBjm;nv&+2O6%c{%{*qFrf39>rBvcbWEPyCXx=016_KVpvCyy8{a(HQ$aQ!Uac_DJJ ziXYcRw2m652dWh$OWOsN$+o-C5kVY^xoecyLG0*$ALZ8#0cU z5gyEka(#WIt}Qa08Mw4V_)&INh2e#lv9(7;?C^1O$Rcx4{bnMk^tue> zguGkY(oW;sH9b#AbtIigxgX)kv;7lN0wJ97+fKHa!|OH*({m|6qz>TpsPHY^_B9gU z@5kJKndcHFUPm-SJ6q8m&Z+J&d&DikE{UEy_{?En!hzrgX!I^WlxwH=K1QOUh>i7k zXexr^EpD*vLZX$3&oh1!n>b+zTLN<^FfMSF(NNk&OwCC@E4~3BlhXE-AV( zAs>~yvHg6%V^u0*X^Twz`}rrYW8RAs3V_GBb;Be##e$?2!}~%QBWQyOZY3h|BUm%O ze0M5#=-Iays-;xNq3?D{qdIVkrVx#MB0#`&7wsvw7ZOCfwOLhT3@W_ZrVNy3;ZgJ3FLIZt-6p9(6KIizj**jMJ}S(QTS;V{ zmLK^co#1L5>4>|OQ%{keh+v#P9gC;%dpBe{6iA9@)?p*@Y{OkKvgQ`qm$8qTl_tP=gw=WH}zC80cC=ME@j6f zy#!uUHJB8U)RFDPp%ksuznU}yw9=_#=f9*D84D8DDtLR&RWNF=MwL&I_bgO%c>7GL zCu@fiFc-B=n6z@*hqDxuss~1y@8fDSDin1MaTC$4+iK&^RCG;)6I5vP%T0$8Tu$3- z{Z*)Omrh2>?~`f+eR8Z#x|AAgCKK^bqetcL1x%7jsoKaymq^H{@;HmOI;HdykN>n;;SCs%49%@ek2jF|r zSqupR9)Ke6v!~!|%*n1qI~13_i%`i?0o3?JU$R1~56RQqSB{!=sn6=BtTkPh(%!!s zDE3P%w`WR8uDIqBn-wFaS98fpbrsh_t4g!_aoCt@bnnPJ^PW+BD)Z$UQe$B*h z&qk0oEt8jYEVGy7E%P7IH;7E@Hz-eoTOQ;?&Yk9KST5ub&7Dhr-XNVHXc?V}yI2;9Ya`eKer z()ZU8*_&(!!x7Z6+t*bAM zt-UXyt;(UxVxOHpM1ONRYBh2vm~9EbA(UxrFM_=Wp+>ZWp*zJB?1pB#TU<|vkyK3ssfiC z1@FBNf1YD6l8=WvH%hY~0afp#50TGS8v=8auW`>U8lm)hwlt{1Roc8lJ8acx*r>OfDd0h(2u65S--Vd z40}#yu+S(~(Cj>yocKK1A1e-8`XPBf`pqOXjB`^=m(_X7`bl|Cn-1cxn~+hJ{z~Ex z-O5oJ-E~m}{_s&*{(qzFz=zmSI142GrDPF)S$S@P|3!V2xPbsvJb`6f`FE>nI&MyC zS~}(?C7sSN#|3DX?b2(W>=J0E@AA~Uj*v90#EDzr$6YMc#uZs+#)a2Uj0pUzjnDqq zN-j{~BEO!uM|!c~Nt!+DNuE7*EEOe=bL~Jd7sVMnNXm#z7{Dn;4fHDQ8g;DT!SiDT|#KDeWPFo6Rhn zo}g4ND@Qd&AfZt%E2&Y+mr^U~MQKuYFEL7Bqd5woRB_Vi1|i)gNhPEK|{Dc{sm zTDi@9OxeqlM#;;nO!;DZJ|AIbzHmLSLOL_QLf%JkCE+=zk?juIM%=Qpk%CQ+Cx%;@ zC*ir?mGh44OyXGS%=}pMO#N8y%=j2^_RF%xmHUqEOvbXpmH#eDHS0OamFZ6BOzD`R zp{%59s-feo>LO^zG3XsIE;KgARat~NuTZXiFuuIUMcs)ZUFRFJuJE^xkW3Xtd?<#y#f6;oj zKD#)QxA>6oRee!=MmgI!I%)XGx0~sdMdY%0W-3Ymj8GNnxh&6|WJo=q$caA>$!%=q++ zd1L!5A$gakuVwD*iyUF+#_+JTTVo}Zl)GqRvg1)gS|m;-MuJF@G?_RXyMgbKW->3= z#yXSWrMH?GS9|$|ku;g**Ln#_@jfL*nCAIO<>X`e*6 z_JmhLNs*Y9ZuWTN=oSaq4W2*n$y}4Dt>YQ7-;ar!Sdrw&xp2NGe#>x+`7^=qE#ta+XWU zM%QL8q>PS}D>+_MK69AsXC;BtHu>)ZjOk4Jm<5J7!c>oDB}xiA^{m?Hp`!N8zL39M z84+$#)x1E?sefx?gS80Omi?%e2=_m{h94P{CG8yt>u&yR-kp&W+}^%owL-Gix*~#_rtn|!ggzr*dN^VRMz3Xw=t!-cvg1+2e5WQy@xVzisEthZ=U&R|litN&R zBQTBM&X~(6WWz0-2*4uC6XH@|J5lz3h%I^@njrW=U47HL7JXf zH;k|;aF}89lnfL(HF(#nAgIlfXAfLYsuu6AhRd+Td9V!KjpG-T1>dP8a#%&Tu0H>~ zO)7{cf+>sU?i&NLC&a|=bb{R8w@NXa?Nn7(p+lC&r0>j6RJfs7kk3GVS*ffDFpn;Uabo&cB8U2YD zNya_d=8SMNvH=UWZ354k_%l=iDznQta`x?T@85wd=&ci${Sc@OgnQQbb-P<=yKmO` zzop;6i+R?+qs=zJ31&Le5h|GVOp7i=fsSIdRJPtz2(JCC zY&$>wPATrj4}R#nrU6Mz~Fz5RNN%!1~V(3(+PGrqr8yH*6km*4gQb7-*jJsN7l0*sH^n^zgqUn1QhA7zRvtk;vf1pg2Yd%Kwtv2$DQ zrT#ZriuAh#laQuEsw$H8(jreJyBTFd!FC<_wMh41BD2R+8Em$Gb+ zd6uE{tKF(5Bk9d)y&+z)@i|d$tKE$!hE$!T+7Sa}?aoBJMeN>?wh50b9!M(xY5Dp$ zE7`?IJ{GPQqB$h4@55|ccF+lF=QZI+HLKdS!8l~D-_!NqdA5OUYk9VbBXw0a@q|2z zd$utkcm3Izhrf!xTfz7NQ0_Xz+0H&Z!`^PXy>}x4XxVi^T=96mxFLP~y67HyW9jJ2 z3-PUVFB#a?kY0d`vK6K^hCLW^qhC;C&amb4qR6hdyQScBIxg$<*5{Tty#Y^ z3lW$Kum};D3z$LvIR0p`Pcl%_)YkF-?#Y+C~kT`3H*po%$huPFE&)&gQdB=6Qd86c$39Fa- zlL{+C#VdCjq8b48uN!68-}?>RzZ;mUZzy1ndN(VFW6^Pamq>H0^Z zC#(A1&L=ueTg7(*x)!_l5LJ`Jmt6FRvFxd^m%S?Ufwyb7`pUdl3e8F7ciaj)g?G$~ zhZD~7AIr|Fn)OpIHUu^VYDpoDdx>Ou6_sW*=r)szNl}fhx)n0@Wks~OXBd=YqHXC3 zdwFXNqcBst3pMyiXNYR55%==cG@_6?L#kZd5h|*o2nSRo+}=6kqC*g)X!w{^h!Igu zlx1Q=8wqo{%5ElihtB!eIfu9P*PDmhk{Tr3(aQ7V+44N3+&#{86sq zocvJk@r9^!@a^b#H_HAWs8>rUx~Q5Th*Y^k49Q zLG%TaufR$^7U_n%B3zuEwc{63Us%E=*;#9T;rWFaT&$h7=@+VBxPBq`4rtiM8huH{ z71_g2$NYlu6D_2^U3@L9FVMcg>+|rHHf;7bk~aEe>?@5K0lkfA48QnFWrjdrqcWp> zUL&j8n>u!}QI1CXFZjhqI2wt*VETe;1>lsVWr&t-WEGL*W~~*Gq-X8*$>}8)UDqNq zlNg|e#3G_?@a;P(T{cxh1WfJNXqmIBoC6lI%%M7Wsl`SeP|<#J|2ux z_6n#C7{5BX$P5ZB^nV5$nI3_K0kl^qADJE=j()UuCnK2w9*%)u?M_agp{f5fSjqJ9 zG!3w}*YOl?Wv&=;ueXr!bh!;WzdEVO3<Sv#sRE`{XZ7#xBgBgvR^S2nW4+?-a*}lnKpFJ}_^t<|vp5^?Yz(FXzl^K=gbF zU@vDeYmfwduwk!e)V>1#XW*!TV(`HYznorI2PSuhi@G1Zs7E9NLI&KAhQ2}=nfuX! z`tM{w=x11Xz2LjoawPynler&9tB+oHs*gSk7*PS9X_B^!x{R#utb%|An<#n0Ap#FmU3v$&_d0lqZQE6TJFZfkQq;-it0SK1I zCAS-v#|5`5l_v$aJANVc39n%T?{14a38F_B+jR^fmenp%6^_*&Q5D7)1fK{{&X0-! z?91bW+r`S`-P%pxUv5PVGhcTaz6dtGX)x;G-E}ei;w#-527F@l34HAtuIUmb`>^yn z=O+Ml>xATX$uBIv(D=f``g6NPtqnh3cRbz8XtjpOJw{jhO?3{|+1baG*Xh~Eq}Tbs zAZq+v4AU1>UvPav);KD?&h`b}7krH)((5E&uzW%DLf~n3ktc5*U({}Aom|we_l55# z-hyA~+eRBIxIRN3aKef>UeE;XyI1u&5>f{paBhdJ4u!>Xd5nth@he75j1cgXKcpI3 z%RRJX?sqCgjIB>UW}FLV$Gk`}F%`WGQtWjqqU|}myzH*(4kX|$?9Q$}gjsM^<{z~X zqO&-9U$8g{(3tK$s+t}ERK`af&cmF#X!iFXfj5pXXg5yR1q{P)1?nmBf4vpY2?w?_ zGIpdLKd6$(<6*otn3d_}3$+&2NNN6Pr$%VmsMIQr&W$vS&XdyQX{Sd>d+F3Vj@~U5 zG!kJaZx0%yC#1(Ygj&m~Dz=be>z&OTCnm1Ml~8+oxxORFV~mo-Np1m*Yx8-jQ)f@a zDauND$y0wF4w08t^3oqo+HMU|@ThwTGe@}@)~1cd$NdS4kDpV@ii?mwnl)}nEc$%X z`eQ6goYQ$MGsZ~KcYpTpiGMQCgJ8x>lp&F@GQ9Cm>c^kC`|{jXQ~USLh_roczA{Ncp3Pe2Xfr}c81ino{Pz-7r`V%a@<^RN^CJ- z&Lze@k`czMyb&=BZhusQ~56mJJM#2D-ZZIc z;~R49(ob^CpVwWCof5omJ6$o+Hf#pkVD}R|a`YV)Lyet2dygbfS5yB*z4Y3fJ3WGd zc21vC+C`sCN3H0ntvK=~P#_gSL*4OFH2$7l`{G+_{wFM{v|3$`lHnH;0unV$;{Ano zL9If8RLdJ2ypu2r0$OQpVOr2!V1PQmdLNFk>=x3WB>Q3otzwc{^ke9|KnP)xsDBcD zgK&s5)uI1>nUk}c$-=^GFNQzewIt4dm&Z$a?Hps-K+XoFt zVaXY45E~R9NcH@?5M~B=RGtNDW@(7gw}dk>bwALnO*b)P-dQcEPDzV`0V@qG=w&u& zsTNkJDo0U0p|k=v^m6N3bj({LvBRX-o3dCnntPNbHPy8Hd^n=vAw>I$_vY2J!$eIC zF+Fjz6Ata|JfdtvTLXx9;;(7sOpnnDVmlK>lt8H*%P%x>B2FLRCTfvChzTBduzu=)7&_q2e;wqf>-^mYK{s#*@C|mb4P7Y zO>POis(8Y;HL`RAY`J2b`?>8Gof~f1x+At@u0vh~BX&b>iCh{yLV2U{Ll6ebcT;RB zUs^oEd1LTHW(PBLV{S=bnmodICr01kc;k2Wyry5$J+ga4cEUbX?|D5TKJmj6R&R?8 z681!IeQZ)(&b%UI*IaVF{$A@eeno%90f2Y?y{JwOyjZ+_d7VY1eNEAO480TR)7z{n ze}{iZ`0#t#%)VrJzj4@BKwrh!EIdfUk}@A8=;?zKF#BJ95jQTJk+dmdl)_ zFs%=xn(U@R-)a$}G4M>^YZ25Hn5l2J_}w*dP2X)1{2th$Z?_0}ANZ#4%L#%24A|7? z{Du(Nw`tD_76r`PH0Okf`s;ft%)iT7IM@e0E@R9a>VTX9SJYi%kCTC5)}3mPkpX{T zpJ6!Yw8hIwNbd)`WQwc}m)u=okFAZM)}3gN{!(e$4pA9+vgz3jY70!?G;RKF8@Tf0 zuRd$Q6r32#qT;2wI~*?t0c3P=!tcx!fj<;Af>c-q`U$@kVO+U+!O#7ie`gNdn~8Au z9Dd6~jgVvH?s4taxfGTlTO4>w?gExbZ<$;=s_KDO0o8iSw%9H;-SOKA)N79{pgZC8{Qr9(w^nDYK&Tz_9fmh@GJk%4nrT8&eVfN02I z*=^OG7K3rAd8wd|JMZsez^6{g?gwu`vWP_hk=|X{jzPAW;HL~Waq+ZOaV-ST$+l^u zv4PMSjQ@jebJowzv=H_brmg3^8uApn1oR@)HZ4;-o!{NIUFQ>kJI>^-}WK4LE z^q(bnW;~(WlW7m|{^#TWuCX(;gT0T=o@N!I=|H|`i&o*A95ScqCYnEC-?Gt`LkzKf zShqaz)-QWp^J_%{kxw%>3?j&n2!#_sG=Jr900dslEXc`V%Gw>p)S7LXj{Ljt! z+$@IRuU-0Fll=DyWq&!t!Lg31v8 zXKi%0AgxlDv|Gt)b^J|lVQ3R7yXVck# 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­}Kz$GM5#API+& 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 S105aw+yrCS33f25lKc-VYZ!_E literal 0 HcmV?d00001 diff --git a/cali.lang.base/lib/java-cup-11b.jar b/cali.lang.base/lib/java-cup-11b.jar new file mode 100644 index 0000000000000000000000000000000000000000..16587964267b9423e5a73eb01b14e12a2ac27a23 GIT binary patch literal 105472 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�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 fileNames = new ArrayList(); + + /** + * Flag for initialization is complete. This is set to true once + * the base cali object have been parsed. Once set to true calls to + * addClass will instantiate static classes right away. + */ + private boolean initComplete = false; + + /* + * Main class. + */ + private boolean mainClassFound = false; + private astClass mainClassDef = null; + private CaliObject mainClassInstance = null; + + /* + * Main function. + */ + private boolean mainFunctFound = false; + private astFunctDef mainFunctDef = null; + private CaliList mainFunctArgs = new CaliList(false); + private CallStack mainCallStack = new CallStack(); + + /** + * This flag is set if the parser encounters errors. This is used + * when parsing the initial source code prior to running the application. If + * set to true the interpreter will fail to start. + */ + private boolean hasParseErrors = false; + + /** + * Allowed include paths. + */ + private List includePaths = new ArrayList(); + + /** + * List of Cali includes. + */ + private List includes = new ArrayList(); + + /* + * Class objects storage for engine. + */ + private Map classes = new ConcurrentHashMap(); + private Map staticClasses = new ConcurrentHashMap(); + + /** + * Default constructor. When called this gets an instance of the Universe object + * and initializes it if not already done. It loads universe classes and instantiates + * static classes. Finally it sets the initComplete flag to true. + * @throws caliException + */ + public Engine () throws caliException { + Universe u = Universe.get(); + u.init(this); + + // If needed, load base classes. + this.loadUniverseClasses(); + + // Instantiate the static classes. + this.instantiateStaticClasses(); + + this.initComplete = true; + } + + /** + * Adds a Cali include to the interpreter. The include can be a standard library + * language include. It can also be a file that exists in one f the includePaths + * if any are set. + * @param Include is a String with the include to add. + * @throws Exception + */ + public void addInclude(String Include) throws Exception { + if (Lang.langIncludes.containsKey(Include)) { + if (!this.includes.contains(Include)) { + this.includes.add(Include); + this.parseString(Include, Lang.langIncludes.get(Include)); + } + } else { + for (String pth : this.includePaths) { + String tinc = pth + Include; + File f = new File(tinc); + if (f.exists()) { + if (!this.includes.contains(tinc)) { + this.includes.add(tinc); + this.parseFile(tinc); + break; + } + } + } + } + } + + /** + * Adds an include path to the list of search paths for Cali includes. + * @param Path is a String with the search path to add. + */ + public void addIncludePath(String Path) { + String tinc = Path; + if (!tinc.endsWith("/")) { + tinc += "/"; + } + this.includePaths.add(tinc); + } + + /** + * Gets a list of the search include paths. + * @return A List of Strings with the include paths. + */ + public List getIncludePaths() { + return this.includePaths; + } + + /** + * Gets a list of current includes. + * @return A List of Strings with the current includes. + */ + public List getIncludes() { + return this.includes; + } + + public void addClass(astNode TCls) throws caliException { + astClass Cls = (astClass)TCls; + this.classes.put(Cls.getName(), Cls); + this.setClassConstructor(Cls); + if (Cls.getStatic() && this.initComplete) { + // Instantiate static class now. + this.instantiateStaticClass(Cls); + } + } + + /** + * Gets a class instance (astClass) object from + * the list of class definitions with the provided name. + * @param Name is a String with the class to get. + * @return An astClass object with the class definition or null if not found. + */ + public astClass getClassByName(String Name) { + return this.classes.get(Name); + } + + /** + * Checks to see if a class definition with the provided name exists in the engine. + * Note that this doesn't include static classes. + * @param Name is a String with the class definition to search for. + * @return A boolean with true for exists and false for not. + */ + public boolean containsClass(String Name) { + if (this.classes.containsKey(Name)) { + return true; + } + return false; + } + + /** + * Checks to see if a static class definition with the provided name exists + * in the engine. + * @param Name is a String with the class definition to search for. + * @return A boolean with true for exists and false for not. + */ + public boolean containsStaticClass(String Name) { + if (this.staticClasses.containsKey(Name)) { + return true; + } + return false; + } + + /** + * Gets the static class definition with the provided name. + * @param Name is a string with the class definition to get. + * @return An astClass definition for the class or null if not found. + */ + public CaliType getStaticClass(String Name) { + return this.staticClasses.get(Name); + } + + /** + * Gets a Map with the current class names and their astClass + * definition objects as values. + * @return A Map of (String, astClass) with the current classes. + */ + public Map getClasses() { + return this.classes; + } + + /** + * Sets the debug flag. If set to true the engine will print various + * verbose debug statements to standard output. + * @param Debug is a boolean with true for debug and false for not. + */ + public void setDebug(boolean Debug) { + this.debug = Debug; + } + + /** + * Gets the debug flag. + * @return A boolean with true for debug and false for not. + */ + public boolean getDebug() { + return this.debug; + } + + /** + * This function loads the native type class definitions + * in the Engine class set. This is need if you want to + * say create a new native type using the new operator. + */ + public void loadUniverseClasses() { + // Add universe classes. + Map clses = Universe.get().getClasses(); + for (String key : clses.keySet()) { + if (!this.classes.containsKey(key)) { + this.classes.put(key, clses.get(key)); + } + } + } + + /** + * The interpreter will parse the Cali code file with the provided file name. + * @param FileName is a String with the Cali code file to parse. + * @throws Exception + */ + public void parseFile(String FileName) throws Exception { + this.parseString(FileName, Util.read(FileName)); + } + + /** + * The interpreter will parse the provided Cali code string. It also + * ties that code to the provided file name internally. + * @param FileName is a String with the file name to assign to the provided code. + * @param Contents is a String with the Cali code to parse. + * @throws Exception + */ + public void parseString(String FileName, String Contents) throws Exception { + Lexer scanner = new Lexer(new StringReader(Contents)); + parser p = new parser(scanner, this, FileName); + p.parse(); + this.fileNames.add(FileName); + } + + /** + * Runs the Cali engine. This function goes though and identifies + * the first class with a main function. If not found it will throw an exception. + * If found it will call the entry point of the application (main function). + * @throws caliException + */ + public void run() throws caliException { + if (!this.hasParseErrors) { + if (this.debug) + System.out.println("[debug] Running program now ..."); + + this.mainCallStack = new CallStack(); + + // Set the main class and function. + if (this.setMainClassAndFunct()) { + this.callMain(); + } else { + throw new caliException("Engine.run(): Failed to find main class."); + } + } else { + throw new caliException("Engine.run(): Parse errors were encountered. Not running."); + } + } + + /** + * Sets the constructor function reference for the + * provided astClass class definition object. + * @param ac is a astClass object to set. + */ + private void setClassConstructor(astClass ac) { + if (ac.containsFunction(ac.getName())) { + ac.setConstructor((astFunctDef)ac.getFunct(ac.getName())); + } + } + + /** + * Function instantiates objects for all static class definitions. This is + * called once all the base lang classes have been parsed. + * @throws caliException + */ + private void instantiateStaticClasses() throws caliException { + for (String cname : this.classes.keySet()) { + astClass ac = this.classes.get(cname); + if (ac.getStatic()) { + this.instantiateStaticClass(ac); + } + } + } + + /** + * Instantiates a static class object with the provided class definition. + * @param ac is a astClass class definition object. + * @throws caliException + */ + private void instantiateStaticClass(astClass ac) throws caliException { + if (this.debug) + System.out.println("[debug] Instantiating static class: " + ac.getName()); + CaliType aci = null; + Environment tenv = new Environment(this); + Members locals = new Members(); + tenv.setEnvironment((CaliObject)aci, locals, this.mainCallStack); + aci = (CaliObject) ac.instantiate(tenv, false, new CaliList()); + if(!aci.isEx()) { + this.staticClasses.put(ac.getName(), aci); + } else { + throw new caliException(((CaliException)aci).getStackTrace()); + } + } + + /** + * Searches through list of class definitions looking for the + * first one that contains a main function. Once found it sets + * it's private mainClassFound and mainFunctFound variables. It + * then breaks and returns true if found. + * @return A boolean with true if main function found and set and + * false for not. + */ + private boolean setMainClassAndFunct() { + boolean found = false; + for (String cname : this.classes.keySet()) { + if (found) break; + astClass ac = this.classes.get(cname); + + if (ac.containsFunction("main")) { + this.mainClassFound = true; + this.mainClassDef = ac; + this.mainFunctFound = true; + this.mainFunctDef = (astFunctDef) ac.getFunct("main"); + found = true; + break; + } + } + return found; + } + + /** + * This is the program entry point. This function setups up the environment, + * locals and instantiates the main class. It then compiles the main function + * arguments and then calls main to kick off program execution. + * @throws caliException + */ + private void callMain() throws caliException { + Environment tenv = new Environment(this); + Members locals = new Members(); + tenv.setEnvironment(null, locals, this.mainCallStack); + + CaliType tci = this.mainClassDef.instantiate(tenv, false, new CaliList()); + if(!tci.isEx()) + { + this.mainClassInstance = (CaliObject) tci; + tenv.setClassInstance(this.mainClassInstance); + /* + * Main is expecting a list of args, but the function is expecting + * a list as well, so list inside of list. + */ + CaliList margs = new CaliList(); + margs.add(this.mainFunctArgs); + + /* + * Call main. + */ + CaliType ret = new CaliNull(); + ret = this.mainClassDef.call(tenv, false, "main", margs); + if(ret.isEx()) { + CaliException ex = (CaliException)ret; + System.err.println(((CaliTypeInt)ex).str()); + } + } else { + CaliException ex = (CaliException)tci; + System.err.println(ex.toString()); + } + } + + /** + * Instantiates a new object with the provided class name. + * @param Name is a String with the class name to instantiate. + * @return A newly intsantiated CaliObject. + * @throws caliException + */ + public CaliObject instantiateObject(String Name) throws caliException { + if (this.classes.containsKey(Name)) { + Environment tenv = new Environment(this); + Members locals = new Members(); + tenv.setEnvironment(this.mainClassInstance, locals, this.mainCallStack); + + return (CaliObject) this.classes.get(Name).instantiate(tenv); + } else { + throw new caliException("Attempting to instantiate object of type '" + Name + "' but class not found!"); + } + } + + /** + * Sets the parse error flag. If set prior to run being called, run will + * throw an exception because of the parse error. This is called by the + * Cali parser generated from cali.cup. + */ + public void setParseError() { + this.hasParseErrors = true; + } + + /** + * Obligatory toString method. + * @return A String representing the engine includes and classes. + */ + @Override + public String toString() { + String rstr = ""; + + rstr += "Parser loaded the following cali files ...\n"; + for(int i = 0; i < this.includes.size(); i++) { + rstr += "INCLUDE={'" + this.includes.get(i) + "'}\n"; + } + rstr += "\n"; + + rstr += "loadClassList found the following classes ...\n"; + for(String className : this.classes.keySet()) { + rstr += "CLASS={" + className + "}\n"; + rstr += this.classes.get(className).toString(); + } + rstr += "\n"; + + return rstr; + } +} diff --git a/cali.lang.base/src/com/cali/Environment.java b/cali.lang.base/src/com/cali/Environment.java new file mode 100644 index 0000000..243c3ac --- /dev/null +++ b/cali.lang.base/src/com/cali/Environment.java @@ -0,0 +1,175 @@ +/* + * Copyright 2017 Austin Lehman + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.cali; + +import com.cali.ast.astClass; +import com.cali.types.CaliObject; +import com.cali.types.CaliType; +import com.cali.types.Members; + +/** + * Houses the current Cali executing environment. Things it maintains are the current Cali + * Engine instance, the current class instance, the local variables, the call stack and the + * current object pointer. + * @author austin + */ +public class Environment { + private Engine eng = null; + private CaliObject ci = null; + private Members locals = null; + private CallStack st = null; + + /** + * This is to store the current working object. This isn't used + * for scoping, that is what ci is for. + */ + private CaliType curObj = null; + + /** + * Default constructor takes the Engine reference + * as argument. + * @param Eng is the Cali Engine instance. + */ + public Environment(Engine Eng) { + this.eng = Eng; + this.curObj = null; + } + + /** + * Sets the environment information. + * @param Ci is a CaliObject with the current class instance for scope. + * @param Locals is an instance of Members which is the function locals. + * @param St is an instance of StackTrace object. + */ + public void setEnvironment(CaliObject Ci, Members Locals, CallStack St) { + this.ci = Ci; + this.locals = Locals; + this.st = St; + } + + /** + * Gets a reference to the current Cali Engine object. + * @return A Engine object. + */ + public Engine getEngine() { + return eng; + } + + /** + * Gets the current class instance. + * @return A CaliObject with the current class instance. + */ + public CaliObject getClassInstance() { + return ci; + } + + /** + * Sets the current class instance. + * @param ci Is a CaliObject with the class instance to set. + */ + public void setClassInstance(CaliObject ci) { + this.ci = ci; + } + + /** + * Gets an instance of the current locals. + * @return A Members object with the current locals. + */ + public Members getLocals() { + return locals; + } + + /** + * Sets the current locals. + * @param locals is a Memvers object with the current locals. + */ + public void setLocals(Members locals) { + this.locals = locals; + } + + /** + * Gets the current call stack object. + * @return A CallStack object. + */ + public CallStack getCallStack() { + return st; + } + + /** + * Sets the current call stack. + * @param st is a CallStack object to set. + */ + public void setCallStack(CallStack st) { + this.st = st; + } + + /** + * Gets the current object reference. + * @return An object with the current object. + */ + public CaliType getCurObj() { + return curObj; + } + + /** + * Sets the current object reference. + * @param curObj is the current object reference. + */ + public void setCurObj(CaliType curObj) { + this.curObj = curObj; + } + + /** + * Helper that gets a class instance by name + * from the Engine. + * @param Name is a String with the name of the class definition to get. + * @return + */ + public astClass getClassByName(String Name) { + return this.eng.getClassByName(Name); + } + + /** + * Clones the environment using the provided current object + * for the new environment and returns the cloned environment object. + * @param Cur is an object with the current object reference. + * @return The cloned Environment object. + */ + public Environment clone(CaliType Cur) { + Environment ret = new Environment(this.eng); + ret.setEnvironment(this.ci, this.locals, this.st); + ret.setCurObj(Cur); + return ret; + } + + /** + * Gets the current StackTrace object as a string. + * @return A String with the current stack trace. + */ + public String stackTraceToString() { + return this.st.getStackTrace(); + } + + /** + * Removes the last StackTrace object from the chain. + */ + public void removeLastTrace() { + if (this.st.getParent() != null) { + this.st = this.st.getParent(); + } + } +} diff --git a/cali.lang.base/src/com/cali/Lexer.java b/cali.lang.base/src/com/cali/Lexer.java new file mode 100644 index 0000000..e95349d --- /dev/null +++ b/cali.lang.base/src/com/cali/Lexer.java @@ -0,0 +1,1136 @@ +/* The following code was generated by JFlex 1.4_pre3 on 3/26/17 11:26 AM */ + +/* + * Copyright 2017 Austin Lehman + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.cali; + +import java.math.BigDecimal; +import java.math.BigInteger; + +import java_cup.runtime.Symbol; +import com.cali.stdlib.console; + + +/** + * This class is a scanner generated by + * JFlex 1.4_pre3 + * on 3/26/17 11:26 AM from the specification file + * file:/home/austin/eclipse/cali.lang.base/cali.lang.base/src/com/cali/Scanner.jflex + */ +class Lexer extends sym implements java_cup.runtime.Scanner { + + /** This character denotes the end of file */ + public static final int YYEOF = -1; + + /** initial size of the lookahead buffer */ + private static final int YY_BUFFERSIZE = 16384; + + /** lexical states */ + public static final int C_COMMENT = 1; + public static final int STRING = 2; + public static final int YYINITIAL = 0; + public static final int STRING_LIT = 4; + public static final int STRING_FRMT = 3; + + /** + * Translates characters to character classes + */ + private static final String yycmap_packed = + "\11\0\1\66\1\6\1\0\1\1\1\5\22\0\1\1\1\54\1\63"+ + "\1\61\1\0\1\53\1\57\1\64\1\41\1\42\1\52\1\50\1\40"+ + "\1\51\1\3\1\10\12\2\1\37\1\7\1\55\1\47\1\56\1\0"+ + "\1\62\32\4\1\45\1\65\1\46\1\0\1\4\1\0\1\13\1\24"+ + "\1\11\1\22\1\15\1\35\1\4\1\33\1\21\1\4\1\36\1\12"+ + "\1\20\1\16\1\26\1\23\1\4\1\25\1\14\1\27\1\17\1\30"+ + "\1\34\1\31\1\32\1\4\1\43\1\60\1\44\uff82\0"; + + /** + * Translates characters to character classes + */ + private static final char [] yycmap = yy_unpack_cmap(yycmap_packed); + + + /** + * Translates a state to a row index in the transition table (packed version) + */ + final private static String yy_rowMap_packed = + "\0\0\0\67\0\156\0\245\0\334\0\u0113\0\u0113\0\u014a\0\u0181\0\u01b8"+ + "\0\u01ef\0\u0113\0\u0226\0\u025d\0\u0294\0\u02cb\0\u0302\0\u0339\0\u0370\0\u03a7"+ + "\0\u03de\0\u0415\0\u044c\0\u0483\0\u04ba\0\u04f1\0\u0113\0\u0113\0\u0113\0\u0113"+ + "\0\u0113\0\u0113\0\u0113\0\u0528\0\u055f\0\u0596\0\u05cd\0\u0604\0\u063b\0\u0672"+ + "\0\u06a9\0\u06e0\0\u0717\0\u0113\0\u074e\0\u0785\0\u0113\0\u07bc\0\u07f3\0\u082a"+ + "\0\u0861\0\u0113\0\u0898\0\u08cf\0\u0113\0\u0113\0\u0113\0\u0906\0\u093d\0\u0113"+ + "\0\u0974\0\u0113\0\u09ab\0\u09e2\0\u0a19\0\u0a50\0\u0a87\0\u0113\0\u0113\0\u0abe"+ + "\0\u0af5\0\u0b2c\0\u0b63\0\u0b9a\0\u0bd1\0\u0c08\0\u0c3f\0\u0c76\0\u0cad\0\u01b8"+ + "\0\u0ce4\0\u0d1b\0\u0d52\0\u0d89\0\u0dc0\0\u0df7\0\u0e2e\0\u0e65\0\u0e9c\0\u0ed3"+ + "\0\u0113\0\u0113\0\u0113\0\u0113\0\u0113\0\u0113\0\u0113\0\u0113\0\u0113\0\u0113"+ + "\0\u0113\0\u0113\0\u0113\0\u0113\0\u0f0a\0\u0f41\0\u0113\0\u0113\0\u0113\0\u0f78"+ + "\0\u0faf\0\u0113\0\u0a19\0\u0113\0\u0fe6\0\u101d\0\u1054\0\u108b\0\u10c2\0\u10f9"+ + "\0\u1130\0\u1167\0\u01b8\0\u119e\0\u11d5\0\u120c\0\u1243\0\u127a\0\u12b1\0\u12e8"+ + "\0\u131f\0\u1356\0\u138d\0\u01b8\0\u13c4\0\u13fb\0\u1432\0\u01b8\0\u0113\0\u1469"+ + "\0\u14a0\0\u01b8\0\u14d7\0\u150e\0\u1545\0\u01b8\0\u01b8\0\u157c\0\u01b8\0\u15b3"+ + "\0\u15ea\0\u1621\0\u1658\0\u168f\0\u16c6\0\u16fd\0\u1734\0\u01b8\0\u176b\0\u17a2"+ + "\0\u17d9\0\u1810\0\u01b8\0\u01b8\0\u1847\0\u187e\0\u18b5\0\u18ec\0\u1923\0\u195a"+ + "\0\u1991\0\u19c8\0\u19ff\0\u01b8\0\u1a36\0\u01b8\0\u01b8\0\u01b8\0\u1a6d\0\u01b8"+ + "\0\u01b8\0\u01b8\0\u1aa4\0\u1adb\0\u1b12\0\u01b8\0\u1b49\0\u1b80\0\u01b8\0\u0113"+ + "\0\u01b8\0\u1bb7\0\u01b8\0\u01b8\0\u1bee\0\u1c25\0\u1c5c\0\u1c93\0\u01b8\0\u01b8"; + + /** + * Translates a state to a row index in the transition table + */ + final private static int [] yy_rowMap = yy_unpack_rowMap(yy_rowMap_packed); + + + /** + * Unpacks the compressed row translation table. + * + * @param packed the packed row translation table + * @return the unpacked row translation table + */ + private static int [] yy_unpack_rowMap(String packed) { + int [] map = new int[400]; + int i = 0; /* index in packed string */ + int j = 0; /* index in unpacked array */ + while (i < 400) { + int high = ((int) packed.charAt(i++)) << 16; + map[j++] = high | packed.charAt(i++); + } + return map; + } + /** + * The packed transition table of the DFA (part 0) + */ + private static final String yy_packed0 = + "\1\6\1\7\1\10\1\11\1\12\1\13\1\7\1\14"+ + "\1\15\1\16\2\12\1\17\1\20\1\21\2\12\1\22"+ + "\1\23\1\24\1\25\1\26\1\12\1\27\4\12\1\30"+ + "\1\31\1\12\1\32\1\33\1\34\1\35\1\36\1\37"+ + "\1\40\1\41\1\42\1\43\1\44\1\45\1\46\1\47"+ + "\1\50\1\51\1\52\1\53\1\54\1\55\1\56\1\57"+ + "\1\6\1\7\6\60\1\7\43\60\1\61\14\60\5\62"+ + "\2\63\54\62\1\64\1\62\1\65\1\66\5\67\1\70"+ + "\1\71\54\67\1\72\1\67\1\73\1\74\5\75\2\63"+ + "\55\75\1\76\1\77\1\100\71\0\1\10\1\101\1\12"+ + "\4\0\26\12\33\0\1\102\65\0\1\12\1\0\1\12"+ + "\4\0\26\12\36\0\1\7\70\0\1\103\36\0\1\104"+ + "\2\0\1\105\16\0\1\12\1\0\1\12\4\0\1\12"+ + "\1\106\1\107\23\12\32\0\1\12\1\0\1\12\4\0"+ + "\16\12\1\110\4\12\1\111\2\12\32\0\1\12\1\0"+ + "\1\12\4\0\1\12\1\112\3\12\1\113\12\12\1\114"+ + "\5\12\32\0\1\12\1\0\1\12\4\0\4\12\1\115"+ + "\1\12\1\116\17\12\32\0\1\12\1\0\1\12\4\0"+ + "\5\12\1\117\16\12\1\120\1\12\32\0\1\12\1\0"+ + "\1\12\4\0\4\12\1\121\21\12\32\0\1\12\1\0"+ + "\1\12\4\0\6\12\1\122\5\12\1\123\11\12\32\0"+ + "\1\12\1\0\1\12\4\0\14\12\1\124\11\12\32\0"+ + "\1\12\1\0\1\12\4\0\4\12\1\125\21\12\32\0"+ + "\1\12\1\0\1\12\4\0\14\12\1\126\5\12\1\127"+ + "\3\12\32\0\1\12\1\0\1\12\4\0\22\12\1\130"+ + "\3\12\32\0\1\12\1\0\1\12\4\0\2\12\1\131"+ + "\12\12\1\132\10\12\67\0\1\133\76\0\1\134\66\0"+ + "\1\135\1\136\65\0\1\137\1\0\1\140\64\0\1\141"+ + "\66\0\1\142\66\0\1\143\66\0\1\144\66\0\1\145"+ + "\76\0\1\146\67\0\1\147\55\0\1\150\102\0\1\151"+ + "\3\0\6\60\1\0\43\60\1\0\14\60\6\152\1\0"+ + "\1\152\1\153\41\152\1\61\14\152\5\62\2\0\54\62"+ + "\1\0\1\62\1\0\1\62\5\0\2\63\57\0\1\63"+ + "\16\0\1\71\6\0\1\70\1\0\1\74\33\0\1\154"+ + "\1\0\1\155\1\0\5\62\2\63\54\62\1\0\1\62"+ + "\1\0\1\66\63\0\1\156\66\0\1\157\1\0\1\155"+ + "\1\0\5\75\2\0\55\75\2\0\1\75\16\0\1\71"+ + "\6\0\1\70\1\0\1\74\34\0\1\160\1\155\1\0"+ + "\5\75\2\63\55\75\2\0\1\100\2\0\1\161\67\0"+ + "\1\162\63\0\5\103\2\0\60\103\2\0\1\12\1\0"+ + "\1\12\4\0\2\12\1\163\23\12\32\0\1\12\1\0"+ + "\1\12\4\0\3\12\1\164\12\12\1\165\7\12\32\0"+ + "\1\12\1\0\1\12\4\0\2\12\1\166\23\12\32\0"+ + "\1\12\1\0\1\12\4\0\10\12\1\167\15\12\32\0"+ + "\1\12\1\0\1\12\4\0\3\12\1\170\22\12\32\0"+ + "\1\12\1\0\1\12\4\0\6\12\1\171\17\12\32\0"+ + "\1\12\1\0\1\12\4\0\16\12\1\172\7\12\32\0"+ + "\1\12\1\0\1\12\4\0\23\12\1\173\2\12\32\0"+ + "\1\12\1\0\1\12\4\0\1\12\1\174\24\12\32\0"+ + "\1\12\1\0\1\12\4\0\1\175\2\12\1\176\22\12"+ + "\32\0\1\12\1\0\1\12\4\0\24\12\1\177\1\12"+ + "\32\0\1\12\1\0\1\12\4\0\13\12\1\200\12\12"+ + "\32\0\1\12\1\0\1\12\4\0\10\12\1\201\4\12"+ + "\1\202\10\12\32\0\1\12\1\0\1\12\4\0\4\12"+ + "\1\203\21\12\32\0\1\12\1\0\1\12\4\0\16\12"+ + "\1\204\7\12\32\0\1\12\1\0\1\12\4\0\6\12"+ + "\1\205\12\12\1\206\4\12\32\0\1\12\1\0\1\12"+ + "\4\0\14\12\1\207\11\12\32\0\1\12\1\0\1\12"+ + "\4\0\10\12\1\210\15\12\32\0\1\12\1\0\1\12"+ + "\4\0\1\12\1\211\24\12\32\0\1\12\1\0\1\12"+ + "\4\0\14\12\1\212\11\12\113\0\1\213\3\0\6\152"+ + "\1\0\1\152\1\0\41\152\1\0\14\152\63\0\1\76"+ + "\70\0\1\214\3\0\1\12\1\0\1\12\4\0\3\12"+ + "\1\215\22\12\32\0\1\12\1\0\1\12\4\0\4\12"+ + "\1\216\21\12\32\0\1\12\1\0\1\12\4\0\1\217"+ + "\25\12\32\0\1\12\1\0\1\12\4\0\16\12\1\220"+ + "\7\12\32\0\1\12\1\0\1\12\4\0\16\12\1\221"+ + "\7\12\32\0\1\12\1\0\1\12\4\0\4\12\1\222"+ + "\21\12\32\0\1\12\1\0\1\12\4\0\7\12\1\223"+ + "\16\12\32\0\1\12\1\0\1\12\4\0\4\12\1\224"+ + "\21\12\32\0\1\12\1\0\1\12\4\0\1\12\1\225"+ + "\24\12\32\0\1\12\1\0\1\12\4\0\1\12\1\226"+ + "\24\12\32\0\1\12\1\0\1\12\4\0\16\12\1\227"+ + "\7\12\32\0\1\12\1\0\1\12\4\0\2\12\1\230"+ + "\23\12\32\0\1\12\1\0\1\12\4\0\1\12\1\231"+ + "\24\12\32\0\1\12\1\0\1\12\4\0\17\12\1\232"+ + "\6\12\32\0\1\12\1\0\1\12\4\0\16\12\1\233"+ + "\7\12\32\0\1\12\1\0\1\12\4\0\2\12\1\234"+ + "\23\12\32\0\1\12\1\0\1\12\4\0\6\12\1\235"+ + "\17\12\32\0\1\12\1\0\1\12\4\0\4\12\1\236"+ + "\21\12\32\0\1\12\1\0\1\12\4\0\15\12\1\237"+ + "\10\12\32\0\1\12\1\0\1\12\4\0\1\12\1\240"+ + "\24\12\32\0\1\12\1\0\1\12\4\0\3\12\1\241"+ + "\22\12\113\0\1\242\5\0\1\12\1\0\1\12\4\0"+ + "\3\12\1\243\22\12\32\0\1\12\1\0\1\12\4\0"+ + "\22\12\1\244\3\12\32\0\1\12\1\0\1\12\4\0"+ + "\10\12\1\245\15\12\32\0\1\12\1\0\1\12\4\0"+ + "\1\246\25\12\32\0\1\12\1\0\1\12\4\0\14\12"+ + "\1\247\11\12\32\0\1\12\1\0\1\12\4\0\6\12"+ + "\1\250\17\12\32\0\1\12\1\0\1\12\4\0\2\12"+ + "\1\251\23\12\32\0\1\12\1\0\1\12\4\0\6\12"+ + "\1\252\17\12\32\0\1\12\1\0\1\12\4\0\10\12"+ + "\1\253\15\12\32\0\1\12\1\0\1\12\4\0\2\12"+ + "\1\254\23\12\32\0\1\12\1\0\1\12\4\0\4\12"+ + "\1\255\21\12\32\0\1\12\1\0\1\12\4\0\25\12"+ + "\1\256\32\0\1\12\1\0\1\12\4\0\14\12\1\257"+ + "\11\12\32\0\1\12\1\0\1\12\4\0\23\12\1\260"+ + "\2\12\32\0\1\12\1\0\1\12\4\0\4\12\1\261"+ + "\21\12\32\0\1\12\1\0\1\12\4\0\4\12\1\262"+ + "\21\12\115\0\1\263\3\0\1\12\1\0\1\12\4\0"+ + "\1\264\25\12\32\0\1\12\1\0\1\12\4\0\22\12"+ + "\1\265\3\12\32\0\1\12\1\0\1\12\4\0\5\12"+ + "\1\266\20\12\32\0\1\12\1\0\1\12\4\0\11\12"+ + "\1\267\14\12\32\0\1\12\1\0\1\12\4\0\5\12"+ + "\1\270\20\12\32\0\1\12\1\0\1\12\4\0\1\12"+ + "\1\271\24\12\32\0\1\12\1\0\1\12\4\0\1\272"+ + "\25\12\32\0\1\12\1\0\1\12\4\0\16\12\1\273"+ + "\7\12\32\0\1\12\1\0\1\12\4\0\1\274\25\12"+ + "\32\0\1\12\1\0\1\12\4\0\5\12\1\275\20\12"+ + "\113\0\1\276\5\0\1\12\1\0\1\12\4\0\4\12"+ + "\1\277\21\12\32\0\1\12\1\0\1\12\4\0\1\300"+ + "\25\12\32\0\1\12\1\0\1\12\4\0\16\12\1\301"+ + "\7\12\32\0\1\12\1\0\1\12\4\0\4\12\1\302"+ + "\21\12\32\0\1\12\1\0\1\12\4\0\16\12\1\303"+ + "\7\12\32\0\1\12\1\0\1\12\4\0\4\12\1\304"+ + "\21\12\32\0\1\12\1\0\1\12\4\0\4\12\1\305"+ + "\21\12\32\0\1\12\1\0\1\12\4\0\15\12\1\306"+ + "\10\12\32\0\1\12\1\0\1\12\4\0\11\12\1\307"+ + "\14\12\32\0\1\12\1\0\1\12\4\0\24\12\1\310"+ + "\1\12\30\0"; + + /** + * The transition table of the DFA + */ + private static final int yytrans [] = yy_unpack(); + + + /* error codes */ + private static final int YY_UNKNOWN_ERROR = 0; + private static final int YY_ILLEGAL_STATE = 1; + private static final int YY_NO_MATCH = 2; + private static final int YY_PUSHBACK_2BIG = 3; + + /* error messages for the codes above */ + private static final String YY_ERROR_MSG[] = { + "Unkown internal scanner error", + "Internal error: unknown state", + "Error: could not match input", + "Error: pushback value was too large" + }; + + /** + * YY_ATTRIBUTE[aState] contains the attributes of state aState + */ + private static final byte YY_ATTRIBUTE[] = { + 1, 1, 0, 0, 0, 9, 9, 1, 1, 1, 1, 9, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 9, 9, 9, 9, 9, 9, + 9, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 9, 1, 1, 9, 1, + 1, 1, 1, 9, 1, 1, 9, 9, 9, 1, 1, 9, 1, 9, 1, 1, + 0, 0, 1, 9, 9, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 9, 9, 9, 9, 9, 9, + 9, 9, 9, 9, 9, 9, 9, 9, 0, 1, 9, 9, 9, 0, 0, 9, + 1, 9, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 9, 0, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 9, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1 + }; + + /** the input device */ + private java.io.Reader yy_reader; + + /** the current state of the DFA */ + private int yy_state; + + /** the current lexical state */ + private int yy_lexical_state = YYINITIAL; + + /** this buffer contains the current text to be matched and is + the source of the yytext() string */ + private char yy_buffer[] = new char[YY_BUFFERSIZE]; + + /** the textposition at the last accepting state */ + private int yy_markedPos; + + /** the textposition at the last state to be included in yytext */ + private int yy_pushbackPos; + + /** the current text position in the buffer */ + private int yy_currentPos; + + /** startRead marks the beginning of the yytext() string in the buffer */ + private int yy_startRead; + + /** endRead marks the last character in the buffer, that has been read + from input */ + private int yy_endRead; + + /** number of newlines encountered up to the start of the matched text */ + private int yyline; + + /** the number of characters up to the start of the matched text */ + private int yychar; + + /** + * the number of characters from the last newline up to the start of the + * matched text + */ + private int yycolumn; + + /** + * yy_atBOL == true <=> the scanner is currently at the beginning of a line + */ + private boolean yy_atBOL = true; + + /** yy_atEOF == true <=> the scanner is at the EOF */ + private boolean yy_atEOF; + + /** denotes if the user-EOF-code has already been executed */ + private boolean yy_eof_done; + + /* user code: */ + StringBuffer string = new StringBuffer(); + + private Symbol symbol(int sym) { + return new Symbol(sym, yyline+1, yycolumn+1); + } + + private Symbol symbol(int sym, Object val) { + return new Symbol(sym, yyline+1, yycolumn+1, val); + } + + private void error(String message) { + console.get().err("Error at line "+(yyline+1)+", column "+(yycolumn+1)+" : "+message); + } + + + /** + * Creates a new scanner + * There is also a java.io.InputStream version of this constructor. + * + * @param in the java.io.Reader to read input from. + */ + Lexer(java.io.Reader in) { + this.yy_reader = in; + } + + /** + * Creates a new scanner. + * There is also java.io.Reader version of this constructor. + * + * @param in the java.io.Inputstream to read input from. + */ + Lexer(java.io.InputStream in) { + this(new java.io.InputStreamReader(in)); + } + + /** + * Unpacks the split, compressed DFA transition table. + * + * @return the unpacked transition table + */ + private static int [] yy_unpack() { + int [] trans = new int[7370]; + int offset = 0; + offset = yy_unpack(yy_packed0, offset, trans); + return trans; + } + + /** + * Unpacks the compressed DFA transition table. + * + * @param packed the packed transition table + * @return the index of the last entry + */ + private static int yy_unpack(String packed, int offset, int [] trans) { + int i = 0; /* index in packed string */ + int j = offset; /* index in unpacked array */ + int l = packed.length(); + while (i < l) { + int count = packed.charAt(i++); + int value = packed.charAt(i++); + value--; + do trans[j++] = value; while (--count > 0); + } + return j; + } + + /** + * Unpacks the compressed character translation table. + * + * @param packed the packed character translation table + * @return the unpacked character translation table + */ + private static char [] yy_unpack_cmap(String packed) { + char [] map = new char[0x10000]; + int i = 0; /* index in packed string */ + int j = 0; /* index in unpacked array */ + while (i < 136) { + int count = packed.charAt(i++); + char value = packed.charAt(i++); + do map[j++] = value; while (--count > 0); + } + return map; + } + + + /** + * Refills the input buffer. + * + * @return false, iff there was new input. + * + * @exception IOException if any I/O-Error occurs + */ + private boolean yy_refill() throws java.io.IOException { + + /* first: make room (if you can) */ + if (yy_startRead > 0) { + System.arraycopy(yy_buffer, yy_startRead, + yy_buffer, 0, + yy_endRead-yy_startRead); + + /* translate stored positions */ + yy_endRead-= yy_startRead; + yy_currentPos-= yy_startRead; + yy_markedPos-= yy_startRead; + yy_pushbackPos-= yy_startRead; + yy_startRead = 0; + } + + /* is the buffer big enough? */ + if (yy_currentPos >= yy_buffer.length) { + /* if not: blow it up */ + char newBuffer[] = new char[yy_currentPos*2]; + System.arraycopy(yy_buffer, 0, newBuffer, 0, yy_buffer.length); + yy_buffer = newBuffer; + } + + /* finally: fill the buffer with new input */ + int numRead = yy_reader.read(yy_buffer, yy_endRead, + yy_buffer.length-yy_endRead); + + if (numRead < 0) { + return true; + } + else { + yy_endRead+= numRead; + return false; + } + } + + + /** + * Closes the input stream. + */ + public final void yyclose() throws java.io.IOException { + yy_atEOF = true; /* indicate end of file */ + yy_endRead = yy_startRead; /* invalidate buffer */ + + if (yy_reader != null) + yy_reader.close(); + } + + + /** + * Closes the current stream, and resets the + * scanner to read from a new input stream. + * + * All internal variables are reset, the old input stream + * cannot be reused (internal buffer is discarded and lost). + * Lexical state is set to YY_INITIAL. + * + * @param reader the new input stream + */ + public final void yyreset(java.io.Reader reader) throws java.io.IOException { + yyclose(); + yy_reader = reader; + yy_atBOL = true; + yy_atEOF = false; + yy_endRead = yy_startRead = 0; + yy_currentPos = yy_markedPos = yy_pushbackPos = 0; + yyline = yychar = yycolumn = 0; + yy_lexical_state = YYINITIAL; + } + + + /** + * Returns the current lexical state. + */ + public final int yystate() { + return yy_lexical_state; + } + + + /** + * Enters a new lexical state + * + * @param newState the new lexical state + */ + public final void yybegin(int newState) { + yy_lexical_state = newState; + } + + + /** + * Returns the text matched by the current regular expression. + */ + public final String yytext() { + return new String( yy_buffer, yy_startRead, yy_markedPos-yy_startRead ); + } + + + /** + * Returns the character at position pos from the + * matched text. + * + * It is equivalent to yytext().charAt(pos), but faster + * + * @param pos the position of the character to fetch. + * A value from 0 to yylength()-1. + * + * @return the character at position pos + */ + public final char yycharat(int pos) { + return yy_buffer[yy_startRead+pos]; + } + + + /** + * Returns the length of the matched text region. + */ + public final int yylength() { + return yy_markedPos-yy_startRead; + } + + + /** + * Reports an error that occured while scanning. + * + * In a wellformed scanner (no or only correct usage of + * yypushback(int) and a match-all fallback rule) this method + * will only be called with things that "Can't Possibly Happen". + * If this method is called, something is seriously wrong + * (e.g. a JFlex bug producing a faulty scanner etc.). + * + * Usual syntax/scanner level error handling should be done + * in error fallback rules. + * + * @param errorCode the code of the errormessage to display + */ + private void yy_ScanError(int errorCode) { + String message; + try { + message = YY_ERROR_MSG[errorCode]; + } + catch (ArrayIndexOutOfBoundsException e) { + message = YY_ERROR_MSG[YY_UNKNOWN_ERROR]; + } + + throw new Error(message); + } + + + /** + * Pushes the specified amount of characters back into the input stream. + * + * They will be read again by then next call of the scanning method + * + * @param number the number of characters to be read again. + * This number must not be greater than yylength()! + */ + private void yypushback(int number) { + if ( number > yylength() ) + yy_ScanError(YY_PUSHBACK_2BIG); + + yy_markedPos -= number; + } + + + /** + * Contains user EOF-code, which will be executed exactly once, + * when the end of file is reached + */ + private void yy_do_eof() throws java.io.IOException { + if (!yy_eof_done) { + yy_eof_done = true; + yyclose(); + } + } + + + /** + * Resumes scanning until the next regular expression is matched, + * the end of input is encountered or an I/O-Error occurs. + * + * @return the next token + * @exception IOException if any I/O-Error occurs + */ + public java_cup.runtime.Symbol next_token() throws java.io.IOException { + int yy_input; + int yy_action; + + // cached fields: + int yy_currentPos_l; + int yy_startRead_l; + int yy_markedPos_l; + int yy_endRead_l = yy_endRead; + char [] yy_buffer_l = yy_buffer; + char [] yycmap_l = yycmap; + + int [] yytrans_l = yytrans; + int [] yy_rowMap_l = yy_rowMap; + byte [] yy_attr_l = YY_ATTRIBUTE; + + while (true) { + yy_markedPos_l = yy_markedPos; + + boolean yy_r = false; + for (yy_currentPos_l = yy_startRead; yy_currentPos_l < yy_markedPos_l; + yy_currentPos_l++) { + switch (yy_buffer_l[yy_currentPos_l]) { + case '\u000B': + case '\u000C': + case '\u0085': + case '\u2028': + case '\u2029': + yyline++; + yycolumn = 0; + yy_r = false; + break; + case '\r': + yyline++; + yycolumn = 0; + yy_r = true; + break; + case '\n': + if (yy_r) + yy_r = false; + else { + yyline++; + yycolumn = 0; + } + break; + default: + yy_r = false; + yycolumn++; + } + } + + if (yy_r) { + // peek one character ahead if it is \n (if we have counted one line too much) + boolean yy_peek; + if (yy_markedPos_l < yy_endRead_l) + yy_peek = yy_buffer_l[yy_markedPos_l] == '\n'; + else if (yy_atEOF) + yy_peek = false; + else { + boolean eof = yy_refill(); + yy_markedPos_l = yy_markedPos; + yy_buffer_l = yy_buffer; + if (eof) + yy_peek = false; + else + yy_peek = yy_buffer_l[yy_markedPos_l] == '\n'; + } + if (yy_peek) yyline--; + } + yy_action = -1; + + yy_startRead_l = yy_currentPos_l = yy_currentPos = + yy_startRead = yy_markedPos_l; + + yy_state = yy_lexical_state; + + + yy_forAction: { + while (true) { + + if (yy_currentPos_l < yy_endRead_l) + yy_input = yy_buffer_l[yy_currentPos_l++]; + else if (yy_atEOF) { + yy_input = YYEOF; + break yy_forAction; + } + else { + // store back cached positions + yy_currentPos = yy_currentPos_l; + yy_markedPos = yy_markedPos_l; + boolean eof = yy_refill(); + // get translated positions and possibly new buffer + yy_currentPos_l = yy_currentPos; + yy_markedPos_l = yy_markedPos; + yy_buffer_l = yy_buffer; + yy_endRead_l = yy_endRead; + if (eof) { + yy_input = YYEOF; + break yy_forAction; + } + else { + yy_input = yy_buffer_l[yy_currentPos_l++]; + } + } + int yy_next = yytrans_l[ yy_rowMap_l[yy_state] + yycmap_l[yy_input] ]; + if (yy_next == -1) break yy_forAction; + yy_state = yy_next; + + int yy_attributes = yy_attr_l[yy_state]; + if ( (yy_attributes & 1) == 1 ) { + yy_action = yy_state; + yy_markedPos_l = yy_currentPos_l; + if ( (yy_attributes & 8) == 8 ) break yy_forAction; + } + + } + } + + // store back cached position + yy_markedPos = yy_markedPos_l; + + switch (yy_action) { + + case 199: + { return symbol(sym.INSTANCEOF); } + case 201: break; + case 177: + { return symbol(sym.BOOL, false); } + case 202: break; + case 138: + { string.setLength(0); yybegin(STRING_FRMT); } + case 203: break; + case 157: + { return symbol(sym.BOOL, true); } + case 204: break; + case 50: + { /* Do nothing. */ } + case 205: break; + case 198: + { return symbol(sym.PROTECTED); } + case 206: break; + case 29: + { return symbol(sym.LBRACKET); } + case 207: break; + case 30: + { return symbol(sym.RBRACKET); } + case 208: break; + case 90: + { return symbol(sym.CALLBACK); } + case 209: break; + case 97: + { return symbol(sym.MODULUSEQ); } + case 210: break; + case 113: + { return symbol(sym.ETCETERA); } + case 211: break; + case 162: + { return symbol(sym.CLASSDEF); } + case 212: break; + case 48: + case 105: + { /* ignore */ } + case 213: break; + case 40: + { return symbol(sym.GT); } + case 214: break; + case 39: + { return symbol(sym.LT); } + case 215: break; + case 38: + { return symbol(sym.NOT); } + case 216: break; + case 36: + { return symbol(sym.MU); } + case 217: break; + case 35: + { return symbol(sym.MI); } + case 218: break; + case 34: + { return symbol(sym.PL); } + case 219: break; + case 12: + { return symbol(sym.DI); } + case 220: break; + case 8: + { return symbol(sym.DOT); } + case 221: break; + case 6: + { /* ignore */ } + case 222: break; + case 1: + case 47: + { /* ignore */ } + case 223: break; + case 33: + { return symbol(sym.EQ); } + case 224: break; + case 66: + { /* ignore */ } + case 225: break; + case 79: + { return symbol(sym.IF); } + case 226: break; + case 101: + { return symbol(sym.AND); } + case 227: break; + case 102: + { return symbol(sym.OR); } + case 228: break; + case 122: + { return symbol(sym.NEW); } + case 229: break; + case 133: + { return symbol(sym.TRY); } + case 230: break; + case 137: + { return symbol(sym.FOR); } + case 231: break; + case 176: + { return symbol(sym.WHILE); } + case 232: break; + case 175: + { return symbol(sym.THROW); } + case 233: break; + case 173: + { return symbol(sym.BREAK); } + case 234: break; + case 43: + { return symbol(sym.COUNT); } + case 235: break; + case 11: + { return symbol(sym.SEMI); } + case 236: break; + case 25: + { return symbol(sym.COLON); } + case 237: break; + case 26: + { return symbol(sym.COMMA); } + case 238: break; + case 67: + { return symbol(sym.DIEQ); } + case 239: break; + case 91: + { return symbol(sym.EQEQ); } + case 240: break; + case 92: + { return symbol(sym.PLEQ); } + case 241: break; + case 93: + { return symbol(sym.PLPL); } + case 242: break; + case 94: + { return symbol(sym.MIEQ); } + case 243: break; + case 95: + { return symbol(sym.MIMI); } + case 244: break; + case 96: + { return symbol(sym.MUEQ); } + case 245: break; + case 98: + { return symbol(sym.NOTEQ); } + case 246: break; + case 99: + { return symbol(sym.LTEQ); } + case 247: break; + case 100: + { return symbol(sym.GTEQ); } + case 248: break; + case 141: + { return symbol(sym.CASE); } + case 249: break; + case 145: + { return symbol(sym.ELSE); } + case 250: break; + case 146: + { return symbol(sym.ENUM); } + case 251: break; + case 148: + { return symbol(sym.NULL); } + case 252: break; + case 163: + { return symbol(sym.CATCH); } + case 253: break; + case 59: + { string.append('\t'); } + case 254: break; + case 56: + { string.append('\n'); } + case 255: break; + case 55: + { string.append('\r'); } + case 256: break; + case 107: + { string.append('\"'); } + case 257: break; + case 108: + { string.append("\\"); } + case 258: break; + case 111: + { string.append('\''); } + case 259: break; + case 189: + { string.append("\"\"\""); } + case 260: break; + case 61: + { + yybegin(YYINITIAL); + return symbol(sym.STRING, string.toString()); + } + case 261: break; + case 68: + { yybegin(C_COMMENT); } + case 262: break; + case 106: + { yybegin(YYINITIAL); } + case 263: break; + case 51: + { + yybegin(YYINITIAL); + return symbol(sym.STRING, + string.toString()); + } + case 264: break; + case 0: + case 9: + case 13: + case 14: + case 15: + case 16: + case 17: + case 18: + case 19: + case 20: + case 21: + case 22: + case 23: + case 24: + case 69: + case 70: + case 71: + case 72: + case 73: + case 74: + case 75: + case 76: + case 77: + case 78: + case 80: + case 81: + case 82: + case 83: + case 84: + case 85: + case 86: + case 87: + case 88: + case 89: + case 114: + case 115: + case 116: + case 117: + case 118: + case 119: + case 120: + case 121: + case 123: + case 124: + case 125: + case 126: + case 127: + case 128: + case 129: + case 130: + case 131: + case 132: + case 134: + case 135: + case 136: + case 140: + case 142: + case 143: + case 144: + case 147: + case 149: + case 150: + case 151: + case 152: + case 153: + case 154: + case 155: + case 156: + case 158: + case 159: + case 160: + case 164: + case 165: + case 166: + case 167: + case 168: + case 169: + case 170: + case 171: + case 172: + case 174: + case 182: + case 183: + case 184: + case 186: + case 187: + case 191: + case 194: + case 195: + case 196: + case 197: + { return symbol(sym.IDENT, yytext()); } + case 265: break; + case 45: + { string.setLength(0); yybegin(STRING); } + case 266: break; + case 193: + { return symbol(sym.PRIVATE); } + case 267: break; + case 192: + { return symbol(sym.DEFAULT); } + case 268: break; + case 190: + { return symbol(sym.INCLUDE); } + case 269: break; + case 188: + { return symbol(sym.RETURN); } + case 270: break; + case 185: + { return symbol(sym.PUBLIC); } + case 271: break; + case 181: + { return symbol(sym.EXTERN); } + case 272: break; + case 180: + { return symbol(sym.SWITCH); } + case 273: break; + case 179: + { return symbol(sym.STATIC); } + case 274: break; + case 54: + case 57: + case 58: + { string.append( yytext() ); } + case 275: break; + case 49: + case 53: + { string.append( yytext() ); } + case 276: break; + case 37: + { return symbol(sym.MODULUS); } + case 277: break; + case 27: + { return symbol(sym.LPAREN); } + case 278: break; + case 28: + { return symbol(sym.RPAREN); } + case 279: break; + case 31: + { return symbol(sym.LBRACE); } + case 280: break; + case 32: + { return symbol(sym.RBRACE); } + case 281: break; + case 60: + case 63: + { string.append( yytext() ); } + case 282: break; + case 103: + { return symbol(sym.INSERT); } + case 283: break; + case 46: + { string.setLength(0); yybegin(STRING_LIT); } + case 284: break; + case 5: + case 10: + case 41: + case 42: + case 44: + case 52: + case 62: + { /* throw new Error("Illegal character <" + String.ValueOf((int)yytext()) + ">");*/ + error("Illegal character <" + String.valueOf((int)yytext().charAt(0)) + ">"); + } + case 285: break; + case 7: + case 112: + { + if(yytext().contains(".")) + { + BigDecimal val = null; + try{ val = new BigDecimal(yytext()); } + catch(NumberFormatException e) + { + error("Number format exception <" + yytext() + ">"); + } + return symbol(sym.DOUBLE, val); + } + else + { + BigInteger val = null; + try{ val = new BigInteger(yytext()); } + catch(NumberFormatException e) + { + error("Number format exception <" + yytext() + ">"); + } + return symbol(sym.INT, val); + } + } + case 286: break; + default: + if (yy_input == YYEOF && yy_startRead == yy_currentPos) { + yy_atEOF = true; + yy_do_eof(); + { return symbol( sym.EOF ); + } + } + else { + yy_ScanError(YY_NO_MATCH); + } + } + } + } + + +} diff --git a/cali.lang.base/src/com/cali/Main.java b/cali.lang.base/src/com/cali/Main.java new file mode 100644 index 0000000..eb10b0f --- /dev/null +++ b/cali.lang.base/src/com/cali/Main.java @@ -0,0 +1,62 @@ +/* + * Copyright 2017 Austin Lehman + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.cali; + +/** + * Main class implements program entry point for command line + * usage. + * @author austin + */ +public class Main { + /** + * Command line program entry point. + * @param args is an array of Strings with the command line arguments. + * @throws Exception + */ + public static void main(String[] args) throws Exception { + if (args.length == 0) { + printUsage(); + System.out.println("\nError, incorrect number of arguments. Expecting script file name."); + } else { + // Create a new Cali engine. + Engine eng = new Engine(); + + // Sets debug output to true. + //eng.setDebug(true); + + // Parse the provided file name. + eng.parseFile(args[0]); + + // Prints the full parsed abastract syntax tree of all the sources. + //System.out.println(eng.toString()); + + // Attempt to run the code. + eng.run(); + } + } + + /** + * Prints the application usage to standard output. + */ + public static void printUsage() { + String rstr = ""; + rstr += "Cali-Lang Version 1.0\n"; + rstr += "Copyright 2017 Austin Lehman\n"; + rstr += "Apache License Version 2\n"; + System.out.println(rstr); + } +} \ No newline at end of file diff --git a/cali.lang.base/src/com/cali/Scanner.jflex b/cali.lang.base/src/com/cali/Scanner.jflex new file mode 100644 index 0000000..c3db8ad --- /dev/null +++ b/cali.lang.base/src/com/cali/Scanner.jflex @@ -0,0 +1,236 @@ +/* + * Copyright 2017 Austin Lehman + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.cali; + +import java.math.BigDecimal; +import java.math.BigInteger; + +import java_cup.runtime.Symbol; +import com.cali.stdlib.console; + +%% +%class Lexer +%cup +%extends sym +%unicode +%line +%column +%eofval{ + return symbol( sym.EOF ); +%eofval} + +%{ + StringBuffer string = new StringBuffer(); + + private Symbol symbol(int sym) { + return new Symbol(sym, yyline+1, yycolumn+1); + } + + private Symbol symbol(int sym, Object val) { + return new Symbol(sym, yyline+1, yycolumn+1, val); + } + + private void error(String message) { + console.get().err("Error at line "+(yyline+1)+", column "+(yycolumn+1)+" : "+message); + } +%} + +white_space = [ \t\f] +/* number = "-"? ({white_space}*)? [0-9]+ ("." [0-9]+)? */ +number = [0-9]+ ("." [0-9]+)? +letter = [A-Za-z] +digit = [0-9] +underscore = [_] +alphanumeric = {letter}|{digit} +//identifier = {letter}({alphanumeric}|{underscore})* +identifier = ({alphanumeric}|{underscore})* +//var = "$"+{identifier} +new_line = \r\n; + +%state C_COMMENT +%state STRING +%state STRING_FRMT +%state STRING_LIT + +%% + +/* single line comment */ + "//"[^\r\n]* { /* ignore */ } + +/* keywords */ + "class" { return symbol(sym.CLASSDEF); } + "enum" { return symbol(sym.ENUM); } + "include" { return symbol(sym.INCLUDE); } + "public" { return symbol(sym.PUBLIC); } + "protected" { return symbol(sym.PROTECTED); } + "private" { return symbol(sym.PRIVATE); } + "static" { return symbol(sym.STATIC); } + "extern" { return symbol(sym.EXTERN); } + "return" { return symbol(sym.RETURN); } + "try" { return symbol(sym.TRY); } + "catch" { return symbol(sym.CATCH); } + "throw" { return symbol(sym.THROW); } + "new" { return symbol(sym.NEW); } + "null" { return symbol(sym.NULL); } + "if" { return symbol(sym.IF); } + "else" { return symbol(sym.ELSE); } + "switch" { return symbol(sym.SWITCH); } + "case" { return symbol(sym.CASE); } + "default" { return symbol(sym.DEFAULT); } + "while" { return symbol(sym.WHILE); } + "break" { return symbol(sym.BREAK); } + "for" { return symbol(sym.FOR); } + "instanceof" { return symbol(sym.INSTANCEOF); } + + ";" { return symbol(sym.SEMI); } + ":" { return symbol(sym.COLON); } + "," { return symbol(sym.COMMA); } + "(" { return symbol(sym.LPAREN); } + ")" { return symbol(sym.RPAREN); } + "{" { return symbol(sym.LBRACKET); } + "}" { return symbol(sym.RBRACKET); } + "[" { return symbol(sym.LBRACE); } + "]" { return symbol(sym.RBRACE); } + + "=" { return symbol(sym.EQ); } + "+=" { return symbol(sym.PLEQ); } + "-=" { return symbol(sym.MIEQ); } + "*=" { return symbol(sym.MUEQ); } + "/=" { return symbol(sym.DIEQ); } + "%=" { return symbol(sym.MODULUSEQ); } + "++" { return symbol(sym.PLPL); } + "--" { return symbol(sym.MIMI); } + "+" { return symbol(sym.PL); } + "-" { return symbol(sym.MI); } + "*" { return symbol(sym.MU); } + "/" { return symbol(sym.DI); } + "%" { return symbol(sym.MODULUS); } + + "==" { return symbol(sym.EQEQ); } + "!=" { return symbol(sym.NOTEQ); } + "<" { return symbol(sym.LT); } + ">" { return symbol(sym.GT); } + "<=" { return symbol(sym.LTEQ); } + ">=" { return symbol(sym.GTEQ); } + "!" { return symbol(sym.NOT); } + "&&" { return symbol(sym.AND); } + "||" { return symbol(sym.OR); } + "true" { return symbol(sym.BOOL, true); } + "false" { return symbol(sym.BOOL, false); } + "..." { return symbol(sym.ETCETERA); } + "::" { return symbol(sym.CALLBACK); } + "#" { return symbol(sym.COUNT); } + "@=" { return symbol(sym.INSERT); } + + "." { return symbol(sym.DOT); } + + +{ + "/*" { yybegin(C_COMMENT); } + [\"]{3} { string.setLength(0); yybegin(STRING_FRMT); } + \" { string.setLength(0); yybegin(STRING); } + \' { string.setLength(0); yybegin(STRING_LIT); } + + /* Just slash n for *nix */ + "\n" { /* ignore */ } + "\r\n" { /* ignore */ } + {white_space} { /* ignore */ } + {number} { + if(yytext().contains(".")) + { + BigDecimal val = null; + try{ val = new BigDecimal(yytext()); } + catch(NumberFormatException e) + { + error("Number format exception <" + yytext() + ">"); + } + return symbol(sym.DOUBLE, val); + } + else + { + BigInteger val = null; + try{ val = new BigInteger(yytext()); } + catch(NumberFormatException e) + { + error("Number format exception <" + yytext() + ">"); + } + return symbol(sym.INT, val); + } + } + {identifier} { return symbol(sym.IDENT, yytext()); } +/* {var} { return symbol(sym.VAR, yytext()); } */ +} + + +{ + [\"]{3} { + yybegin(YYINITIAL); + return symbol(sym.STRING, string.toString()); + } + \\\"\\\"\\\" { string.append("\"\"\""); } + \t { string.append('\t'); } + \n { string.append('\n'); } + \r { string.append('\r'); } + \\\\ { string.append("\\"); } + . { string.append( yytext() ); } +} + + +{ + \" { + yybegin(YYINITIAL); + return symbol(sym.STRING, + string.toString()); + } + [^\n\r\"\\]+ { string.append( yytext() ); } + [\t\r\n]+ { /* Do nothing. */ } + \\t { string.append('\t'); } + \\n { string.append('\n'); } + + \\r { string.append('\r'); } + \\\" { string.append('\"'); } + \\\\ { string.append("\\"); } +} + + +{ + \' { + yybegin(YYINITIAL); + return symbol(sym.STRING, string.toString()); + } + [^\n\r\'\\]+ { string.append( yytext() ); } + [\t\r\n]+ { /* Do nothing. */ } + \\t { string.append('\t'); } + \\n { string.append('\n'); } + + \\r { string.append('\r'); } + \\\' { string.append('\''); } + \\\\ { string.append("\\"); } +} + + +{ + [^*\n]* { /* ignore */ } + "*"+[^*/\n]* { /* ignore */ } + "\n" { /* ignore */ } + "*"+"/" { yybegin(YYINITIAL); } +} + +/* error fallback */ +. { /* throw new Error("Illegal character <" + String.ValueOf((int)yytext()) + ">");*/ + error("Illegal character <" + String.valueOf((int)yytext().charAt(0)) + ">"); + } diff --git a/cali.lang.base/src/com/cali/Universe.java b/cali.lang.base/src/com/cali/Universe.java new file mode 100644 index 0000000..f6a68c6 --- /dev/null +++ b/cali.lang.base/src/com/cali/Universe.java @@ -0,0 +1,116 @@ +/* + * Copyright 2017 Austin Lehman + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.cali; + +import java.util.Map; +import java.util.concurrent.ConcurrentHashMap; +import com.cali.ast.astClass; +import com.cali.ast.caliException; +import com.cali.stdlib.Lang; + +/** + * Univers singleton object manages program global objects for Cali Engines. Engines + * are setup in a manner that allows for multiple Engine instances per program. The Univers + * provides a global mechanism for all of the Engines. + * @author austin + */ +public class Universe { + /** + * The single Universe instance. + */ + static Universe instance = null; + + /** + * Flag defineing if the univers has completed initialization yet or not. + */ + private boolean initialized = false; + + /** + * Defines the Cali version. + */ + private static final String version = "0.8b"; + + /** + * Map of class definitions. This is used to hold the base lang clases. It allows + * them to be parsed once and coppied to any subsequent Engine object when needed. + */ + private Map classes = new ConcurrentHashMap(); + + /** + * Default constructor set to private to defeat instantiation. See get to get an + * instance of the object. + */ + private Universe() { } + + /** + * Initializes the Universe object with the provided Engine. This function will use + * the provided engine to Parse the Lang.langSrc code if not already initialized. + * @param eng is an Engine object. + */ + public void init(Engine eng) { + if (!this.initialized) { + // Load native class definitions here! + try { + eng.parseString("lang.ca", Lang.langSrc); + this.classes = eng.getClasses(); + } catch (Exception e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + this.initialized = true; + } + } + + /** + * Gets a handle of the Universe object. + * @return + */ + public static Universe get() { + if(instance == null) instance = new Universe(); + return instance; + } + + /** + * Gets the Map of lang class definitions. + * @return a Map object with class definitions. + */ + public Map getClasses() { + return this.classes; + } + + /** + * Gets the class definition of the provided class name. + * @param Name is a String with the class name to get. + * @return A astClass class definition. + * @throws caliException + */ + public astClass getClassDef(String Name) throws caliException { + if (this.classes.containsKey(Name)) { + return this.classes.get(Name); + } else { + throw new caliException("Cali Universe: Freaking out, can't find requested class def '" + Name + "'."); + } + } + + /** + * Gets the Cali version. + * @return A String with the Cali version. + */ + public static String getCaliVersion() { + return version; + } +} diff --git a/cali.lang.base/src/com/cali/Util.java b/cali.lang.base/src/com/cali/Util.java new file mode 100644 index 0000000..6431f08 --- /dev/null +++ b/cali.lang.base/src/com/cali/Util.java @@ -0,0 +1,98 @@ +/* + * Copyright 2017 Austin Lehman + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.cali; + +import java.io.BufferedWriter; +import java.io.FileReader; +import java.io.FileWriter; +import java.io.IOException; +import java.util.ArrayList; + +/** + * Cali interpreter utility functions. + * @author austin + */ +public class Util { + /** + * Reads a file with the provided file name and returns it as + * a String. + * @param FileName is a String with the file name to read. + * @return A String with the file contents. + * @throws IOException + */ + public static String read(String FileName) throws IOException + { + FileReader fr = null; + try { + fr = new FileReader(FileName); + + int len = -1; + char[] buff = new char[4096]; + final StringBuffer buffer = new StringBuffer(); + while ((len = fr.read(buff)) > 0) { buffer.append(buff, 0, len); } + + return buffer.toString(); + } catch (IOException e) { + throw e; + } finally { + if(fr != null) { + try { fr.close(); } + catch (IOException e) { throw e; } + } + } + } + + /** + * Writes the provided String to file. If append is set to true, it will append + * the text to file, otherwise it will replace it if the file already exists. + * @param FileName is a String with the file name to save. + * @param Data is a String with the text data to write. + * @param Append is a boolean with true for append and false for not. + * @throws IOException + */ + public static void write(String FileName, String Data, boolean Append) throws IOException { + BufferedWriter bw = null; + try { + bw = new BufferedWriter(new FileWriter(FileName, Append)); + bw.write(Data); + } catch (IOException e) { + throw e; + } finally { + if(bw != null) { + try { bw.close(); } + catch (IOException e) { throw e; } + } + } + } + + /** + * Joins the provided list of strings with the provided glue string. + * @param parts is an ArrayList of Strings to join. + * @param Glue is a String with the glue. + * @return The combined String. + */ + public static String join(ArrayList parts, String Glue) { + StringBuilder sb = new StringBuilder(); + for (int i = 0; i < parts.size(); i++) { + if (i > 0) { + sb.append(Glue); + } + sb.append(parts.get(i)); + } + return sb.toString(); + } +} diff --git a/cali.lang.base/src/com/cali/ast/AccessType.java b/cali.lang.base/src/com/cali/ast/AccessType.java new file mode 100644 index 0000000..b5e39de --- /dev/null +++ b/cali.lang.base/src/com/cali/ast/AccessType.java @@ -0,0 +1,23 @@ +/* + * Copyright 2017 Austin Lehman + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.cali.ast; + +public enum AccessType { + aPrivate, + aProtected, + aPublic +} diff --git a/cali.lang.base/src/com/cali/ast/astBool.java b/cali.lang.base/src/com/cali/ast/astBool.java new file mode 100644 index 0000000..e1f47c4 --- /dev/null +++ b/cali.lang.base/src/com/cali/ast/astBool.java @@ -0,0 +1,76 @@ +/* + * Copyright 2017 Austin Lehman + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.cali.ast; + +import com.cali.Environment; +import com.cali.types.CaliBool; +import com.cali.types.CaliType; + + +public class astBool extends astNode implements astNodeInt +{ + private boolean value = false; + + public astBool() { + this.setType(astNodeType.BOOL); + } + + public astBool(boolean Value) { + this.setType(astNodeType.BOOL); + this.value = Value; + } + + public astBool(long Value) { + this.setType(astNodeType.BOOL); + if(Value == 0) this.value = false; + else this.value = true; + } + + public boolean getValueBool() { + return this.value; + } + + public String toString() { + return this.toString(0); + } + + public String toString(int Level) { + String rstr = ""; + rstr += getTabs(Level) + "{\n"; + rstr += this.getNodeStr(Level + 1) + ",\n"; + rstr += getTabs(Level + 1) + "\"value\": "; + if(value) rstr += "true"; + else rstr += "false"; + rstr += "\n"; + if(this.getChild() != null) { + rstr += getTabs(Level + 1) + "\"child\":\n"; + rstr += ((astNodeInt)this.getChild()).toString(Level + 1) + ",\n"; + } + rstr += getTabs(Level) + "}"; + return rstr; + } + + @Override + public CaliType evalImpl(Environment env, boolean getref) throws caliException { + CaliType ret = new CaliBool(this.value); + if (this.getChild() != null) { + Environment tenv = env.clone(ret); + return this.getChild().eval(tenv, getref); + } + return ret; + } +} diff --git a/cali.lang.base/src/com/cali/ast/astBreak.java b/cali.lang.base/src/com/cali/ast/astBreak.java new file mode 100644 index 0000000..3e65802 --- /dev/null +++ b/cali.lang.base/src/com/cali/ast/astBreak.java @@ -0,0 +1,45 @@ +/* + * Copyright 2017 Austin Lehman + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.cali.ast; + +import com.cali.Environment; +import com.cali.types.CaliBreak; +import com.cali.types.CaliType; + +public class astBreak extends astNode implements astNodeInt { + public astBreak() { + this.setType(astNodeType.BREAK); + } + + public String toString() { + return this.toString(0); + } + + @Override + public String toString(int Level) { + String rstr = ""; + rstr += getTabs(Level) + "{\n"; + rstr += this.getNodeStr(Level + 1) + "\n"; + rstr += getTabs(Level) + "}"; + return rstr; + } + + @Override + public CaliType evalImpl(Environment env, boolean getref) throws caliException { + return new CaliBreak(); + } +} diff --git a/cali.lang.base/src/com/cali/ast/astCallback.java b/cali.lang.base/src/com/cali/ast/astCallback.java new file mode 100644 index 0000000..45c33fe --- /dev/null +++ b/cali.lang.base/src/com/cali/ast/astCallback.java @@ -0,0 +1,67 @@ +/* + * Copyright 2017 Austin Lehman + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.cali.ast; + +import com.cali.Environment; +import com.cali.types.CaliCallback; +import com.cali.types.CaliObject; +import com.cali.types.CaliType; + +public class astCallback extends astNode implements astNodeInt { + private String functName = ""; + + public astCallback() { + this.setType(astNodeType.CALLBACK); + } + + public astCallback(String FunctName) { + this.setType(astNodeType.CALLBACK); + this.functName = FunctName; + } + + @Override + public String toString(int Level) { + String rstr = ""; + rstr += getTabs(Level) + "{\n"; + rstr += this.getNodeStr(Level + 1) + ",\n"; + rstr += getTabs(Level + 1) + "\"functName\":\"" + this.functName + "\"\n"; + if(this.getChild() != null) { + rstr += getTabs(Level + 1) + "\"child\":\n"; + rstr += ((astNodeInt)this.getChild()).toString(Level + 1) + ",\n"; + } + rstr += getTabs(Level) + "}"; + return rstr; + } + + @Override + public CaliType evalImpl(Environment env, boolean getref) throws caliException { + CaliType ret = new CaliCallback(env, (CaliObject)env.getClassInstance(), this.functName); + if (this.getChild() != null) { + Environment tenv = env.clone(ret); + return this.getChild().eval(tenv, getref); + } + return ret; + } + + public String getFunctName() { + return functName; + } + + public void setFunctName(String functName) { + this.functName = functName; + } +} diff --git a/cali.lang.base/src/com/cali/ast/astClass.java b/cali.lang.base/src/com/cali/ast/astClass.java new file mode 100644 index 0000000..b0206ad --- /dev/null +++ b/cali.lang.base/src/com/cali/ast/astClass.java @@ -0,0 +1,451 @@ +/* + * Copyright 2017 Austin Lehman + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.cali.ast; + +import java.util.ArrayList; +import java.util.List; +import java.util.Map; +import java.util.concurrent.ConcurrentHashMap; + +import com.cali.CallStack; +import com.cali.Engine; +import com.cali.Environment; +import com.cali.types.CaliBool; +import com.cali.types.CaliDouble; +import com.cali.types.CaliException; +import com.cali.types.CaliException.exType; +import com.cali.types.CaliInt; +import com.cali.types.CaliList; +import com.cali.types.CaliMap; +import com.cali.types.CaliNull; +import com.cali.types.CaliObject; +import com.cali.types.CaliString; +import com.cali.types.CaliType; +import com.cali.types.Members; + +public class astClass extends astNode implements astNodeInt { + + // Is the class static. + private boolean isStatic = false; + + // Is the class external. + private boolean isExtern = false; + + // External class name. + private String externClassName = ""; + + // List of extended class names. + private ArrayList extendedClasses = new ArrayList(); + + // Constructor definition. + private astFunctDef constructor = null; + + // External class reverence. + @SuppressWarnings("rawtypes") + private Class externClass = null; + + // Class members. + private List membList = new ArrayList(); + private Map membDefs = new ConcurrentHashMap(); + + // Class functions. + private List functList = new ArrayList(); + private Map functDefs = new ConcurrentHashMap(); + + // Inherited members and functions are kept track of so we can + // reproduce the AST later. + private List inheritedMembers = new ArrayList(); + private List inheritedFuncts = new ArrayList(); + + /** + * Default constructor. + */ + public astClass() { + this.setType(astNodeType.CLASS); + } + + /** + * Creates a new class. + * @param Name A string with the class name. + */ + public astClass(String Name) { + this.setType(astNodeType.CLASS); + this.setName(Name); + } + + public void addMember(String Name, astNode Value) { + this.membList.add(Name); + this.membDefs.put(Name, Value); + } + + public boolean containsMember(String Name) { + return this.membDefs.containsKey(Name); + } + + public astNode getMember(String Name) { + return this.membDefs.get(Name); + } + + public Map getMembers() { + return this.membDefs; + } + + public void addFunction(String Name, astNode Value) { + this.functList.add(Name); + this.functDefs.put(Name, Value); + } + + public boolean containsFunction(String Name) { + return this.functDefs.keySet().contains(Name); + } + + public astNode getFunct(String Name) { + return this.functDefs.get(Name); + } + + /* + * Run functions + */ + public CaliType instantiate(Environment env) throws caliException { + return this.instantiate(env, true, new CaliList()); + } + + public CaliType instantiate(Environment env, boolean getRef, CaliList args) throws caliException { + CaliObject ci; + if (this.isExtern) { + ci = (CaliObject) instantiateExtern(); + } else { + ci = new CaliObject(); + } + ci.setClassDef(this); + + // Instantiated inherited classes. + this.instantiateInheritedClasses(env, ci); + + // Instantiate members. + this.instantiateMembers(env, ci); + + /* + * Call constructor. + */ + if(this.constructor != null) { + CallStack constStack = new CallStack(); + Environment tenv = new Environment(env.getEngine()); + tenv.setEnvironment(ci, env.getLocals(), constStack); + CaliType ret = this.call(tenv, getRef, getName(), args); + if (ret.isEx()) { + return ret; + } + } + + return ci; + } + + public void instantiateMembers(Environment env, CaliObject ci) throws caliException { + for (int i = 0; i < this.membList.size(); i++) { + astNode cur = this.membDefs.get(this.membList.get(i)); + switch(cur.getType()) { + case VAR: + ci.addMember(cur.getName(), cur.eval(env)); + break; + case BOOL: + ci.addMember(cur.getName(), cur.eval(env)); + break; + case INT: + ci.addMember(cur.getName(), cur.eval(env)); + break; + case DOUBLE: + ci.addMember(cur.getName(), cur.eval(env)); + break; + case STRING: + ci.addMember(cur.getName(), cur.eval(env)); + break; + case OBJ: + ci.addMember(cur.getName(), cur.eval(env)); + break; + case LIST: + ci.addMember(cur.getName(), cur.eval(env)); + break; + case MAP: + ci.addMember(cur.getName(), cur.eval(env)); + break; + case NULL: + ci.addMember(cur.getName(), cur.eval(env)); + break; + default: + throw new caliException("astClass.instantiateMembers(): Unexpected node type '" + cur.getType().name() + "' found."); + } + } + } + + public CaliType call (Environment env, boolean getRef, String functName, CaliList args) throws caliException { + CaliType ret = new CaliNull(); + + if (this.functDefs.containsKey(functName)) { + astFunctDef fdef = (astFunctDef) this.functDefs.get(functName); + // Local function variables and objects + Members locals = new Members(); + Environment tenv = new Environment(env.getEngine()); + CaliObject ci = env.getClassInstance(); + + + if (env.getCurObj() != null && env.getCurObj() instanceof CaliObject) { + ci = (CaliObject) env.getCurObj(); + } + tenv.setEnvironment(ci, locals, env.getCallStack()); + if(fdef.getExtern()) { + CaliType tmp = ((astFunctDef)this.functDefs.get(functName)).initArgs(tenv, args); + if(!tmp.isEx()) { + //ret = env.getClassInstance().externMod.call(functName, args); + + ret = fdef.callExtern(tenv, args); + /* + * Check ret for exception now. + */ + } else { + ret = tmp; + } + } else { + ret = ((astFunctDef)this.functDefs.get(functName)).call(tenv, getRef, args, this.getFileName()); + } + } else { + CaliException ce = new CaliException(exType.exRuntime); + ce.setText("Object '" + this.getName() + "' doesn't have function '" + functName + "'."); + ret = ce; + } + + return ret; + } + + private void instantiateInheritedClasses(Environment env, CaliObject cobj) throws caliException { + boolean foundExtern = false; + + for(String className : this.extendedClasses) { + astClass ac = env.getClassByName(className); + if(ac != null) { + if(ac.getExtern()) { + if(foundExtern) { + throw new caliException(this, "Cannot inherit from two external classes.", env.stackTraceToString()); + } + + foundExtern = true; + this.isExtern = true; + this.externClassName = ac.getExternClassName(); + this.externClass = ac.getExternClass(); + + CaliObject ao = (CaliObject) ac.instantiate(env); + if(ao != null) { + cobj.setExternObject(ao.getExternObject()); + } else { + throw new caliException(this, "Failed to instantiate class '" + className + "', object is null.", env.stackTraceToString()); + } + } + + ac.instantiateMembers(env, cobj); + + for(String key : ac.getFuncts().keySet()) { + // If the child most class doesn't contain the function, add it. (This allows overwrite functionality.) + if(!this.functDefs.containsKey(key)) { + this.functDefs.put(key, ac.getFuncts().get(key)); + this.inheritedFuncts.add(key); + } + } + + } else { + throw new caliException(this, "Extended class '" + className + "' not found.", env.stackTraceToString()); + } + } + + } + + private CaliType instantiateExtern() throws caliException { + boolean primType = true; + CaliObject obj; + + // Instantiate native type, or generic object. + if (this.getName().equals("bool")) { + obj = new CaliBool(); + } else if (this.getName().equals("int")) { + obj = new CaliInt(); + } else if (this.getName().equals("double")) { + obj = new CaliDouble(); + } else if (this.getName().equals("string")) { + obj = new CaliString(); + } else if (this.getName().equals("list")) { + obj = new CaliList(); + } else if (this.getName().equals("map")) { + obj = new CaliMap(); + } else { + primType = false; + obj = new CaliObject(); + } + + obj.setClassDef(this); + + if (primType) { + obj.setExternObject(obj); + } else { + try { + obj.setExternObject(this.externClass.newInstance()); + } catch (SecurityException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (InstantiationException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (IllegalAccessException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (IllegalArgumentException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + } + + return obj; + } + + private void loadExternClass() { + ClassLoader cl = Engine.class.getClassLoader(); + try { + this.externClass = cl.loadClass(this.externClassName); + } catch (ClassNotFoundException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (SecurityException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (IllegalArgumentException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + } + + + @Override + public String toString() { + return this.toString(0); + } + + public String toString(int Level) { + String rstr = ""; + rstr += getTabs(Level) + "{\n"; + rstr += this.getNodeStr(Level + 1) + ",\n"; + rstr += getTabs(Level + 1) + "\"fileName\": \"" + this.getFileName() + "\",\n"; + rstr += getTabs(Level + 1) + "\"modRef\": \"" + this.externClassName + "\",\n"; + rstr += getTabs(Level + 1) + "\"static\": \"" + this.isStatic + "\",\n"; + rstr += getTabs(Level + 1) + "\"extern\": \"" + this.isExtern + "\",\n"; + + rstr += getTabs(Level + 1) + "\"definitions\": [\n"; + for(int i = 0; i < this.membList.size(); i++) + rstr += ((astNodeInt)this.membDefs.get(this.membList.get(i))).toString(Level + 2) + ",\n"; + rstr += getTabs(Level + 1) + "],\n"; + + if(this.constructor != null) + { + rstr += getTabs(Level + 1) + "\"constructor\":\n"; + rstr += this.constructor.toString(Level + 1) + ",\n"; + } + + rstr += getTabs(Level + 1) + "\"functionDefinitions\": [\n"; + for(int i = 0; i < this.functList.size(); i++) + rstr += ((astNodeInt)this.functDefs.get(this.functList.get(i))).toString(Level + 2) + ",\n"; + rstr += getTabs(Level + 1) + "],\n"; + + rstr += getTabs(Level) + "}"; + return rstr; + } + + public boolean hasMain() { + if(this.functDefs.containsKey("main")) + return true; + return false; + } + + public void setInheritedMembers(ArrayList InheritedMembers) { this.inheritedMembers = InheritedMembers; } + public List getInheritedMembers() { return this.inheritedMembers; } + + public void setInheritedFuncts(ArrayList InheritedFuncts) { this.inheritedFuncts = InheritedFuncts; } + public List getInheritedFuncts() { return this.inheritedFuncts; } + + public boolean getStatic() { + return isStatic; + } + + public void setStatic(boolean isStatic) { + this.isStatic = isStatic; + } + + public boolean getExtern() { + return isExtern; + } + + public void setExtern(boolean isExtern) { + this.isExtern = isExtern; + } + + public String getExternClassName() { + return externClassName; + } + + public void setExternClassName(String externClass) { + this.externClassName = externClass; + this.loadExternClass(); + } + + @SuppressWarnings("rawtypes") + public void setExternClass(Class C) { this.externClass = C; } + + @SuppressWarnings("rawtypes") + public Class getExternClass() { return this.externClass; } + + @Override + public CaliType evalImpl(Environment env, boolean getref) { + return new CaliNull(); + } + + public ArrayList getExtendedClasses() { + return extendedClasses; + } + + public void setExtendedClasses(ArrayList extendedClasses) { + this.extendedClasses = extendedClasses; + } + + public astFunctDef getConstructor() { + return constructor; + } + + public void setConstructor(astFunctDef constructor) { + this.constructor = constructor; + } + + public boolean instanceOf(String Name) { + if (this.getName().equals(Name)) { + return true; + } else if (this.extendedClasses.contains(Name)) { + return true; + } else if (this.getName().equals("cnull") && Name.equals("null")) { + return true; + } + return false; + } + + public Map getFuncts() { + return this.functDefs; + } +} diff --git a/cali.lang.base/src/com/cali/ast/astConditionBlock.java b/cali.lang.base/src/com/cali/ast/astConditionBlock.java new file mode 100644 index 0000000..e0476f0 --- /dev/null +++ b/cali.lang.base/src/com/cali/ast/astConditionBlock.java @@ -0,0 +1,85 @@ +/* + * Copyright 2017 Austin Lehman + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.cali.ast; + +import com.cali.Environment; +import com.cali.types.CaliNull; +import com.cali.types.CaliType; + +public class astConditionBlock extends astNode implements astNodeInt { + private astNode expr = null; + private astStatementList instructionList = new astStatementList(); + + public astConditionBlock() { + this.setType(astNodeType.CONDITION); + } + + public void setExpression(astNode Expr) { this.expr = Expr; } + public astNode getExpression() { return this.expr; } + + public void addToInstructionList(astNode Inst) { + this.instructionList.getStatements().add(Inst); + } + + public String toString() { + return this.toString(0); + } + + @Override + public String toString(int Level) { + String rstr = ""; + + rstr += getTabs(Level) + "{\n"; + rstr += this.getNodeStr(Level + 1) + ",\n"; + + if(this.expr != null) { + rstr += getTabs(Level + 1) + "\"expression\":\n"; + rstr += ((astNodeInt)this.expr).toString(Level + 1) + ",\n"; + } + + if(this.instructionList != null) { + rstr += getTabs(Level + 1) + "\"statementList\":\n"; + rstr += this.instructionList.toString(Level + 1) + ",\n"; + } + + rstr += getTabs(Level) + "}"; + return rstr; + } + + @Override + public CaliType evalImpl(Environment env, boolean getref) throws caliException { + CaliType ret = new CaliNull(); + CaliType tmp = new CaliNull(); + + for(astNode inst : this.instructionList.getStatements()) { + tmp = inst.eval(env, getref); + if(astNode.isBreakReturnEvent(tmp)) { + ret = tmp; + break; + } + } + return ret; + } + + public astStatementList getInstructionList() { + return instructionList; + } + + public void setInstructionList(astStatementList instructionList) { + this.instructionList = instructionList; + } +} diff --git a/cali.lang.base/src/com/cali/ast/astDouble.java b/cali.lang.base/src/com/cali/ast/astDouble.java new file mode 100644 index 0000000..3cb4e3c --- /dev/null +++ b/cali.lang.base/src/com/cali/ast/astDouble.java @@ -0,0 +1,66 @@ +/* + * Copyright 2017 Austin Lehman + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.cali.ast; + +import com.cali.Environment; +import com.cali.types.CaliDouble; +import com.cali.types.CaliType; + + +public class astDouble extends astNode implements astNodeInt { + private double value = 0.0; + + public astDouble() { + this.setType(astNodeType.DOUBLE); + } + + public astDouble(double Value) { + this.setType(astNodeType.DOUBLE); + this.value = Value; + } + + public double getValueDouble() { + return this.value; + } + + public String toString() { + return this.toString(0); + } + + public String toString(int Level) { + String rstr = ""; + rstr += getTabs(Level) + "{\n"; + rstr += this.getNodeStr(Level + 1) + ",\n";; + rstr += getTabs(Level + 1) + "\"value\": " + this.value + "\n"; + if(this.getChild() != null) { + rstr += getTabs(Level + 1) + "\"child\":\n"; + rstr += ((astNodeInt)this.getChild()).toString(Level + 1) + ",\n"; + } + rstr += getTabs(Level) + "}"; + return rstr; + } + + @Override + public CaliType evalImpl(Environment env, boolean getref) throws caliException { + CaliType ret = new CaliDouble(this.value); + if (this.getChild() != null) { + Environment tenv = env.clone(ret); + return this.getChild().eval(tenv, getref); + } + return ret; + } +} diff --git a/cali.lang.base/src/com/cali/ast/astEtcetera.java b/cali.lang.base/src/com/cali/ast/astEtcetera.java new file mode 100644 index 0000000..e01e392 --- /dev/null +++ b/cali.lang.base/src/com/cali/ast/astEtcetera.java @@ -0,0 +1,45 @@ +/* + * Copyright 2017 Austin Lehman + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.cali.ast; + +import com.cali.Environment; +import com.cali.types.CaliType; + +public class astEtcetera extends astVar implements astNodeInt { + public astEtcetera() { + this.setType(astNodeType.ETCETERA); + } + + public String toString() { + return this.toString(0); + } + + @Override + public String toString(int Level) { + String rstr = ""; + rstr += getTabs(Level) + "{\n"; + rstr += this.getNodeStr(Level + 1) + ",\n";; + rstr += getTabs(Level + 1) + "\"primType\": " + this.getPrimType().name() + "\n"; + rstr += getTabs(Level) + "}"; + return rstr; + } + + @Override + public CaliType evalImpl(Environment env, boolean getref) throws caliException { + throw new caliException("evalImpl() called on astEtcetera. This shouldn't happen!"); + } +} diff --git a/cali.lang.base/src/com/cali/ast/astExpression.java b/cali.lang.base/src/com/cali/ast/astExpression.java new file mode 100644 index 0000000..3d51741 --- /dev/null +++ b/cali.lang.base/src/com/cali/ast/astExpression.java @@ -0,0 +1,963 @@ +/* + * Copyright 2017 Austin Lehman + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.cali.ast; + +import com.cali.Environment; +import com.cali.types.CaliBool; +import com.cali.types.CaliDouble; +import com.cali.types.CaliException; +import com.cali.types.CaliException.exType; +import com.cali.types.CaliInt; +import com.cali.types.CaliList; +import com.cali.types.CaliMap; +import com.cali.types.CaliNull; +import com.cali.types.CaliObject; +import com.cali.types.CaliRef; +import com.cali.types.CaliString; +import com.cali.types.CaliType; +import com.cali.types.CaliTypeInt; +import com.cali.types.cType; + +public class astExpression extends astNode implements astNodeInt { + private astNode left = null; + private astNode right = null; + private expType eType = expType.UNDEF; + + public astExpression() { + this.setType(astNodeType.EXP); + } + + public astExpression(astNode Left) { + this.setType(astNodeType.EXP); + this.setLeft(Left); + } + + @Override + public String toString() { + return this.toString(0); + } + + @Override + public String toString(int Level) { + String rstr = ""; + rstr += getTabs(Level) + "{\n"; + rstr += this.getNodeStr(Level + 1) + ",\n"; + rstr += getTabs(Level + 1) + "\"eType\": \"" + this.eType.name() + "\"\n"; + if(this.left != null) { + rstr += getTabs(Level + 1) + "\"left\":\n"; + rstr += ((astNodeInt)this.left).toString(Level + 1) + ",\n"; + } + if(this.right != null) { + rstr += getTabs(Level + 1) + "\"right\":\n"; + rstr += ((astNodeInt)this.right).toString(Level + 1) + ",\n"; + } + if (this.getChild() != null) { + rstr += getTabs(Level + 1) + "\"child\":\n"; + rstr += ((astNodeInt)this.getChild()).toString(Level + 1) + ",\n"; + } + rstr += getTabs(Level) + "}"; + return rstr; + } + + public astNode getLeft() { + return left; + } + + public void setLeft(astNode left) { + this.left = left; + } + + public astNode getRight() { + return right; + } + + public void setRight(astNode right) { + this.right = right; + } + + public expType geteType() { + return eType; + } + + public void seteType(expType eType) { + this.eType = eType; + } + + @Override + public CaliType evalImpl(Environment env, boolean getRef) throws caliException { + CaliType ret = new CaliNull(); + + if((this.left != null)&&(this.right != null)) { + switch(this.eType) { + case ASSIGNMENT: { + ret = this.assignment(env, getRef); + break; + } case ADD: { + ret = this.oper(env, getRef); + break; + } case SUBTRACT: { + ret = this.oper(env, getRef); + break; + } case MULTIPLY: { + ret = this.oper(env, getRef); + break; + } case DIVIDE: { + ret = this.oper(env, getRef); + break; + } case MODULUS: { + ret = this.oper(env, getRef); + break; + } case EQEQ: { + ret = this.oper(env, getRef); + break; + } case NOTEQ: { + ret = this.oper(env, getRef); + break; + } case LT: { + ret = this.oper(env, getRef); + break; + } case GT: { + ret = this.oper(env, getRef); + break; + } case LTEQ: { + ret = this.oper(env, getRef); + break; + } case GTEQ: { + ret = this.oper(env, getRef); + break; + } case AND: { + ret = this.oper(env, getRef); + break; + } case OR: { + ret = this.oper(env, getRef); + break; + } case INSERT: { + ret = this.oper(env, getRef); + break; + } case INSTANCEOF: { + ret = this.oper(env, getRef); + break; + } case PLEQ: { + ret = this.operEquals(env, getRef); + break; + } case MIEQ: { + ret = this.operEquals(env, getRef); + break; + } case MUEQ: { + ret = this.operEquals(env, getRef); + break; + } case DIEQ: { + ret = this.operEquals(env, getRef); + break; + } default: { + CaliException e = new CaliException(exType.exInternal); + e.setException(this.getLineNum(), "UNDEFINED_EXPRESSION", "Undefined expression '" + this.eType.name() + "' found. (aExp::call)", "Undefined expression '" + this.eType.name() + "' found. (aExp::call)", env.getCallStack().getStackTrace()); + ret = e; + break; + } + } + } else if(this.left != null) { + switch(this.eType) { + case PLPL: { + ret = this.operIncDec(env, getRef); + break; + } case MIMI: { + ret = this.operIncDec(env, getRef); + break; + } case NOT: { + ret = this.operLeft(env, getRef); + break; + } case COUNT: { + ret = this.operLeft(env, getRef); + break; + } case INCLUDE: { + ret = this.operLeft(env, getRef); + break; + } default: { + CaliException e = new CaliException(exType.exInternal); + e.setException(this.getLineNum(), "UNDEFINED_EXPRESSION", "Undefined expression '" + this.eType.name() + "' found. (aExp::call)", "Undefined expression '" + this.eType.name() + "' found. (aExp::call)", env.getCallStack().getStackTrace()); + ret = e; + break; + } + } + } + + // If child is defined, evaluate it as well. + if (this.getChild() != null) { + Environment tenv = env; + if (ret instanceof CaliObject || ret.getType() == cType.cMap || ret.getType() == cType.cList) { + tenv = env.clone(ret); + } + ret = this.getChild().eval(tenv, getRef); + } + + + return ret; + } + + private CaliType assignment(Environment env, boolean getRef) throws caliException { + CaliType ret = new CaliNull(); + + CaliType lres = this.left.eval(env, true); + if (!lres.isEx()) { + if (lres.getType() == cType.cRef) { + CaliRef ref = (CaliRef)lres; + CaliType rval = this.right.eval(env, getRef); + if (!rval.isEx()) { + ref.assign(rval); + ret = rval; + } else { + ret = rval; + } + } else { + CaliException e = new CaliException(exType.exRuntime); + e.setException(this.getLineNum(), "ASSIGN_NOT_POSSIBLE", "astExpression.assignment(): Left side of assignment expression returned an object of type '" + lres.getType().name() + "' which can't be assigned.", env.getCallStack().getStackTrace()); + return e; + } + } else { + ret = lres; + } + return ret; + } + + private CaliType oper(Environment env, boolean getRef) throws caliException { + CaliType ret = new CaliNull(); + + CaliType r_left = left.eval(env, getRef); + if(!r_left.isEx()) { + CaliType r_right = right.eval(env, getRef); + if(!r_right.isEx()) { + switch(this.eType) { + case ADD: { + ret = evalPlus(env, r_left, r_right); + break; + } case SUBTRACT: { + ret = evalMinus(env, r_left, r_right); + break; + } case MULTIPLY: { + ret = evalMult(env, r_left, r_right); + break; + } case DIVIDE: { + ret = evalDiv(env, r_left, r_right); + break; + } case MODULUS: { + ret = evalModulus(env, r_left, r_right); + break; + } case EQEQ: { + ret = evalEqualsEquals(env, r_left, r_right); + break; + } case NOTEQ: { + ret = evalNotEquals(env, r_left, r_right); + break; + } case LT: { + ret = evalLessThan(env, r_left, r_right); + break; + } case GT: { + ret = evalGreaterThan(env, r_left, r_right); + break; + } case LTEQ: { + ret = evalLessThanEquals(env, r_left, r_right); + break; + } case GTEQ: { + ret = evalGreaterThanEquals(env, r_left, r_right); + break; + } case AND: { + ret = evalAnd(env, r_left, r_right); + break; + } case OR: { + ret = evalOr(env, r_left, r_right); + break; + } case INSERT: { + ret = evalInsert(env, r_left, r_right); + break; + } case INSTANCEOF: { + ret = evalInstanceOf(env, r_left, r_right); + break; + } default: { + CaliException e = new CaliException(exType.exInternal); + e.setException(this.getLineNum(), "UNDEFINED_EXPRESSION", "Undefined operator expression '" + this.eType.name() + "' found. (aExp::call)", "Undefined operator expression '" + this.eType.name() + "' found. (aExp::call)", env.getCallStack().getStackTrace()); + ret = e; + break; + } + } + } else { + ret = r_right; + } + } else { + ret = r_left; + } + + return ret; + } + + private CaliType evalPlus(Environment env, CaliType r_left, CaliType r_right) { + CaliType ret = new CaliNull(); + + // Let's do actual addition. + if (this.isNumber(r_left) && this.isNumber(r_right)) { + if (this.isInt(r_left) && this.isInt(r_right)) { + ret = new CaliInt(this.getValueInt(r_left) + this.getValueInt(r_right)); + } else if (this.isInt(r_left)) { + ret = new CaliDouble((double)this.getValueInt(r_left) + ((CaliDouble)r_right).getValue()); + } else if (this.isInt(r_right)) { + ret = new CaliDouble(((CaliDouble)r_left).getValue() + (double)this.getValueInt(r_right)); + } else { + ret = new CaliDouble(((CaliDouble)r_left).getValue() + ((CaliDouble)r_right).getValue()); + } + } + + // Otherwise, we are going to treat as concatenation. + else { + ret = new CaliString(((CaliTypeInt)r_left).str() + ((CaliTypeInt)r_right).str()); + } + + return ret; + } + + private CaliType evalMinus(Environment env, CaliType r_left, CaliType r_right) { + CaliType ret = new CaliNull(); + + if (this.isNumber(r_left) && this.isNumber(r_right)) { + if (this.isInt(r_left) && this.isInt(r_right)) { + ret = new CaliInt(this.getValueInt(r_left) - this.getValueInt(r_right)); + } else if (this.isInt(r_left)) { + ret = new CaliDouble((double)this.getValueInt(r_left) - ((CaliDouble)r_right).getValue()); + } else if (this.isInt(r_right)) { + ret = new CaliDouble(((CaliDouble)r_left).getValue() - (double)this.getValueInt(r_right)); + } else { + ret = new CaliDouble(((CaliDouble)r_left).getValue() - ((CaliDouble)r_right).getValue()); + } + } else { + if (!this.isNumber(r_left)) { + CaliException e = new CaliException(exType.exRuntime); + e.setException(getLineNum(), "INVALID_EXPRESSION", "astExpression.evalMinus(): Left side of expression isn't a number.", env.getCallStack().getStackTrace()); + return e; + } else { + CaliException e = new CaliException(exType.exRuntime); + e.setException(getLineNum(), "INVALID_EXPRESSION", "astExpression.evalMinus(): Right side of expression isn't a number.", env.getCallStack().getStackTrace()); + return e; + } + } + + return ret; + } + + private CaliType evalMult(Environment env, CaliType r_left, CaliType r_right) { + CaliType ret = new CaliNull(); + + if (this.isNumber(r_left) && this.isNumber(r_right)) { + if (this.isInt(r_left) && this.isInt(r_right)) { + ret = new CaliInt(this.getValueInt(r_left) * this.getValueInt(r_right)); + } else if (this.isInt(r_left)) { + ret = new CaliDouble((double)this.getValueInt(r_left) * ((CaliDouble)r_right).getValue()); + } else if (this.isInt(r_right)) { + ret = new CaliDouble(((CaliDouble)r_left).getValue() * (double)this.getValueInt(r_right)); + } else { + ret = new CaliDouble(((CaliDouble)r_left).getValue() * ((CaliDouble)r_right).getValue()); + } + } else { + if (!this.isNumber(r_left)) { + CaliException e = new CaliException(exType.exRuntime); + e.setException(getLineNum(), "INVALID_EXPRESSION", "astExpression.evalMult(): Left side of expression isn't a number.", env.getCallStack().getStackTrace()); + return e; + } else { + CaliException e = new CaliException(exType.exRuntime); + e.setException(getLineNum(), "INVALID_EXPRESSION", "astExpression.evalMult(): Right side of expression isn't a number.", env.getCallStack().getStackTrace()); + return e; + } + } + + return ret; + } + + private CaliType evalDiv(Environment env, CaliType r_left, CaliType r_right) { + CaliType ret = new CaliNull(); + + if (this.isNumber(r_left) && this.isNumber(r_right)) { + if (r_right.getType() == cType.cInt && this.getValueInt(r_right) == 0) { + CaliException e = new CaliException(exType.exRuntime); + e.setException(getLineNum(), "DIV_BY_0", "astExpression.evailDiv(): Division by 0 exception.", env.getCallStack().getStackTrace()); + return e; + } else if (r_right.getType() == cType.cDouble && ((CaliDouble)r_right).getValue() == 0.0) { + CaliException e = new CaliException(exType.exRuntime); + e.setException(getLineNum(), "DIV_BY_0", "astExpression.evailDiv(): Division by 0 exception.", env.getCallStack().getStackTrace()); + return e; + } else { + if (this.isInt(r_left) && this.isInt(r_right)) { + ret = new CaliDouble((double)this.getValueInt(r_left) / (double)this.getValueInt(r_right)); + } else if (this.isInt(r_left)) { + ret = new CaliDouble((double)this.getValueInt(r_left) / ((CaliDouble)r_right).getValue()); + } else if (this.isInt(r_right)) { + ret = new CaliDouble(((CaliDouble)r_left).getValue() / (double)this.getValueInt(r_right)); + } else { + ret = new CaliDouble(((CaliDouble)r_left).getValue() / ((CaliDouble)r_right).getValue()); + } + } + } else { + if (!this.isNumber(r_left)) { + CaliException e = new CaliException(exType.exRuntime); + e.setException(getLineNum(), "INVALID_EXPRESSION", "astExpression.evailDiv(): Left side of expression isn't a number.", env.getCallStack().getStackTrace()); + return e; + } else { + CaliException e = new CaliException(exType.exRuntime); + e.setException(getLineNum(), "INVALID_EXPRESSION", "astExpression.evailDiv(): Right side of expression isn't a number.", env.getCallStack().getStackTrace()); + return e; + } + } + + return ret; + } + + private CaliType evalModulus(Environment env, CaliType r_left, CaliType r_right) { + CaliType ret = new CaliNull(); + + if (this.isNumber(r_left) && this.isNumber(r_right)) { + if (r_right.getType() == cType.cInt && this.getValueInt(r_right) == 0) { + CaliException e = new CaliException(exType.exRuntime); + e.setException(getLineNum(), "DIV_BY_0", "astExpression.evailModulus(): Division by 0 exception.", env.getCallStack().getStackTrace()); + return e; + } else if (r_right.getType() == cType.cDouble && ((CaliDouble)r_right).getValue() == 0.0) { + CaliException e = new CaliException(exType.exRuntime); + e.setException(getLineNum(), "DIV_BY_0", "astExpression.evailModulus(): Division by 0 exception.", env.getCallStack().getStackTrace()); + return e; + } else { + if (this.isInt(r_left) && this.isInt(r_right)) { + ret = new CaliDouble((double)this.getValueInt(r_left) % (double)this.getValueInt(r_right)); + } else if (this.isInt(r_left)) { + ret = new CaliDouble((double)this.getValueInt(r_left) % ((CaliDouble)r_right).getValue()); + } else if (this.isInt(r_right)) { + ret = new CaliDouble(((CaliDouble)r_left).getValue() % (double)this.getValueInt(r_right)); + } else { + ret = new CaliDouble(((CaliDouble)r_left).getValue() % ((CaliDouble)r_right).getValue()); + } + } + } else { + if (!this.isNumber(r_left)) { + CaliException e = new CaliException(exType.exRuntime); + e.setException(getLineNum(), "INVALID_EXPRESSION", "astExpression.evailModulus(): Left side of expression isn't a number.", env.getCallStack().getStackTrace()); + return e; + } else { + CaliException e = new CaliException(exType.exRuntime); + e.setException(getLineNum(), "INVALID_EXPRESSION", "astExpression.evailModulus(): Right side of expression isn't a number.", env.getCallStack().getStackTrace()); + return e; + } + } + + return ret; + } + + private CaliType evalEqualsEquals(Environment env, CaliType r_left, CaliType r_right) { + CaliType ret = new CaliNull(); + + if (this.isNumber(r_left) && this.isNumber(r_right)) { + if (this.isInt(r_left) && this.isInt(r_right)) { + if (this.getValueInt(r_left) == this.getValueInt(r_right)) ret = new CaliBool(true); + else ret = new CaliBool(false); + } else if (this.isInt(r_left)) { + if ((double)this.getValueInt(r_left) == ((CaliDouble)r_right).getValue()) ret = new CaliBool(true); + else ret = new CaliBool(false); + } else if (this.isInt(r_right)) { + if (((CaliDouble)r_left).getValue() == (double)this.getValueInt(r_right)) ret = new CaliBool(true); + else ret = new CaliBool(false); + } else { + if (((CaliDouble)r_left).getValue() == ((CaliDouble)r_right).getValue()) ret = new CaliBool(true); + else ret = new CaliBool(false); + } + } else if (r_left.getType() == cType.cString || r_right.getType() == cType.cString) { + if (((CaliTypeInt)r_left).str().equals(((CaliTypeInt)r_right).str())) ret = new CaliBool(true); + else ret = new CaliBool(false); + } else if (r_left.isNull() && r_right.isNull()) { + ret = new CaliBool(true); + } else if (r_left == r_right) ret = new CaliBool(true); + else ret = new CaliBool(false); + + return ret; + } + + private CaliType evalLessThan(Environment env, CaliType r_left, CaliType r_right) { + CaliType ret = new CaliNull(); + + if (this.isNumber(r_left) && this.isNumber(r_right)) { + if (this.isInt(r_left) && this.isInt(r_right)) { + if ((int)((CaliInt)r_left).getValue() < (int)((CaliInt)r_right).getValue()) ret = new CaliBool(true); + else ret = new CaliBool(false); + } else if (this.isInt(r_left)) { + if ((double)((CaliInt)r_left).getValue() < ((CaliDouble)r_right).getValue()) ret = new CaliBool(true); + else ret = new CaliBool(false); + } else { + if (((CaliDouble)r_left).getValue() < (double)((CaliInt)r_right).getValue()) ret = new CaliBool(true); + else ret = new CaliBool(false); + } + } + else { + CaliException e = new CaliException(exType.exRuntime); + e.setException(getLineNum(), "INVALID_COMPARISON", "astExpression.evalLessThan(): Less than comparison of non-number.", env.getCallStack().getStackTrace()); + return e; + } + + return ret; + } + + private CaliType evalGreaterThan(Environment env, CaliType r_left, CaliType r_right) { + CaliType ret = new CaliNull(); + + if (this.isNumber(r_left) && this.isNumber(r_right)) { + if (this.isInt(r_left) && this.isInt(r_right)) { + if ((int)((CaliInt)r_left).getValue() > (int)((CaliInt)r_right).getValue()) ret = new CaliBool(true); + else ret = new CaliBool(false); + } else if (this.isInt(r_left)) { + if ((double)((CaliInt)r_left).getValue() > ((CaliDouble)r_right).getValue()) ret = new CaliBool(true); + else ret = new CaliBool(false); + } else { + if (((CaliDouble)r_left).getValue() > (double)((CaliInt)r_right).getValue()) ret = new CaliBool(true); + else ret = new CaliBool(false); + } + } + else { + CaliException e = new CaliException(exType.exRuntime); + e.setException(getLineNum(), "INVALID_COMPARISON", "astExpression.evalGreaterThan(): Greater than comparison of non-number.", env.getCallStack().getStackTrace()); + return e; + } + + return ret; + } + + private CaliType evalLessThanEquals(Environment env, CaliType r_left, CaliType r_right) { + CaliType ret = new CaliNull(); + + if (this.isNumber(r_left) && this.isNumber(r_right)) { + if (this.isInt(r_left) && this.isInt(r_right)) { + if ((int)((CaliInt)r_left).getValue() <= (int)((CaliInt)r_right).getValue()) ret = new CaliBool(true); + else ret = new CaliBool(false); + } else if (this.isInt(r_left)) { + if ((double)((CaliInt)r_left).getValue() <= ((CaliDouble)r_right).getValue()) ret = new CaliBool(true); + else ret = new CaliBool(false); + } else { + if (((CaliDouble)r_left).getValue() <= (double)((CaliInt)r_right).getValue()) ret = new CaliBool(true); + else ret = new CaliBool(false); + } + } else { + CaliException e = new CaliException(exType.exRuntime); + e.setException(getLineNum(), "INVALID_COMPARISON", "astExpression.evalLessThanEquals(): Less than equals comparison of non-number.", env.getCallStack().getStackTrace()); + return e; + } + + return ret; + } + + private CaliType evalGreaterThanEquals(Environment env, CaliType r_left, CaliType r_right) { + CaliType ret = new CaliNull(); + + if (this.isNumber(r_left) && this.isNumber(r_right)) { + if (this.isInt(r_left) && this.isInt(r_right)) { + if ((int)((CaliInt)r_left).getValue() >= (int)((CaliInt)r_right).getValue()) ret = new CaliBool(true); + else ret = new CaliBool(false); + } else if (this.isInt(r_left)) { + if ((double)((CaliInt)r_left).getValue() >= ((CaliDouble)r_right).getValue()) ret = new CaliBool(true); + else ret = new CaliBool(false); + } else { + if (((CaliDouble)r_left).getValue() >= (double)((CaliInt)r_right).getValue()) { + ret = new CaliBool(true); + } else { + ret = new CaliBool(false); + } + } + } + else { + CaliException e = new CaliException(exType.exRuntime); + e.setException(getLineNum(), "INVALID_COMPARISON", "astExpression.evalGreaterThanEquals(): Greater than equals comparison of non-number.", env.getCallStack().getStackTrace()); + return e; + } + + return ret; + } + + private CaliType evalAnd(Environment env, CaliType r_left, CaliType r_right) { + if (r_left.isEx()) { + return r_left; + } else if (r_right.isEx()) { + return r_right; + } else { + if (this.boolVal(r_left) && this.boolVal(r_right)) { + return new CaliBool(true); + } else { + return new CaliBool(false); + } + } + } + + private CaliType evalOr(Environment env, CaliType r_left, CaliType r_right) { + if (r_left.isEx()) { + return r_left; + } else if (r_right.isEx()) { + return r_right; + } else { + if (this.boolVal(r_left) || this.boolVal(r_right)) { + return new CaliBool(true); + } else { + return new CaliBool(false); + } + } + } + + private CaliType evalInsert(Environment env, CaliType r_left, CaliType r_right) { + if (r_left.getType() == cType.cList) { + ((CaliList)r_left).add(r_right); + return r_left; + } else { + CaliException e = new CaliException(exType.exRuntime); + e.setException(getLineNum(), "INSERT_NOT_POSSIBLE", "astExpression.evalInsert(): Left side of insert expression not a list.", env.getCallStack().getStackTrace()); + return e; + } + } + + private CaliType evalInstanceOf(Environment env, CaliType r_left, CaliType r_right) { + if (r_left instanceof CaliObject) { + if (r_right instanceof CaliString) { + if (((CaliObject)r_left).getClassDef().instanceOf(((CaliString)r_right).getValue())) { + return new CaliBool(true); + } else { + return new CaliBool(false); + } + } else { + CaliException e = new CaliException(exType.exRuntime); + e.setException(getLineNum(), "UNEXPECTED_TYPE_FOUND", "astExpression.evalInstanceOf(): Left side of expression is not an instance of CaliObject.", env.getCallStack().getStackTrace()); + return e; + } + } else { + CaliException e = new CaliException(exType.exRuntime); + e.setException(getLineNum(), "UNEXPECTED_TYPE_FOUND", "astExpression.evalInstanceOf(): Left side of expression is not an instance of CaliObject.", env.getCallStack().getStackTrace()); + return e; + } + } + + private CaliType evalNotEquals(Environment env, CaliType r_left, CaliType r_right) { + CaliType ret = this.evalEqualsEquals(env, r_left, r_right); + return new CaliBool(!((CaliBool)ret).getValue()); + } + + private CaliType operEquals(Environment env, boolean getRef) throws caliException { + CaliType ret = new CaliNull(); + + CaliType r_left = left.eval(env, true); + if(!r_left.isEx()) { + if (r_left.getType() == cType.cRef) { + CaliRef ref = (CaliRef)r_left; + CaliType r_right = right.eval(env, getRef); + if(!r_right.isEx()) { + switch(this.eType) { + case PLEQ: { + ret = evalPlusEquals(env, ref, r_right); + break; + } case MIEQ: { + ret = evalMinusEquals(env, ref, r_right); + break; + } case MUEQ: { + ret = evalMultEquals(env, ref, r_right); + break; + } case DIEQ: { + ret = evalDivEquals(env, ref, r_right); + break; + } default: { + CaliException e = new CaliException(exType.exInternal); + e.setException(this.getLineNum(), "UNDEFINED_EXPRESSION", "Undefined oper-equals expression '" + this.eType.name() + "' found. (aExp::call)", "Undefined oper-equals expression '" + this.eType.name() + "' found. (aExp::call)", env.getCallStack().getStackTrace()); + ret = e; + break; + } + } + } else { + ret = r_right; + } + } else { + CaliException e = new CaliException(exType.exRuntime); + e.setException(getLineNum(), "ASSIGN_NOT_POSSIBLE", "astExpression.operEquals(): Left side of assignment expression returned an object of type '" + r_left.getType().name() + "' which can't be assigned.", env.getCallStack().getStackTrace()); + return e; + } + } + else { + ret = r_left; + } + + return ret; + } + + private CaliType evalPlusEquals(Environment env, CaliType r_left, CaliType r_right) { + CaliRef ref = (CaliRef)r_left; + try { + CaliType lval = ref.getValue(); + CaliType res = this.evalPlus(env, lval, r_right); + if (!res.isEx()) { + ref.assign(res); + return res; + } else { + return res; + } + } catch (Exception ex) { + CaliException e = new CaliException(exType.exRuntime); + e.setException(getLineNum(), "ASSIGN_NOT_POSSIBLE", "astExpression.evalPlusEquals(): " + ex.getMessage(), env.getCallStack().getStackTrace()); + return e; + } + } + + private CaliType evalMinusEquals(Environment env, CaliType r_left, CaliType r_right) { + CaliRef ref = (CaliRef)r_left; + try { + CaliType lval = ref.getValue(); + CaliType res = this.evalMinus(env, lval, r_right); + if (!res.isEx()) { + ref.assign(res); + return res; + } else { + return res; + } + } catch (Exception ex) { + CaliException e = new CaliException(exType.exRuntime); + e.setException(getLineNum(), "ASSIGN_NOT_POSSIBLE", "astExpression.evalMinusEquals(): " + ex.getMessage(), env.getCallStack().getStackTrace()); + return e; + } + } + + private CaliType evalMultEquals(Environment env, CaliType r_left, CaliType r_right) { + CaliRef ref = (CaliRef)r_left; + try { + CaliType lval = ref.getValue(); + CaliType res = this.evalMult(env, lval, r_right); + if (!res.isEx()) { + ref.assign(res); + return res; + } else { + return res; + } + } catch (Exception ex) { + CaliException e = new CaliException(exType.exRuntime); + e.setException(getLineNum(), "ASSIGN_NOT_POSSIBLE", "astExpression.evalMultEquals(): " + ex.getMessage(), env.getCallStack().getStackTrace()); + return e; + } + } + + private CaliType evalDivEquals(Environment env, CaliType r_left, CaliType r_right) { + CaliRef ref = (CaliRef)r_left; + try { + CaliType lval = ref.getValue(); + CaliType res = this.evalDiv(env, lval, r_right); + if (!res.isEx()) { + ref.assign(res); + return res; + } else { + return res; + } + } catch (Exception ex) { + CaliException e = new CaliException(exType.exRuntime); + e.setException(getLineNum(), "ASSIGN_NOT_POSSIBLE", "astExpression.evalDivEquals(): " + ex.getMessage(), env.getCallStack().getStackTrace()); + return e; + } + } + + private CaliType operIncDec(Environment env, boolean getRef) throws caliException { + CaliType ret = new CaliNull(); + + CaliType r_left = left.eval(env, true); + if(!r_left.isEx()) { + if (r_left.getType() == cType.cRef) { + CaliRef ref = (CaliRef)r_left; + switch(this.eType) { + case PLPL: { + ret = evalPlusPlus(env, ref); + break; + } case MIMI: { + ret = evalMinusMinus(env, ref); + break; + } default: { + CaliException e = new CaliException(exType.exInternal); + e.setException(this.getLineNum(), "UNDEFINED_EXPRESSION", "Undefined oper inc/dec expression '" + this.eType.name() + "' found. (aExp::call)", "Undefined oper inc/dec expression '" + this.eType.name() + "' found. (aExp::call)", env.getCallStack().getStackTrace()); + ret = e; + break; + } + } + + } else { + CaliException e = new CaliException(exType.exRuntime); + e.setException(getLineNum(), "ASSIGN_NOT_POSSIBLE", "astExpression.operIncDec(): Left side of assignment expression returned an object of type '" + r_left.getType().name() + "' which can't be assigned.", env.getCallStack().getStackTrace()); + return e; + } + } else { + ret = r_left; + } + + return ret; + } + + private CaliType evalPlusPlus(Environment env, CaliType r_left) { + CaliRef ref = (CaliRef)r_left; + try { + CaliType lval = ref.getValue(); + if (this.isNumber(lval)) { + if (this.isInt(lval)) { + CaliInt val = new CaliInt(((CaliInt)lval).getValue() + 1); + ref.assign(val); + return val; + } else { + CaliDouble val = new CaliDouble(((CaliDouble)lval).getValue() + 1.0); + ref.assign(val); + return val; + } + } else { + CaliException e = new CaliException(exType.exRuntime); + e.setException(getLineNum(), "ASSIGN_NOT_POSSIBLE", "astExpression.evalDivEquals(): Attempt to increment data type '" + lval.getType().name() + "'.", env.getCallStack().getStackTrace()); + return e; + } + } catch (Exception ex) { + CaliException e = new CaliException(exType.exRuntime); + e.setException(getLineNum(), "ASSIGN_NOT_POSSIBLE", "astExpression.evalDivEquals(): " + ex.getMessage(), env.getCallStack().getStackTrace()); + return e; + } + } + + private CaliType evalMinusMinus(Environment env, CaliType r_left) { + CaliRef ref = (CaliRef)r_left; + try { + CaliType lval = ref.getValue(); + if (this.isNumber(lval)) { + if (this.isInt(lval)) { + CaliInt val = new CaliInt(((CaliInt)lval).getValue() - 1); + ref.assign(val); + return val; + } else { + CaliDouble val = new CaliDouble(((CaliDouble)lval).getValue() - 1.0); + ref.assign(val); + return val; + } + } else { + CaliException e = new CaliException(exType.exRuntime); + e.setException(getLineNum(), "ASSIGN_NOT_POSSIBLE", "astExpression.evalMinusMinus(): Attempt to increment data type '" + lval.getType().name() + "'.", env.getCallStack().getStackTrace()); + return e; + } + } catch (Exception ex) { + CaliException e = new CaliException(exType.exRuntime); + e.setException(getLineNum(), "ASSIGN_NOT_POSSIBLE", "astExpression.evalMinusMinus(): " + ex.getMessage(), env.getCallStack().getStackTrace()); + return e; + } + } + + private CaliType operLeft(Environment env, boolean getRef) throws caliException + { + CaliType ret = new CaliNull(); + + CaliType r_left = left.eval(env, getRef); + if(!r_left.isEx()) { + switch(this.eType) { + case NOT: { + ret = evalNot(env, r_left); + break; + } case COUNT: { + ret = evalCount(env, r_left); + break; + } case INCLUDE: { + ret = evalInclude(env, r_left); + break; + } default: { + CaliException e = new CaliException(exType.exInternal); + e.setException(this.getLineNum(), "UNDEFINED_EXPRESSION", "Undefined oper left expression '" + this.eType.name() + "' found. (aExp::call)", "Undefined oper left expression '" + this.eType.name() + "' found. (aExp::call)", env.getCallStack().getStackTrace()); + ret = e; + break; + } + } + } + else { + ret = r_left; + } + + return ret; + } + + private CaliType evalNot(Environment env, CaliType r_left) { + return new CaliBool(!this.boolVal(r_left)); + } + + private CaliType evalCount(Environment env, CaliType r_left) { + if (r_left.getType() == cType.cList) { + return new CaliInt(((CaliList)r_left).getValue().size()); + } else if (r_left.getType() == cType.cMap) { + return new CaliInt(((CaliMap)r_left).size()); + } else if (r_left.getType() == cType.cString) { + return new CaliInt(((CaliString)r_left).getValue().length()); + } else { + CaliException e = new CaliException(exType.exRuntime); + e.setException(getLineNum(), "ASSIGN_NOT_POSSIBLE", "astExpression.evalCount(): Count operator (#) cannot be used for data type '" + r_left.getType().name() + "'.", env.getCallStack().getStackTrace()); + return e; + } + } + + private CaliType evalInclude(Environment env, CaliType r_left) { + if (r_left instanceof CaliString) { + try { + env.getEngine().addInclude(((CaliString)r_left).getValue()); + } catch (Exception ex) { + CaliException e = new CaliException(exType.exRuntime); + e.setException(getLineNum(), "INCLUDE_FAILED", "astExpression.evalInclude(): Failed to include '" + ((CaliString)r_left).getValue() + "'. " + ex.getMessage(), env.getCallStack().getStackTrace()); + return e; + } + return new CaliBool(true); + } else { + CaliException e = new CaliException(exType.exRuntime); + e.setException(getLineNum(), "UNEXPECTED_DATA_TYPE", "astExpression.evalInclude(): Expecting string data type but found '" + r_left.getType().name() + "' instead.", env.getCallStack().getStackTrace()); + return e; + } + } + + + private boolean isNumber(CaliType Item) { + if (Item.getType() == cType.cInt || Item.getType() == cType.cDouble || Item.getType() == cType.cBool) return true; + return false; + } + + private boolean isInt(CaliType Item) { + if (Item.getType() == cType.cInt || Item.getType() == cType.cBool) return true; + return false; + } + + private long getValueInt(CaliType Item) { + if (Item.getType() == cType.cInt) { + return (int) ((CaliInt)Item).getValue(); + } else if (((CaliBool)Item).getValue()) { + return 1; + } + return 0; + } + + private boolean boolVal(CaliType Item) { + if (Item.getType() == cType.cNull) { + return false; + } else if (Item.getType() == cType.cBool) { + if (((CaliBool)Item).getValue() == false) return false; + else return true; + } else if (Item.getType() == cType.cInt) { + if (((CaliInt)Item).getValue() == 0) return false; + else return true; + } else if (Item.getType() == cType.cDouble) { + if (((CaliDouble)Item).getValue() == 0.0) return false; + else return true; + } else if (Item.getType() == cType.cString) { + if (((CaliString)Item).getValue() == "") return false; + else return true; + } + else if (Item instanceof CaliObject) return true; + else if (Item.getType() == cType.cList) return true; + else if (Item.getType() == cType.cMap) return true; + else return false; + } +} diff --git a/cali.lang.base/src/com/cali/ast/astFor.java b/cali.lang.base/src/com/cali/ast/astFor.java new file mode 100644 index 0000000..d7d6145 --- /dev/null +++ b/cali.lang.base/src/com/cali/ast/astFor.java @@ -0,0 +1,213 @@ +/* + * Copyright 2017 Austin Lehman + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.cali.ast; + +import com.cali.Environment; +import com.cali.types.CaliBool; +import com.cali.types.CaliList; +import com.cali.types.CaliMap; +import com.cali.types.CaliNull; +import com.cali.types.CaliString; +import com.cali.types.CaliType; +import com.cali.types.cType; + +public class astFor extends astNode implements astNodeInt { + private astNode exprInit = null; + private astNode exprCond = null; + private astNode exprInc = null; + + private astNode eachVar = null; + private astNode eachExpr = null; + + private boolean isForEach = false; + + private astStatementList instructions = new astStatementList(); + + public astFor() { + this.setType(astNodeType.FOR); + } + + public void addToInstructionList(astNode Node) { + this.instructions.getStatements().add(Node); + } + + public String toString() { + return this.toString(0); + } + + @Override + public String toString(int Level) { + String rstr = ""; + + rstr += getTabs(Level) + "{\n"; + rstr += this.getNodeStr(Level + 1) + ",\n"; + + if(this.exprCond != null) { + rstr += getTabs(Level + 1) + "\"condition\":\n"; + rstr += ((astNodeInt)this.exprCond).toString(Level + 1) + ",\n"; + } + + if(this.instructions != null) { + rstr += this.instructions.toString(Level + 1); + } + + rstr += getTabs(Level) + "}"; + return rstr; + } + + @Override + public CaliType evalImpl(Environment env, boolean getref) throws caliException { + if(this.isForEach) { + return this.evalForEachImpl(env, getref); + } else { + return this.evalForImpl(env, getref); + } + } + + private CaliType evalForEachImpl(Environment env, boolean getref) throws caliException { + CaliType ret = new CaliNull(); + + CaliType titems = this.eachExpr.eval(env, getref); + + if(titems.getType() == cType.cList) { + CaliList al = (CaliList)titems; + for(int i = 0; i < al.getValue().size(); i++) { + CaliType item = al.getValue().get(i); + env.getLocals().add(this.eachVar.getName(), item); + + for(astNode inst : this.instructions.getStatements()) { + ret = inst.eval(env, getref); + if(astNode.isBreakReturnEvent(ret)) + break; + } + + if(astNode.isBreakReturnEvent(ret)) + break; + } + } + else if(titems.getType() == cType.cMap) { + CaliMap am = (CaliMap)titems; + + for(String key : am.getValue().keySet()) { + CaliString tmp = new CaliString(key); + env.getLocals().add(this.eachVar.getName(), tmp); + + for(astNode inst : this.instructions.getStatements()) { + ret = inst.eval(env, getref); + if(astNode.isBreakReturnEvent(ret)) + break; + } + + if(astNode.isBreakReturnEvent(ret)) + break; + } + } + else { + throw new caliException(this, "For loop expecting of type LIST or MAP, found '" + titems.getType().name() + "' instead.", env.stackTraceToString()); + } + + return ret; + } + + private CaliType evalForImpl(Environment env, boolean getref) throws caliException + { + CaliType ret = new CaliNull(); + + @SuppressWarnings("unused") + CaliType einit = this.exprInit.eval(env, getref); + + CaliType etmp = this.exprCond.eval(env, getref); + CaliBool cond = etmp.evalExpressionBool(); + while(cond.getValue()) { + for(astNode inst : this.instructions.getStatements()) { + ret = inst.eval(env, getref); + if(astNode.isBreakReturnEvent(ret)) + break; + } + + if(astNode.isBreakReturnEvent(ret)) + break; + else { + // Increment step + @SuppressWarnings("unused") + CaliType einc = this.exprInc.eval(env, getref); + + // Recheck condition + etmp = this.exprCond.eval(env, getref); + cond = etmp.evalExpressionBool(); + } + } + + return ret; + } + + public astNode getExprInit() { + return exprInit; + } + + public void setExprInit(astNode exprInit) { + this.exprInit = exprInit; + } + + public astNode getExprCond() { + return exprCond; + } + + public void setExprCond(astNode exprCond) { + this.exprCond = exprCond; + } + + public astNode getExprInc() { + return exprInc; + } + + public void setExprInc(astNode exprInc) { + this.exprInc = exprInc; + } + + public boolean getIsForEach() { + return isForEach; + } + + public void setIsForEach(boolean isForEach) { + this.isForEach = isForEach; + } + + public astStatementList getInstructions() { + return instructions; + } + + public void setInstructions(astStatementList instructions) { + this.instructions = instructions; + } + + public astNode getEachVar() { + return eachVar; + } + + public void setEachVar(astNode eachVar) { + this.eachVar = eachVar; + } + + public astNode getEachExpr() { + return eachExpr; + } + + public void setEachExpr(astNode eachExpr) { + this.eachExpr = eachExpr; + } +} diff --git a/cali.lang.base/src/com/cali/ast/astFunctCall.java b/cali.lang.base/src/com/cali/ast/astFunctCall.java new file mode 100644 index 0000000..e787fde --- /dev/null +++ b/cali.lang.base/src/com/cali/ast/astFunctCall.java @@ -0,0 +1,135 @@ +/* + * Copyright 2017 Austin Lehman + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.cali.ast; + +import com.cali.CallStack; +import com.cali.Environment; +import com.cali.types.CaliException; +import com.cali.types.CaliException.exType; +import com.cali.types.CaliList; +import com.cali.types.CaliNull; +import com.cali.types.CaliObject; +import com.cali.types.CaliType; + +public class astFunctCall extends astNode implements astNodeInt { + private astFunctDefArgsList args = new astFunctDefArgsList(); + public void addArg(astNode Arg) { this.args.getArgs().add(Arg); } + + public astFunctCall() { + this.setType(astNodeType.FUNCTCALL); + } + + public astFunctCall(String Name) { + this.setType(astNodeType.FUNCTCALL); + this.setName(Name); + } + + public String toString() { + return this.toString(0); + } + + @Override + public String toString(int Level) { + String rstr = ""; + rstr += getTabs(Level) + "{\n"; + rstr += this.getNodeStr(Level + 1) + ",\n"; + if(this.args != null) { + rstr += getTabs(Level + 1) + "\"argumentList\":\n"; + rstr += this.args.toString(Level + 1) + ",\n"; + } + if (this.getChild() != null) { + rstr += getTabs(Level + 1) + "\"child\":\n"; + rstr += ((astNodeInt)this.getChild()).toString(Level + 2) + ",\n"; + } + rstr += getTabs(Level) + "}"; + return rstr; + } + + public astFunctDefArgsList getArgs() { + return args; + } + + public void setArgs(astFunctDefArgsList args) { + this.args = args; + } + + public CaliType evalImpl(Environment env, boolean getRef) throws caliException { + CaliType ret = new CaliNull(); + + if (this.functionHasAccess(env, this.getName())) { + CaliType cargs; + if(this.args != null) { + Environment tenv = env.clone(null); + cargs = this.args.eval(tenv, getRef); + } + else { + cargs = new CaliList(); + } + + if(!cargs.isEx()) { + astClass cls = env.getClassInstance().getClassDef(); + if (env.getCurObj() != null && env.getCurObj() instanceof CaliObject) { + cls = ((CaliObject)env.getCurObj()).getClassDef(); + } + if(cls != null) { + CallStack cst = new CallStack(this.getFileName(), this.getLineNum(), env.getClassInstance().getClassDef().getName(), this.getName(), "Function called."); + cst.setParent(env.getCallStack()); + + Environment tenv = env.clone(env.getCurObj()); + tenv.setEnvironment(env.getClassInstance(), env.getLocals(), cst); + + ret = cls.call(tenv, getRef, getName(), (CaliList)cargs); + } else { + CaliException e = new CaliException(exType.exInternal); + e.setException(this.getLineNum(), "CLASS_DEF_NOT_FOUND", "Class '" + env.getClassInstance().getClassDef().getName() + "' has no function definition '" + getName() + "'.", "Class '" + env.getClassInstance().getClassDef().getName() + "' has no function definition '" + this.getName() + "'.", env.getCallStack().getStackTrace()); + ret = e; + } + } + else { + ret = cargs; + } + } else { + CaliException e = new CaliException(exType.exRuntime); + e.setException(this.getLineNum(), "NO_ACCESS", "aObj.aFunctCall(): No access to function '" + this.getName() + "'.", env.getCallStack().getStackTrace()); + return e; + } + + if (this.getChild() != null && !ret.isEx()) { + Environment tenv = env.clone(ret); + ret = this.getChild().eval(tenv, getRef); + } + + return ret; + } + + public boolean functionHasAccess(Environment env, String functionName) { + if (env.getClassInstance() != env.getCurObj()) { + astClass ac = ((CaliObject)env.getCurObj()).getClassDef(); + if (ac.containsFunction(functionName)) { + if (ac.getFunct(functionName).getAccessType() == AccessType.aPrivate) { + return false; + } else { + return true; + } + } else { + return true; + } + } else { + return true; + } + } +} diff --git a/cali.lang.base/src/com/cali/ast/astFunctDef.java b/cali.lang.base/src/com/cali/ast/astFunctDef.java new file mode 100644 index 0000000..c8dbe15 --- /dev/null +++ b/cali.lang.base/src/com/cali/ast/astFunctDef.java @@ -0,0 +1,368 @@ +/* + * Copyright 2017 Austin Lehman + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.cali.ast; + +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; +import java.util.ArrayList; + +import com.cali.CallStack; +import com.cali.Environment; +import com.cali.types.CaliBool; +import com.cali.types.CaliException; +import com.cali.types.CaliException.exType; +import com.cali.types.CaliInt; +import com.cali.types.CaliList; +import com.cali.types.CaliNull; +import com.cali.types.CaliType; +import com.cali.types.CaliReturn; +import com.cali.types.CaliObject; +import com.cali.types.CaliDouble; +import com.cali.types.cType; + +public class astFunctDef extends astNode implements astNodeInt { + private astFunctDefArgsList argList = new astFunctDefArgsList(); + private astStatementList instructionList = new astStatementList(); + private boolean isExtern = false; + + public astFunctDef() { + this.setType(astNodeType.FUNCTDEF); + } + + public astFunctDef(String Name) { + this.setType(astNodeType.FUNCTDEF); + this.setName(Name); + } + + public astFunctDefArgsList getArgList() { + return argList; + } + + public void setArgList(astFunctDefArgsList argList) { + this.argList = argList; + } + + public astStatementList getInstructionList() { + return instructionList; + } + + public void setInstructionList(astStatementList InstructionList) { + this.instructionList = InstructionList; + } + + public void setExtern(boolean extern) { + this.isExtern = extern; + } + + public boolean getExtern() { + return this.isExtern; + } + + @Override + public CaliType evalImpl(Environment env, boolean getref) throws caliException { + throw new caliException(this, "INTERNAL [astFunctDef.evalImpl] Not implemented.", env.stackTraceToString()); + } + + @Override + public String toString(int Level) { + String rstr = ""; + rstr += getTabs(Level) + "{\n"; + rstr += this.getNodeStr(Level + 1) + ",\n"; + if(this.argList != null) { + rstr += getTabs(Level + 1) + "\"argumentList\":\n"; + rstr += this.argList.toString(Level + 1) + ",\n"; + } + if(this.instructionList != null) { + rstr += getTabs(Level + 1) + "\"statementList\":\n"; + rstr += this.instructionList.toString(Level + 1) + ",\n"; + } + rstr += getTabs(Level) + "}"; + return rstr; + } + + public CaliType initArgs(Environment env, CaliList args) throws caliException { + CaliType ret = new CaliNull(); + + if (this.argList != null) { + int i = 0; + for (astNode adef : this.argList.getArgs()) { + // Data type in funct def specified, check that passed data + // is valid. + if (i < args.getValue().size()) { + if (adef.getType() != astNodeType.UNDEF) { + if ( + (adef.getType() == astNodeType.BOOL && args.getValue().get(i).getType() != cType.cBool) + || (adef.getType() == astNodeType.INT && args.getValue().get(i).getType() != cType.cInt) + || (adef.getType() == astNodeType.DOUBLE && args.getValue().get(i).getType() != cType.cDouble) + || (adef.getType() == astNodeType.STRING && args.getValue().get(i).getType() != cType.cString) + || (adef.getType() == astNodeType.LIST && args.getValue().get(i).getType() != cType.cList) + || (adef.getType() == astNodeType.MAP && args.getValue().get(i).getType() != cType.cMap) + || (adef.getType() == astNodeType.OBJ && args.getValue().get(i).getType() != cType.cObject) + ) { + CaliException e = new CaliException(exType.exRuntime); + e.setException(this.getLineNum(), "INVALID_DATA_TYPE", "Function '" + this.getName() + "' definition at position " + (i + 1) + " is expected to be of type '" + adef.getType().name() + "' but found '" + args.getValue().get(i).getType().name() + "' instead.", env.getCallStack().getStackTrace()); + return e; + } else if (adef.getType() == astNodeType.VAR && adef.getPrimType() != cType.cUndef && adef.getPrimType() != args.getValue().get(i).getType()) { + CaliException e = new CaliException(exType.exRuntime); + e.setException(this.getLineNum(), "INVALID_DATA_TYPE", "Function '" + this.getName() + "' definition at position " + (i + 1) + " is expected to be of type '" + adef.getPrimType().name() + "' but found '" + args.getValue().get(i).getType().name() + "' instead.", env.getCallStack().getStackTrace()); + return e; + } + } + + if (adef.getType() == astNodeType.ETCETERA) { + CaliList etcList = new CaliList(); + for (int j = i; j < args.getValue().size(); j++) { + etcList.add(args.getValue().get(j)); + } + env.getLocals().add("etc", etcList); + break; + } else { + env.getLocals().add(adef.getName(), args.getValue().get(i)); + } + } else if (adef.getType() == astNodeType.ETCETERA) { + CaliList etcList = new CaliList(); + env.getLocals().add("etc", etcList); + break; + } else if (adef.getType() != astNodeType.VAR) { + // Not a var, so it is a defalut value. + env.getLocals().add(adef.getName(), adef.eval(env, false)); + } else { + CaliException e = new CaliException(exType.exRuntime); + e.setException(this.getLineNum(), "ARGUMENT_NUMBER", "Number of arguments provided does not match the number in definition.", "Number of arguments provided does not match the number in definition.", env.getCallStack().getStackTrace()); + ret = e; + } + i++; + } + } else if (this.argList.getArgs().size() > 0) { + CaliException e = new CaliException(exType.exRuntime); + e.setException(this.getLineNum(), "ARGUMENT_NUMBER", "Number of arguments provided does not match the number in definition.", "Number of arguments provided does not match the number in definition.", env.getCallStack().getStackTrace()); + ret = e; + } + + if(ret.isNull()) { + ret = new CaliBool(true); + } + + return ret; + } + + public CaliType call (Environment env, boolean getRef, CaliList args, String FileName) throws caliException { + CaliType ret = new CaliNull(); + boolean retFound = false; + + CaliType tnode = this.initArgs(env, args); + + CallStack cst = new CallStack(FileName, this.getLineNum(), env.getClassInstance().getClassDef().getName(), this.getName(), "Defined."); + cst.setParent(env.getCallStack()); + + // Itterate statement list of function + if(!tnode.isEx()) { + if(this.instructionList != null) { + for(int i = 0; (i < this.instructionList.getStatements().size())&&(!ret.isEx()); i++) { + astNode statement = this.instructionList.getStatements().get(i); + CaliType tmp = null; + if(statement != null) { + Environment tenv = new Environment(env.getEngine()); + tenv.setEnvironment(env.getClassInstance(), env.getLocals(), cst); + tmp = statement.eval(tenv, getRef); + if(tmp.isReturn()) { + ret = ((CaliReturn)tmp).getValue(); + retFound = true; + break; + } else if(tmp.isEx()) { + ret = tmp; + break; + } + } else { + CaliException e = new CaliException(exType.exInternal); + e.setException(this.getLineNum(), "NULL_PTR", "Null pointer for statement. (aFunctDef::call)", "Null pointer for statement.", env.getCallStack().getStackTrace()); + ret = e; + break; + } + } + } else { + CaliException e = new CaliException(exType.exInternal); + e.setException(this.getLineNum(), "NULL_PTR", "Null pointer for slist. (aFunctDef::call)", "Null pointer for slist.", env.getCallStack().getStackTrace()); + ret = e; + } + } + else + ret = tnode; + + if(ret == null) { + if(retFound) { + CaliException e = new CaliException(exType.exInternal); + e.setException(this.getLineNum(), "NULL_PTR", "Null pointer returned. (aFunctDef::call)", "Null pointer returned.", env.getCallStack().getStackTrace()); + ret = e; + } else { + // No return statement, create new astNode of aUndef and return. + ret = new CaliNull(); + } + } + + + return ret; + } + + public CaliType callExtern(Environment env, CaliList args) throws caliException { + CaliType ret = new CaliNull(); + + CaliObject callingObj = env.getClassInstance(); + Object o = callingObj.getExternObject(); + if(o != null) { + ArrayList fargs = this.getExternArgs(env, args); + try { + Class aclass = callingObj.getClassDef().getExternClass(); + Method meth = aclass.getMethod(this.getName(), ArrayList.class); + CaliType tmp = (CaliType)meth.invoke(o,fargs); + if((tmp != null)&&(tmp instanceof CaliType)) ret = tmp; + else + throw new caliException(this, "Return value found from calling '" + this.getName() + "' is null or not of type CaliType.", env.stackTraceToString()); + } catch (NoSuchMethodException e) { + // Attempt to call the second flavor with env info. + CaliType tmp = this.callExternEnv(env, args); + if(tmp != null) ret = tmp; + + if(tmp == null) + throw new caliException(this, "External call, no such method '" + this.getName() + "'.", env.stackTraceToString()); + } catch (SecurityException e) { + throw new caliException(this, "External call, security exception for method '" + this.getName() + "'.", env.stackTraceToString()); + } catch (IllegalAccessException e) { + throw new caliException(this, "External call, illegal access exception for method '" + this.getName() + "'.", env.stackTraceToString()); + } catch (IllegalArgumentException e) { + throw new caliException(this, "External call, illegal argument exception for method '" + this.getName() + "'.", env.stackTraceToString()); + } catch(StackOverflowError e) { + throw new caliException(this, "External call, stack overflow exception for method '" + this.getName() + "'. Infinite recursion perhaps?", env.stackTraceToString()); + } catch (InvocationTargetException e) { + e.printStackTrace(); + throw new caliException(this, "External call, invocation target exception for method '" + this.getName() + "', the external method threw an uncaught exception.", env.stackTraceToString()); + } + } else { + throw new caliException(this, "External object not found when calling '" + this.getName() + "'.", env.stackTraceToString()); + } + + if(ret.getType() == cType.cException) { + CaliException ae = (CaliException)ret; + ret = new CaliNull(); + throw new caliException(this, ae.getText(), env.stackTraceToString()); + } + + return ret; + } + + private ArrayList getExternArgs(Environment env, CaliList eargs) throws caliException + { + ArrayList args = new ArrayList(); + + boolean etcFound = false; + CaliList etcList = new CaliList(); + cType etype = cType.cUndef; + + for(int i = 0; (i < this.argList.getArgs().size())||(i < eargs.size()); i++) { + if((i < this.argList.getArgs().size())&&(this.argList.getArgs().get(i).getType() == astNodeType.ETCETERA)) { + if(!etcFound) { + etype = ((astEtcetera)this.argList.getArgs().get(i)).getPrimType(); + etcFound = true; + } + else + throw new caliException(this, "Already found a etcetera (...) definition in this function definition.", env.stackTraceToString()); + } + + if(etcFound) { + if(i < eargs.size()) { + if(etype != cType.cUndef) { + if(eargs.getValue().get(i).getType() == etype) { + etcList.add(eargs.getValue().get(i)); + } + else + throw new caliException(this, "Etcetera (...) list is expecting type '" + etype.name() + " but found type '" + eargs.getValue().get(i).getType().name() + "'.", env.stackTraceToString()); + } + else + etcList.add(eargs.getValue().get(i)); + } + } else { + if(etcFound) { + throw new caliException(this, "Cannot have arguments in function definition after etcetera (...).", env.stackTraceToString()); + } else { + if(this.argList.getArgs().size() > i) { + astNode v = this.argList.getArgs().get(i); + + if(i < eargs.size()) { + if((v.getPrimType() == cType.cUndef)||(v.getPrimType() == eargs.getValue().get(i).getType())||(eargs.getValue().get(i).isNull())) { + args.add(eargs.getValue().get(i)); + } else if((v.getPrimType() == cType.cInt)&&(eargs.getValue().get(i).getType() == cType.cDouble)){ + CaliInt ai = new CaliInt((int)((CaliDouble)eargs.getValue().get(i)).getValue()); + args.add(ai); + } else if((v.getPrimType() == cType.cDouble)&&(eargs.getValue().get(i).getType() == cType.cInt)) { + CaliDouble ad = new CaliDouble((double)((CaliInt)eargs.getValue().get(i)).getValue()); + args.add(ad); + } else { + throw new caliException(this, "Expecting type '" + v.getPrimType().name() + " but found type '" + eargs.getValue().get(i).getType().name() + "'.", env.stackTraceToString()); + } + } else { + args.add(this.argList.getArgs().get(i).eval(env)); + } + } else { + throw new caliException(this, "Incorrect number of arguments provided to function '" + this.getName() + "'. Provided " + String.valueOf(eargs.size()) + " but expecting " + String.valueOf(this.argList.getArgs().size()) + ".", env.stackTraceToString()); + } + } + } + } + + if(etcFound) { + args.add(etcList); + } + + return args; + } + + private CaliType callExternEnv(Environment env, CaliList args) throws caliException { + CaliType ret = new CaliNull(); + + CaliObject callingObj = env.getClassInstance(); + Object o = callingObj.getExternObject(); + if(o != null) { + ArrayList fargs = this.getExternArgs(env, args); + try { + Class aclass = callingObj.getClassDef().getExternClass(); + Method meth = aclass.getMethod(this.getName(), Environment.class, ArrayList.class); + CaliType tmp = (CaliType)meth.invoke(o, env, fargs); + if(tmp != null) ret = tmp; + } catch (NoSuchMethodException e) { + throw new caliException(this, "External call, no such method '" + this.getName() + "'.", env.stackTraceToString()); + } catch (SecurityException e) { + throw new caliException(this, "External call, security exception for method '" + this.getName() + "'.", env.stackTraceToString()); + } catch (IllegalAccessException e) { + throw new caliException(this, "External call, illegal access exception for method '" + this.getName() + "'.", env.stackTraceToString()); + } catch (IllegalArgumentException e) { + throw new caliException(this, "External call, illegal argument exception for method '" + this.getName() + "'.", env.stackTraceToString()); + } catch (InvocationTargetException e) { + throw new caliException(this, "External call, invocation target exception for method '" + this.getName() + "', the external method threw an uncaught exception.", env.stackTraceToString()); + } + } else { + throw new caliException(this, "External object not found when calling '" + this.getName() + "'.", env.stackTraceToString()); + } + + if(ret.getType() == cType.cException) { + CaliException ae = (CaliException)ret; + ret = new CaliNull(); + throw new caliException(this, ae.getText(), env.stackTraceToString()); + } + + return ret; + } +} diff --git a/cali.lang.base/src/com/cali/ast/astFunctDefArgsList.java b/cali.lang.base/src/com/cali/ast/astFunctDefArgsList.java new file mode 100644 index 0000000..bba95c6 --- /dev/null +++ b/cali.lang.base/src/com/cali/ast/astFunctDefArgsList.java @@ -0,0 +1,81 @@ +/* + * Copyright 2017 Austin Lehman + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.cali.ast; + +import java.util.ArrayList; +import java.util.List; + +import com.cali.Environment; +import com.cali.types.CaliList; +import com.cali.types.CaliType; + +public class astFunctDefArgsList extends astNode implements astNodeInt { + private List args = new ArrayList(); + + public astFunctDefArgsList() { + this.setType(astNodeType.FUNCTDEFARGSLIST); + } + + public astFunctDefArgsList(String Name) { + super(); + this.setName(Name); + } + + public void addNode(astNode Node) { + this.args.add(Node); + } + + public void setArgs(List Args) { + this.args = Args; + } + + public List getArgs() { + return this.args; + } + + @Override + public String toString(int Level) { + String rstr = ""; + rstr += getTabs(Level) + "{\n"; + rstr += this.getNodeStr(Level + 1) + ",\n"; + rstr += getTabs(Level + 1) + "\"argumentList\": [\n"; + for(int i = 0; i < args.size(); i++) + rstr += ((astNodeInt)this.args.get(i)).toString(Level + 2) + ",\n"; + rstr += getTabs(Level + 1) + "]\n"; + rstr += getTabs(Level) + "}"; + return rstr; + } + + @Override + public CaliType evalImpl(Environment env, boolean getRef) throws caliException { + CaliList lst = new CaliList(); + CaliType ret = lst; + + for(int i = 0; i < this.args.size(); i++) { + astNode arg = this.args.get(i); + CaliType tmp = null; + tmp = arg.eval(env, getRef); + if(!tmp.isEx()) { + lst.add(tmp); + } else { + ret = tmp; + break; + } + } + return ret; + } +} diff --git a/cali.lang.base/src/com/cali/ast/astIfElse.java b/cali.lang.base/src/com/cali/ast/astIfElse.java new file mode 100644 index 0000000..bb1a0b6 --- /dev/null +++ b/cali.lang.base/src/com/cali/ast/astIfElse.java @@ -0,0 +1,130 @@ +/* + * Copyright 2017 Austin Lehman + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.cali.ast; + +import java.util.ArrayList; + +import com.cali.Environment; +import com.cali.types.CaliBool; +import com.cali.types.CaliNull; +import com.cali.types.CaliType; + +public class astIfElse extends astNode implements astNodeInt { + private astConditionBlock ifCondition; + private ArrayList ifElseConditions = new ArrayList(); + private astStatementList elseInstructionList = new astStatementList(); + + public astIfElse() { + this.setType(astNodeType.IFELSE); + } + + public void addToIfElseInstructionList(astNode Node) { + this.ifElseConditions.add(Node); + } + + public void addToElseInstructionList(astNode Node) { + this.elseInstructionList.getStatements().add(Node); + } + + public String toString() { + return this.toString(0); + } + + @Override + public String toString(int Level) { + String rstr = ""; + + rstr += getTabs(Level) + "{\n"; + rstr += this.getNodeStr(Level + 1) + ",\n"; + + if(this.ifCondition != null) { + rstr += getTabs(Level + 1) + "\"ifCondition\":\n"; + rstr += this.ifCondition.toString(Level + 1) + ",\n"; + } + + if(this.ifElseConditions != null) { + rstr += getTabs(Level + 1) + "\"ifElseConditions\": {\n"; + for(int i = 0; i < this.ifElseConditions.size(); i++) + rstr += ((astNodeInt)this.ifElseConditions.get(i)).toString(Level + 2) + ",\n"; + rstr += getTabs(Level + 1) + "}"; + } + + if(this.elseInstructionList != null) { + rstr += getTabs(Level + 1) + "\"elseInstructionList\":\n"; + rstr += this.elseInstructionList.toString(Level + 1) + "\n"; + } + + rstr += getTabs(Level) + "}"; + return rstr; + } + + @Override + public CaliType evalImpl(Environment env, boolean getref) throws caliException { + CaliType ret = new CaliNull(); + CaliType etmp = this.ifCondition.getExpression().eval(env, getref); + CaliBool tmp = etmp.evalExpressionBool(); + if(!tmp.getValue()) { + // Else If Blocks + for(int i = 0; (i < this.ifElseConditions.size())&&(!tmp.getValue()); i++) { + astConditionBlock acb = (astConditionBlock)this.ifElseConditions.get(i); + etmp = acb.getExpression().eval(env, getref); + tmp = etmp.evalExpressionBool(); + if(tmp.getValue()) { + ret = acb.eval(env, getref); + break; + } + } + // Else block + if(!tmp.getValue()) { + for(astNode inst : this.elseInstructionList.getStatements()) { + ret = inst.eval(env, getref); + if(astNode.isBreakReturnEvent(ret)) + break; + } + } + } + else { + ret = this.ifCondition.eval(env, getref); + } + + return ret; + } + + public astConditionBlock getIfCondition() { + return ifCondition; + } + + public void setIfCondition(astConditionBlock ifCondition) { + this.ifCondition = ifCondition; + } + + public ArrayList getIfElseConditions() { + return ifElseConditions; + } + + public void setIfElseConditions(ArrayList ifElseConditions) { + this.ifElseConditions = (ArrayList)ifElseConditions; + } + + public astStatementList getElseInstructionList() { + return elseInstructionList; + } + + public void setElseInstructionList(astStatementList elseInstructionList) { + this.elseInstructionList = elseInstructionList; + } +} diff --git a/cali.lang.base/src/com/cali/ast/astInclude.java b/cali.lang.base/src/com/cali/ast/astInclude.java new file mode 100644 index 0000000..7c294f3 --- /dev/null +++ b/cali.lang.base/src/com/cali/ast/astInclude.java @@ -0,0 +1,79 @@ +/* + * Copyright 2017 Austin Lehman + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.cali.ast; + +import java.util.ArrayList; +import java.util.Arrays; + +import com.cali.Environment; +import com.cali.types.CaliString; +import com.cali.types.CaliType; + +public class astInclude extends astNode implements astNodeInt { + private ArrayList incList = new ArrayList(); + private String ext = ".ca"; + + public astInclude() { + this.setType(astNodeType.INCLUDE); + } + + public astInclude(String Name) { + this.setType(astNodeType.INCLUDE); + this.incList.add(Name); + } + + public void addName(String Name) { + this.incList.add(Name); + } + + public void addFullString(String FullString) { + this.incList = new ArrayList(Arrays.asList(FullString.split("\\."))); + } + + public String getPath() { + String path = ""; + for(int i = 0; i < this.incList.size(); i++) { + path += incList.get(i); + if(i < (this.incList.size() -1)) + path += System.getProperty("file.separator"); + } + if(!path.equals("")) + path += this.ext; + return path; + } + + public String getExternClass() { + String path = ""; + for(int i = 0; i < this.incList.size(); i++) { + path += incList.get(i); + if(i < (this.incList.size() -1)) + path += "."; + } + return path; + } + + @Override + public String toString(int Level) { + // TODO Auto-generated method stub + return null; + } + + @Override + public CaliType evalImpl(Environment env, boolean getref) { + return new CaliString(this.getPath()); + } +} diff --git a/cali.lang.base/src/com/cali/ast/astInt.java b/cali.lang.base/src/com/cali/ast/astInt.java new file mode 100644 index 0000000..6ff419a --- /dev/null +++ b/cali.lang.base/src/com/cali/ast/astInt.java @@ -0,0 +1,66 @@ +/* + * Copyright 2017 Austin Lehman + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.cali.ast; + +import com.cali.Environment; +import com.cali.types.CaliInt; +import com.cali.types.CaliType; + + +public class astInt extends astNode implements astNodeInt { + private long value = 0; + + public astInt() { + this.setType(astNodeType.INT); + } + + public astInt(long Value) { + this.setType(astNodeType.INT); + this.value = Value; + } + + public long getValueInt() { + return this.value; + } + + public String toString() { + return this.toString(0); + } + + public String toString(int Level) { + String rstr = ""; + rstr += getTabs(Level) + "{\n"; + rstr += this.getNodeStr(Level + 1) + ",\n"; + rstr += getTabs(Level + 1) + "\"value\": " + this.value + "\n"; + if(this.getChild() != null) { + rstr += getTabs(Level + 1) + "\"child\":\n"; + rstr += ((astNodeInt)this.getChild()).toString(Level + 1) + ",\n"; + } + rstr += getTabs(Level) + "}"; + return rstr; + } + + + public CaliType evalImpl(Environment env, boolean getref) throws caliException { + CaliType ret = new CaliInt(this.value); + if (this.getChild() != null) { + Environment tenv = env.clone(ret); + return this.getChild().eval(tenv, getref); + } + return ret; + } +} diff --git a/cali.lang.base/src/com/cali/ast/astList.java b/cali.lang.base/src/com/cali/ast/astList.java new file mode 100644 index 0000000..7d40c83 --- /dev/null +++ b/cali.lang.base/src/com/cali/ast/astList.java @@ -0,0 +1,76 @@ +/* + * Copyright 2017 Austin Lehman + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.cali.ast; + +import java.util.ArrayList; + +import com.cali.Environment; +import com.cali.types.CaliList; +import com.cali.types.CaliType; + +public class astList extends astNode implements astNodeInt { + private ArrayList items = new ArrayList(); + + public astList() { + this.setType(astNodeType.LIST); + } + + public astList(ArrayList Items) { + this.setType(astNodeType.LIST); + this.items = Items; + } + + public void add(astNode Node) { this.items.add(Node); } + public int size() { return this.items.size(); } + public void setItems(ArrayList Items) { this.items = Items; } + public ArrayList getItems() { return this.items; } + + public String toString() { + return this.toString(0); + } + + public String toString(int Level) { + String rstr = ""; + rstr += getTabs(Level) + "{\n"; + rstr += this.getNodeStr(Level + 1) + ",\n"; + rstr += getTabs(Level + 1) + "\"items\": [\n"; + for(int i = 0; i < this.items.size(); i++) + rstr += ((astNodeInt)this.items.get(i)).toString(Level + 2); + rstr += getTabs(Level + 1) + "]\n"; + if(this.getChild() != null) { + rstr += getTabs(Level + 1) + "\"child\":\n"; + rstr += ((astNodeInt)this.getChild()).toString(Level + 1) + ",\n"; + } + rstr += getTabs(Level) + "}"; + return rstr; + } + + @Override + public CaliType evalImpl(Environment env, boolean getref) throws caliException { + CaliList cl = new CaliList(); + for (astNode item : this.items) { + cl.add(item.eval(env, getref)); + } + + if (this.getChild() != null) { + Environment tenv = env.clone(cl); + return this.getChild().eval(tenv, getref); + } + + return cl; + } +} diff --git a/cali.lang.base/src/com/cali/ast/astMap.java b/cali.lang.base/src/com/cali/ast/astMap.java new file mode 100644 index 0000000..69d9fab --- /dev/null +++ b/cali.lang.base/src/com/cali/ast/astMap.java @@ -0,0 +1,102 @@ +/* + * Copyright 2017 Austin Lehman + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.cali.ast; + +import java.util.Map; +import java.util.concurrent.ConcurrentHashMap; + +import com.cali.Environment; +import com.cali.types.CaliMap; +import com.cali.types.CaliType; +import com.cali.types.CaliTypeInt; + +public class astMap extends astNode implements astNodeInt { + private Map items = new ConcurrentHashMap(); + + public astMap() { + this.setType(astNodeType.MAP); + } + + public astMap(Map Items) { + this(); + this.items = Items; + } + + public void add(astNode Key, astNode Value) { this.items.put(Key, Value); } + public boolean containsKey(String Key) { return this.items.containsKey(Key); } + public astNode get(String Key) { return this.items.get(Key); } + public int size() { return this.items.size(); } + + public String toString() { + return this.toString(0); + } + + @Override + public String toString(int Level) { + String rstr = ""; + rstr += getTabs(Level) + "{\n"; + rstr += this.getNodeStr(Level + 1) + ",\n"; + rstr += getTabs(Level + 1) + "\"pairs\": [\n"; + for(astNode key : this.items.keySet()) { + astNode value = this.items.get(key); + rstr += getTabs(Level + 2) + "{\n"; + rstr += getTabs(Level + 3) + "\"key\":\n"; + rstr += ((astNodeInt)key).toString(Level + 3) + ",\n"; + rstr += getTabs(Level + 3) + "\"value\":\n"; + rstr += ((astNodeInt)value).toString(Level + 3); + rstr += getTabs(Level + 2) + "},\n"; + } + rstr += getTabs(Level + 1) + "]\n"; + if(this.getChild() != null) { + rstr += getTabs(Level + 1) + "\"child\":\n"; + rstr += ((astNodeInt)this.getChild()).toString(Level + 1) + ",\n"; + } + rstr += getTabs(Level) + "}"; + return rstr; + } + + @Override + public CaliType evalImpl(Environment env, boolean getref) throws caliException { + CaliMap cm = new CaliMap(); + for (astNode key : this.items.keySet()) { + astNode tn = this.items.get(key); + String kstr = ""; + if (key.getType() == astNodeType.VAR || (key.getType() == astNodeType.OBJ && ((astObj)key).getChild() == null)) { + kstr = key.getName(); + } else { + CaliType kval = key.eval(env, getref); + kstr = ((CaliTypeInt)kval).str(); + } + cm.put(kstr, tn.eval(env, getref)); + } + + if (this.getChild() != null) { + Environment tenv = env.clone(cm); + return this.getChild().eval(tenv, getref); + } + + return cm; + } + + public Map getItems() { + return items; + } + + public void setItems(Map items) { + this.items = items; + } +} diff --git a/cali.lang.base/src/com/cali/ast/astNewInst.java b/cali.lang.base/src/com/cali/ast/astNewInst.java new file mode 100644 index 0000000..6a32002 --- /dev/null +++ b/cali.lang.base/src/com/cali/ast/astNewInst.java @@ -0,0 +1,105 @@ +/* + * Copyright 2017 Austin Lehman + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.cali.ast; + +import java.util.ArrayList; + +import com.cali.Environment; +import com.cali.types.CaliList; +import com.cali.types.CaliNull; +import com.cali.types.CaliObject; +import com.cali.types.CaliType; + +public class astNewInst extends astNode implements astNodeInt { + private astFunctDefArgsList args = new astFunctDefArgsList(); + + public astNewInst() { + this.setType(astNodeType.NEWINST); + } + + public astNewInst(String Name) { + this.setType(astNodeType.NEWINST); + this.setName(Name); + } + + public void addArg(astNode Arg) { this.args.getArgs().add(Arg); } + + @Override + public String toString() { + return this.toString(0); + } + + @Override + public String toString(int Level) { + String rstr = ""; + rstr += getTabs(Level) + "{\n"; + rstr += this.getNodeStr(Level + 1) + ",\n"; + rstr += getTabs(Level + 1) + "\"constructor\": \"" + this.getName() + "\"\n"; + if(this.args != null) { + rstr += getTabs(Level + 1) + "\"argumentList\":\n"; + rstr += this.args.toString(Level + 1) + ",\n"; + } + if(this.getChild() != null) { + rstr += getTabs(Level + 1) + "\"child\":\n"; + rstr += ((astNodeInt)this.getChild()).toString(Level + 1) + ",\n"; + } + rstr += getTabs(Level) + "}"; + return rstr; + } + + @Override + public CaliType evalImpl(Environment env, boolean getref) throws caliException { + CaliType ret = new CaliNull(); + + if(env.getEngine().containsClass(this.getName())) { + CaliList cargs = (CaliList) this.args.eval(env, getref); + CaliObject cobj = (CaliObject) env.getEngine().getClassByName(this.getName()).instantiate(env, getref, cargs); + + if(cobj != null) { + ret = cobj; + } else { + throw new caliException(this, "Cannot instantiate object of type '" + this.getName() + "', class definition not found.", env.stackTraceToString()); + } + } else { + throw new caliException(this, "Cannot instantiate class '" + this.getName() + "'.", env.stackTraceToString()); + } + + if (this.getChild() != null) { + Environment tenv = env.clone(ret); + return this.getChild().eval(tenv, getref); + } + + return ret; + } + + public astFunctDefArgsList getArgs() { + return args; + } + + public void setArgs(astFunctDefArgsList args) { + this.args = args; + } + + public ArrayList getEvaledArgs(Environment env) throws caliException { + ArrayList eargs = new ArrayList(); + for(astNode tn : this.args.getArgs()) { + CaliType res = tn.eval(env); + eargs.add(res); + } + return eargs; + } +} diff --git a/cali.lang.base/src/com/cali/ast/astNode.java b/cali.lang.base/src/com/cali/ast/astNode.java new file mode 100644 index 0000000..4e13152 --- /dev/null +++ b/cali.lang.base/src/com/cali/ast/astNode.java @@ -0,0 +1,217 @@ +/* + * Copyright 2017 Austin Lehman + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.cali.ast; + +import com.cali.Environment; +import com.cali.types.CaliType; +import com.cali.types.cType; + +public class astNode { + private String name = ""; + private astNodeType type = astNodeType.UNDEF; + private String fileName = ""; + private int lineNum = 0; + private int colNum = 0; + + private AccessType accessType = AccessType.aPrivate; + + // Primative type allows for strong typing. + protected cType primativeType = cType.cUndef; + + private astNode child = null; + + public void setPrimType(cType PrimType) { + this.primativeType = PrimType; + } + + public cType getPrimType() { + return this.primativeType; + } + + public String getNodeStr(int Level) { + String rstr = ""; + rstr += getTabs(Level) + "\"type\": \"" + this.type.name() + "\",\n"; + rstr += getTabs(Level) + "\"name\": \"" + this.name + "\",\n"; + rstr += getTabs(Level) + "\"line\": " + this.getLineNum(); + if (this.type != astNodeType.UNDEF) { + rstr += ",\n"; + rstr += getTabs(Level) + "\"dataType\": \"" + this.type.name() + "\""; + } + if (this.primativeType != cType.cUndef) { + rstr += ",\n"; + rstr += getTabs(Level) + "\"primativeType\": \"" + this.primativeType.name() + "\""; + } + return rstr; + } + + public static String getTabs(int level) { + String s = ""; + for(int i = 0; i < level; i++) s += "\t"; + return s; + } + + public String getName() { + return name; + } + public void setName(String name) { + this.name = name; + } + public astNodeType getType() { + return type; + } + public void setType(astNodeType type) { + this.type = type; + } + + public void setFileName(String FileName){ + this.fileName = FileName; + } + + public String getFileName() { + return this.fileName; + } + + public void setLineNum(int LineNum) { + this.lineNum = LineNum; + } + + public int getLineNum() { + return this.lineNum; + } + + public void setColNum(int ColNum) { + this.colNum = ColNum; + } + + public int getColNum() { + return this.colNum; + } + + public void setChild(astNode Child) { + this.child = Child; + } + + public astNode getChild() { + return this.child; + } + + public void setParserInfo(String FileName, int LineNum, int ColNum) { + this.fileName = FileName; + this.lineNum = LineNum; + this.colNum = ColNum; + } + + public CaliType eval(Environment env) throws caliException { + return this.eval(env, false); + } + + public CaliType eval(Environment env, boolean getref) throws caliException { + CaliType ret = null; + + switch(type) { + case NULL: + ret = ((astNull)this).evalImpl(env, getref); + break; + case BOOL: + ret = ((astBool)this).evalImpl(env, getref); + break; + case INT: + ret = ((astInt)this).evalImpl(env, getref); + break; + case DOUBLE: + ret = ((astDouble)this).evalImpl(env, getref); + break; + case STRING: + ret = ((astString)this).evalImpl(env, getref); + break; + case LIST: + ret = ((astList)this).evalImpl(env, getref); + break; + case MAP: + ret = ((astMap)this).evalImpl(env, getref); + break; + case OBJ: + ret = ((astObj)this).evalImpl(env, getref); + break; + case VAR: + ret = ((astVar)this).evalImpl(env, getref); + break; + case EXP: + ret = ((astExpression)this).evalImpl(env, getref); + break; + case FUNCTCALL: + ret = ((astFunctCall)this).evalImpl(env, getref); + break; + case FUNCTDEFARGSLIST: + ret = ((astFunctDefArgsList)this).evalImpl(env, getref); + break; + case RETURN: + ret = ((astReturn)this).evalImpl(env, getref); + break; + case TRYCATCH: + ret = ((astTryCatch)this).evalImpl(env, getref); + break; + case NEWINST: + ret = ((astNewInst)this).evalImpl(env, getref); + break; + case IFELSE: + ret = ((astIfElse)this).evalImpl(env, getref); + break; + case CONDITION: + ret = ((astConditionBlock)this).evalImpl(env, getref); + break; + case SWITCH: + ret = ((astSwitch)this).evalImpl(env, getref); + break; + case WHILE: + ret= ((astWhile)this).evalImpl(env, getref); + break; + case BREAK: + ret = ((astBreak)this).evalImpl(env, getref); + break; + case FOR: + ret = ((astFor)this).evalImpl(env, getref); + break; + case CALLBACK: + ret = ((astCallback)this).evalImpl(env, getref); + break; + case THROW: + ret = ((astThrow)this).evalImpl(env, getref); + break; + case INCLUDE: + ret = ((astInclude)this).evalImpl(env, getref); + break; + default: + throw new caliException(this, "INTERNAL [astNode.eval] Not implemented, attempting to eval type '" + type.name() + "'.", env.stackTraceToString()); + } + + return ret; + } + + public static boolean isBreakReturnEvent(CaliType ret) { + if((ret != null)&&((ret.getType() == cType.cReturn)||(ret.getType() == cType.cBreak))) return true; + return false; + } + + public AccessType getAccessType() { + return accessType; + } + + public void setAccessType(AccessType accessType) { + this.accessType = accessType; + } +} diff --git a/cali.lang.base/src/com/cali/ast/astNodeInt.java b/cali.lang.base/src/com/cali/ast/astNodeInt.java new file mode 100644 index 0000000..5522003 --- /dev/null +++ b/cali.lang.base/src/com/cali/ast/astNodeInt.java @@ -0,0 +1,37 @@ +/* + * Copyright 2017 Austin Lehman + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.cali.ast; + +import com.cali.Environment; +import com.cali.types.CaliType; + + +public interface astNodeInt { + /* Setters */ + public void setName(String Name); + public void setType(astNodeType Type); + + /* Getters */ + public String getName(); + public astNodeType getType(); + + /* To String */ + public String toString(); + public String toString(int Level); + + public CaliType evalImpl(Environment env, boolean getref) throws caliException; +} diff --git a/cali.lang.base/src/com/cali/ast/astNodeType.java b/cali.lang.base/src/com/cali/ast/astNodeType.java new file mode 100644 index 0000000..3abfdfc --- /dev/null +++ b/cali.lang.base/src/com/cali/ast/astNodeType.java @@ -0,0 +1,49 @@ +/* + * Copyright 2017 Austin Lehman + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.cali.ast; + +public enum astNodeType { + UNDEF, + NULL, + BOOL, + INT, + DOUBLE, + STRING, + LIST, + MAP, + INCLUDE, + CLASS, + OBJ, + VAR, + FUNCTDEF, + FUNCTDEFARGSLIST, + STATEMENTLIST, + EXP, + FUNCTCALL, + RETURN, + TRYCATCH, + THROW, + NEWINST, + IFELSE, + CONDITION, + SWITCH, + WHILE, + FOR, + BREAK, + ETCETERA, + CALLBACK +} diff --git a/cali.lang.base/src/com/cali/ast/astNull.java b/cali.lang.base/src/com/cali/ast/astNull.java new file mode 100644 index 0000000..442d2e5 --- /dev/null +++ b/cali.lang.base/src/com/cali/ast/astNull.java @@ -0,0 +1,45 @@ +/* + * Copyright 2017 Austin Lehman + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.cali.ast; + +import com.cali.Environment; +import com.cali.types.CaliNull; +import com.cali.types.CaliType; + +public class astNull extends astNode implements astNodeInt { + public astNull() { + this.setType(astNodeType.NULL); + } + + public String toString() { + return this.toString(0); + } + + @Override + public String toString(int Level) { + String rstr = ""; + rstr += getTabs(Level) + "{\n"; + rstr += this.getNodeStr(Level + 1) + "\n"; + rstr += getTabs(Level) + "}"; + return rstr; + } + + @Override + public CaliType evalImpl(Environment env, boolean getref) throws caliException { + return new CaliNull(); + } +} diff --git a/cali.lang.base/src/com/cali/ast/astObj.java b/cali.lang.base/src/com/cali/ast/astObj.java new file mode 100644 index 0000000..9bb3f01 --- /dev/null +++ b/cali.lang.base/src/com/cali/ast/astObj.java @@ -0,0 +1,270 @@ +/* + * Copyright 2017 Austin Lehman + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.cali.ast; + +import com.cali.Environment; +import com.cali.types.CaliException; +import com.cali.types.CaliException.exType; +import com.cali.types.CaliInt; +import com.cali.types.CaliList; +import com.cali.types.CaliMap; +import com.cali.types.CaliNull; +import com.cali.types.CaliObject; +import com.cali.types.CaliRef; +import com.cali.types.CaliType; +import com.cali.types.CaliTypeInt; +import com.cali.types.cType; + +public class astObj extends astNode implements astNodeInt { + private astNode index = null; + + //private Map members = new ConcurrentHashMap(); + + public astObj() { + this.setType(astNodeType.OBJ); + } + + public void setIndex(astNode Index) { + this.index = Index; + } + + public astNode getIndex() { + return this.index; + } + + @Override + public CaliType evalImpl(Environment env, boolean getRef) throws caliException { + CaliType ret = new CaliNull(); + + if (env.getCurObj() == null) { + ret = this.evalObjStart(env, getRef); + } else { + ret = this.evalObj(env, getRef); + } + + return ret; + } + + /** + * This method is called if the envorinment current object isn't set. This + * is the start of the object path. + * @param env The current Environment object. + * @param getRef a boolean with true to get reference or false for not. + * @return A CaliType object. + * @throws caliException + */ + private CaliType evalObjStart(Environment env, boolean getRef) throws caliException { + CaliType ret = new CaliNull(); + + // this object + if (this.getName().equals("this")) { + // We need to get the object pointer from the + // current object. + if (this.getChild() != null) { + // Set the current object to this class instance. + Environment tenv = env.clone(env.getClassInstance()); + ret = this.getChild().eval(tenv, getRef); + } else { + return env.getClassInstance(); + } + } + + // Found in locals. + else if (!getRef && env.getLocals().contains(this.getName())) { + if (this.getChild() != null) { + Environment tenv = env.clone(env.getLocals().get(this.getName())); + ret = this.getChild().eval(tenv, getRef); + } else { + return env.getLocals().get(this.getName()); + } + } + + // Static object found. + else if (env.getEngine().containsStaticClass(this.getName())) { + if (this.getChild() != null) { + // We need to get the extern static class. + if (this.getChild().getType() == astNodeType.FUNCTCALL || this.getChild().getType() == astNodeType.OBJ) { + Environment tenv = env.clone(env.getEngine().getStaticClass(this.getName())); + ret = this.getChild().eval(tenv, getRef); + } else { + CaliException e = new CaliException(exType.exInternal); + e.setException(getLineNum(), "NOT_IMPLEMENTED", "aObj.callObjStart(): Static class with child of '" + this.getChild().getType().name() + "' found.", env.getCallStack().getStackTrace()); + return e; + } + } else { + CaliException e = new CaliException(exType.exRuntime); + e.setException(getLineNum(), "NO_OPERATION", "aObj.callObjStart(): Static class object found but no child function or property provided.", env.getCallStack().getStackTrace()); + return e; + } + } + + // If getRef is true and we have no children, then just add to locals. + else if (getRef && this.getChild() == null) { + if (!env.getLocals().contains(this.getName())) { + env.getLocals().add(this.getName(), new CaliNull()); + } + CaliRef ref = new CaliRef(); + ref.setMap(this.getName(), env.getLocals().getMap()); + ret = ref; + } + + else if (getRef && this.getChild() != null && env.getLocals().contains(this.getName())) { + Environment tenv = env.clone(env.getLocals().get(this.getName())); + ret = this.getChild().eval(tenv, getRef); + } + + // Else, don't know what to do here. + else { + CaliException e = new CaliException(exType.exInternal); + e.setException(getLineNum(), "NOT_IMPLEMENTED", "aObj.callObjStart(): Unmatched object type for '" + this.getName() + "'.", env.getCallStack().getStackTrace()); + return e; + } + + return ret; + } + + private CaliType evalObj (Environment env, boolean getRef) throws caliException { + CaliType ret = new CaliNull(); + + // Found that it exists in the current object. + if (env.getCurObj() instanceof CaliObject && ((CaliObject)env.getCurObj()).getMembers().contains(this.getName())) { + // Check member access. + if (this.memberHasAccess(env, this.getName())) { + if (this.getChild() != null) { + Environment tenv = env.clone(((CaliObject)env.getCurObj()).getMembers().get(this.getName())); + ret = this.getChild().eval(tenv, getRef); + } else { + if (getRef) { + CaliRef ref = new CaliRef(); + ref.setMap(this.getName(), ((CaliObject)env.getCurObj()).getMembers().getMap()); + ret = ref; + } else { + ret = ((CaliObject)env.getCurObj()).getMembers().get(this.getName()); + } + } + } else { + CaliException e = new CaliException(exType.exRuntime); + e.setException(getLineNum(), "NO_ACCESS", "aObj.callObj(): No access to member '" + this.getName() + "'.", env.getCallStack().getStackTrace()); + return e; + } + } + + // Found in current map object. + else if (env.getCurObj().getType() == cType.cMap) { + String key = this.getName(); + if (this.getIndex() != null) { + Environment tenv = env.clone(((CaliMap)env.getCurObj()).getValue().get(key)); + key = ((CaliTypeInt)this.getIndex().eval(tenv, false)).str(); + } + + if (getRef) { + // Not found, but we're going to return a ref anyway. + CaliRef ref = new CaliRef(); + ref.setMap(key, ((CaliMap)env.getCurObj()).getValue()); + ret = ref; + } else if (((CaliMap)env.getCurObj()).contains(key)) { + // Found that it exists in this map. + if (this.getChild() != null) { + Environment tenv = env.clone(((CaliMap)env.getCurObj()).getValue().get(key)); + ret = this.getChild().eval(tenv, getRef); + } else { + ret = ((CaliMap)env.getCurObj()).getValue().get(key); + } + } else { + CaliException e = new CaliException(exType.exRuntime); + e.setException(this.getLineNum(), "MAP_MISSING_KEY", "aObj.callObj(): Map doesn't have key '" + key + "'.", env.getCallStack().getStackTrace()); + return e; + } + } + + // Found in current list object. + else if (env.getCurObj().getType() == cType.cList) { + // Found that it exists in this map. + if (this.index != null) { + Environment ienv = env.clone(null); + CaliType ctindex = this.index.eval(ienv, false); + if (ctindex.isEx()) { + return ctindex; + } + if (ctindex.getType() == cType.cInt) { + long ind = ((CaliInt)ctindex).getValue(); + CaliList lst = (CaliList)env.getCurObj(); + if (ind >= 0 && ((long)ind) < lst.getValue().size()) { + if (this.getChild() == null) { + ret = lst.getValue().get((int)ind); + } else { + Environment tenv = env.clone(lst.getValue().get((int)ind)); + ret = this.getChild().eval(tenv, getRef); + } + } else { + CaliException e = new CaliException(exType.exRuntime); + e.setException(this.getLineNum(), "INDEX_OUT_OF_BOUNDS", "aObj.callObj(): Index out of bounds.", env.getCallStack().getStackTrace()); + return e; + } + } else { + CaliException e = new CaliException(exType.exRuntime); + e.setException(this.getLineNum(), "INDEX_NOT_FOUND", "aObj.callObj(): Provided index isn't an iteger value.", env.getCallStack().getStackTrace()); + return e; + } + } else { + CaliException e = new CaliException(exType.exRuntime); + e.setException(this.getLineNum(), "INDEX_NOT_FOUND", "aObj.callObj(): List found but no index found.", env.getCallStack().getStackTrace()); + return e; + } + } else { + CaliException e = new CaliException(exType.exInternal); + e.setException(this.getLineNum(), "NOT_IMPLEMENTED", "aObj.callObj(): Unmatched object type for '" + this.getName() + "'.", env.getCallStack().getStackTrace()); + return e; + } + + return ret; + } + + private boolean memberHasAccess (Environment env, String memberName) { + if (env.getClassInstance() != env.getCurObj()) { + astClass ac = ((CaliObject)env.getCurObj()).getClassDef(); + if (ac.containsMember(memberName)) { + if (ac.getMember(memberName).getAccessType() == AccessType.aPrivate) { + return false; + } else { + return true; + } + } else { + return true; + } + } else { + return true; + } + } + + @Override + public String toString(int Level) { + String rstr = ""; + rstr += getTabs(Level) + "{\n"; + rstr += this.getNodeStr(Level + 1) + ",\n"; + if(this.index != null) { + rstr += getTabs(Level + 1) + "\"index\":\n"; + rstr += ((astNodeInt)this.index).toString(Level + 1) + ",\n"; + } + if(this.getChild() != null) { + rstr += getTabs(Level + 1) + "\"child\":\n"; + rstr += ((astNodeInt)this.getChild()).toString(Level + 1) + ",\n"; + } + rstr += getTabs(Level) + "}"; + return rstr; + } +} diff --git a/cali.lang.base/src/com/cali/ast/astReturn.java b/cali.lang.base/src/com/cali/ast/astReturn.java new file mode 100644 index 0000000..5f28f9a --- /dev/null +++ b/cali.lang.base/src/com/cali/ast/astReturn.java @@ -0,0 +1,61 @@ +/* + * Copyright 2017 Austin Lehman + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.cali.ast; + +import com.cali.Environment; +import com.cali.types.CaliReturn; +import com.cali.types.CaliType; + +public class astReturn extends astNode implements astNodeInt +{ + private astNode value = null; + + public astReturn() { + this.setType(astNodeType.RETURN); + } + + public void setValue(astNode Value) { + this.value = Value; + } + + @Override + public String toString() { + return this.toString(0); + } + + @Override + public String toString(int Level) { + String rstr = ""; + rstr += getTabs(Level) + "{\n"; + rstr += this.getNodeStr(Level + 1) + ",\n"; + if(this.value != null) { + rstr += getTabs(Level + 1) + "\"value\": [\n"; + rstr += ((astNodeInt)this.value).toString(Level + 1) + ",\n"; + } + rstr += getTabs(Level) + "}"; + return rstr; + } + + @Override + public CaliType evalImpl(Environment env, boolean getref) throws caliException { + CaliReturn ret = new CaliReturn(); + if(this.value != null) { + ret.setValue(this.value.eval(env, getref)); + } + return ret; + } +} diff --git a/cali.lang.base/src/com/cali/ast/astStatementList.java b/cali.lang.base/src/com/cali/ast/astStatementList.java new file mode 100644 index 0000000..021a224 --- /dev/null +++ b/cali.lang.base/src/com/cali/ast/astStatementList.java @@ -0,0 +1,74 @@ +/* + * Copyright 2017 Austin Lehman + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.cali.ast; + +import java.util.ArrayList; +import java.util.List; + +import com.cali.Environment; +import com.cali.types.CaliNull; +import com.cali.types.CaliType; + +public class astStatementList extends astNode implements astNodeInt { + private List statements = new ArrayList(); + + public astStatementList() { + this.setType(astNodeType.STATEMENTLIST); + } + + public astStatementList(String Name) { + this(); + this.setName(Name); + } + + public List getStatements() { + return statements; + } + + public void setStatements(List statements) { + this.statements = statements; + } + + public void addNode(astNode Node) { + this.statements.add(Node); + } + + @Override + public CaliType evalImpl(Environment env, boolean getRef) throws caliException { + CaliType ret = new CaliNull(); + for(int i = 0; i < this.statements.size(); i++) { + ret = this.statements.get(i).eval(env, getRef); + if (ret.isEx() || ret.isReturn() || ret.isBreak()) { + break; + } + } + return ret; + } + + @Override + public String toString(int Level) { + String rstr = ""; + rstr += getTabs(Level) + "{\n"; + rstr += this.getNodeStr(Level + 1) + ",\n"; + rstr += getTabs(Level + 1) + "\"statements\": [\n"; + for(int i = 0; i < statements.size(); i++) + rstr += ((astNodeInt)this.statements.get(i)).toString(Level + 2) + ",\n"; + rstr += getTabs(Level + 1) + "]\n"; + rstr += getTabs(Level) + "}"; + return rstr; + } +} diff --git a/cali.lang.base/src/com/cali/ast/astString.java b/cali.lang.base/src/com/cali/ast/astString.java new file mode 100644 index 0000000..d2aaebc --- /dev/null +++ b/cali.lang.base/src/com/cali/ast/astString.java @@ -0,0 +1,67 @@ +/* + * Copyright 2017 Austin Lehman + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.cali.ast; + +import com.cali.Environment; +import com.cali.types.CaliString; +import com.cali.types.CaliType; + +public class astString extends astNode implements astNodeInt +{ + private String value = ""; + + public astString() { + this.setType(astNodeType.STRING); + } + + public astString(String Value) { + this.setType(astNodeType.STRING); + if(Value instanceof String) + this.value = Value; + } + + public String getValueString() { + return this.value; + } + + public String toString() { + return this.toString(0); + } + + public String toString(int Level) { + String rstr = ""; + rstr += getTabs(Level) + "{\n"; + rstr += this.getNodeStr(Level + 1) + ",\n"; + rstr += getTabs(Level + 1) + "\"value\": " + this.value + "\n"; + if(this.getChild() != null) { + rstr += getTabs(Level + 1) + "\"child\":\n"; + rstr += ((astNodeInt)this.getChild()).toString(Level + 1) + ",\n"; + } + rstr += getTabs(Level) + "}"; + return rstr; + } + + @Override + public CaliType evalImpl(Environment env, boolean getref) throws caliException { + CaliType ret = new CaliString(this.value); + if (this.getChild() != null) { + Environment tenv = env.clone(ret); + return this.getChild().eval(tenv, getref); + } + return ret; + } +} diff --git a/cali.lang.base/src/com/cali/ast/astSwitch.java b/cali.lang.base/src/com/cali/ast/astSwitch.java new file mode 100644 index 0000000..4830f28 --- /dev/null +++ b/cali.lang.base/src/com/cali/ast/astSwitch.java @@ -0,0 +1,124 @@ +/* + * Copyright 2017 Austin Lehman + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.cali.ast; + +import java.util.ArrayList; + +import com.cali.Environment; +import com.cali.types.CaliBool; +import com.cali.types.CaliNull; +import com.cali.types.CaliType; + +public class astSwitch extends astNode implements astNodeInt { + private astNode expr = null; + private ArrayList caseConditions = new ArrayList(); + private astStatementList defaultList = new astStatementList(); + + public astSwitch() { + this.setType(astNodeType.SWITCH); + } + + public void addToCaseList(astNode Node) { + this.caseConditions.add(Node); + } + + public void addToDefaultInstructionList(astNode Node) { + this.defaultList.getStatements().add(Node); + } + + public String toString() { + return this.toString(0); + } + + @Override + public String toString(int Level) { + String rstr = ""; + + rstr += getTabs(Level) + "{\n"; + rstr += this.getNodeStr(Level + 1) + ",\n"; + + if(this.expr != null) { + rstr += getTabs(Level + 1) + "\"Expression\":\n"; + rstr += ((astNodeInt)this.expr).toString(Level + 1) + ",\n"; + } + + if(this.caseConditions != null) { + rstr += getTabs(Level + 1) + "\"caseConditions\": {\n"; + for(int i = 0; i < this.caseConditions.size(); i++) + rstr += ((astNodeInt)this.caseConditions.get(i)).toString(Level + 2) + ",\n"; + rstr += getTabs(Level + 1) + "}"; + } + + if(this.defaultList != null) { + rstr += getTabs(Level + 1) + "\"defaultList\":\n"; + rstr += this.defaultList.toString(Level + 1) + "\n"; + } + + rstr += getTabs(Level) + "}"; + return rstr; + } + + @Override + public CaliType evalImpl(Environment env, boolean getref) throws caliException { + CaliType ret = new CaliNull(); + CaliType tmp = this.expr.eval(env, getref); + boolean found = false; + // Else If Blocks + for(int i = 0; (i < this.caseConditions.size())&&(!found); i++) { + astConditionBlock acb = (astConditionBlock)this.caseConditions.get(i); + CaliType etemp = acb.getExpression().eval(env, getref); + if(tmp.getType() == etemp.getType()) { + CaliBool res = tmp.compareEqual(env, etemp); + if(res.getValue()) { + ret = acb.eval(env, getref); + found = true; + break; + } + } else { + throw new caliException(acb, "Switch statement expecting type '" + tmp.getType().name() + " but found type '" + etemp.getType().name() + "'.", env.stackTraceToString()); + } + } + // Else block + if(!found) { + for(astNode inst : this.defaultList.getStatements()) { + ret = inst.eval(env, getref); + if(astNode.isBreakReturnEvent(ret)) + break; + } + } + return ret; + } + + public void setExpression(astNode Expr) { this.expr = Expr; } + public astNode getExpression() { return this.expr; } + + public ArrayList getCaseConditions() { + return caseConditions; + } + + public void setCaseConditions(ArrayList caseConditions) { + this.caseConditions = caseConditions; + } + + public astStatementList getDefaultList() { + return defaultList; + } + + public void setDefaultList(astStatementList defaultList) { + this.defaultList = defaultList; + } +} diff --git a/cali.lang.base/src/com/cali/ast/astThrow.java b/cali.lang.base/src/com/cali/ast/astThrow.java new file mode 100644 index 0000000..1ced210 --- /dev/null +++ b/cali.lang.base/src/com/cali/ast/astThrow.java @@ -0,0 +1,53 @@ +/* + * Copyright 2017 Austin Lehman + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.cali.ast; + +import com.cali.Environment; +import com.cali.types.CaliException; +import com.cali.types.CaliType; +import com.cali.types.CaliTypeInt; + +public class astThrow extends astNode implements astNodeInt +{ + private astNode expression = new astNull(); + + public astThrow() { this.setType(astNodeType.THROW); } + + public void setExpression(astNode Expression) { this.expression = Expression; } + public astNode getExpression() { return this.expression; } + + public String toString() { + return this.toString(0); + } + + @Override + public String toString(int Level) { + String rstr = ""; + rstr += getTabs(Level) + "{\n"; + rstr += this.getNodeStr(Level + 1) + ",\n"; + rstr += getTabs(Level + 1) + "\"expression\":\n"; + rstr += ((astNodeInt)this.expression).toString(Level + 2); + rstr += getTabs(Level) + "}"; + return rstr; + } + + @Override + public CaliType evalImpl(Environment env, boolean getref) throws caliException { + CaliType ret = this.expression.eval(env, getref); + return new CaliException(((CaliTypeInt)ret).str()); + } +} diff --git a/cali.lang.base/src/com/cali/ast/astTryCatch.java b/cali.lang.base/src/com/cali/ast/astTryCatch.java new file mode 100644 index 0000000..2fd6917 --- /dev/null +++ b/cali.lang.base/src/com/cali/ast/astTryCatch.java @@ -0,0 +1,141 @@ +/* + * Copyright 2017 Austin Lehman + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.cali.ast; + +import com.cali.Environment; +import com.cali.types.CaliException; +import com.cali.types.CaliException.exType; +import com.cali.types.CaliInt; +import com.cali.types.CaliList; +import com.cali.types.CaliNull; +import com.cali.types.CaliObject; +import com.cali.types.CaliString; +import com.cali.types.CaliType; + +public class astTryCatch extends astNode implements astNodeInt +{ + private astStatementList tryInstList = new astStatementList(); + private astStatementList catchInstList = new astStatementList(); + + public astTryCatch() { + this.setType(astNodeType.TRYCATCH); + } + + @Override + public String toString() { + return this.toString(0); + } + + @Override + public String toString(int Level) { + String rstr = ""; + rstr += getTabs(Level) + "{\n"; + rstr += this.getNodeStr(Level + 1) + ",\n"; + + if(this.tryInstList != null) { + rstr += getTabs(Level + 1) + "\"try\":\n"; + rstr += this.tryInstList.toString(Level + 1) + ",\n"; + } + + rstr += getTabs(Level + 1) + "\"catchObject\": \"" + this.getName() + "\"\n"; + + if(this.catchInstList != null) { + rstr += getTabs(Level + 1) + "\"catch\":\n"; + rstr += this.catchInstList.toString(Level + 1) + "\n"; + } + + rstr += getTabs(Level) + "}"; + return rstr; + } + + @Override + public CaliType evalImpl(Environment env, boolean getRef) throws caliException { + CaliType ret = new CaliNull(); + CaliType except = new CaliNull(); + + for(int i = 0; (i < this.tryInstList.getStatements().size())&&(!ret.isEx()); i++) { + astNode statement = this.tryInstList.getStatements().get(i); + CaliType tmp = statement.eval(env, getRef); + if(tmp.isBreak() || tmp.isReturn()) { + ret = tmp; + break; + } else if(tmp.isEx()) { + except = tmp; + break; + } + } + + if(!except.isNull()) { + CaliType tnode = this.initArgs(env, getRef, (CaliException)except); + if(tnode.isEx()) { + ret = tnode; + } else { + env.getLocals().add(this.getName(), tnode); + for(int i = 0; (i < this.catchInstList.getStatements().size())&&(!ret.isEx()); i++) { + astNode statement = this.catchInstList.getStatements().get(i); + CaliType tmp = statement.eval(env, getRef); + if(tmp.isBreak() || tmp.isReturn()) { + ret = tmp; + break; + } else if(tmp.isEx()) { + ret = tmp; + break; + } + } + } + } + + return ret; + } + + private CaliType initArgs(Environment env, boolean getRef, CaliException ae) throws caliException { + CaliType ret = new CaliNull(); + + if(this.getName().equals("")) { + CaliException e = new CaliException(exType.exRuntime); + e.setException(getLineNum(), "MALFORMED_CATCH_DEFINITION", "Malformed catch definition.", "Malformed catch definition.", env.getCallStack().getStackTrace()); + ret = e; + } else { + // Instantiate a new exception object and return it. + + if(env.getEngine().containsClass("exception")) { + astClass exClass = env.getEngine().getClassByName("exception"); + ret = exClass.instantiate(env, getRef, new CaliList()); + + CaliObject aci = (CaliObject)ret; + aci.addMember("lineNumber", new CaliInt(ae.getLineNumber())); + aci.addMember("exceptionType", new CaliString(ae.getExceptionTypeString())); + aci.addMember("id", new CaliString(ae.getId())); + aci.addMember("text", new CaliString(ae.getText())); + aci.addMember("details", new CaliString(ae.getDetails())); + aci.addMember("stackTrace", new CaliString(ae.getStackTrace())); + } else { + CaliException e = new CaliException(exType.exRuntime); + e.setException(getLineNum(), "EXCEPTION_CLASS_NOT_FOUND", "Exception class definition not found.", "Exception class definition not found.", env.getCallStack().getStackTrace()); + ret = e; + } + } + + return ret; + } + + public void setTryInstList(astStatementList TryInstList) { this.tryInstList = TryInstList; } + public astStatementList getTryInstList() { return this.tryInstList; } + + public void setCatchInstList(astStatementList CatchInstList) { this.catchInstList = CatchInstList; } + public astStatementList getCatchInstList() { return this.catchInstList; } +} diff --git a/cali.lang.base/src/com/cali/ast/astVar.java b/cali.lang.base/src/com/cali/ast/astVar.java new file mode 100644 index 0000000..5d21991 --- /dev/null +++ b/cali.lang.base/src/com/cali/ast/astVar.java @@ -0,0 +1,67 @@ +/* + * Copyright 2017 Austin Lehman + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.cali.ast; + +import com.cali.Environment; +import com.cali.types.CaliNull; +import com.cali.types.CaliType; + + +public class astVar extends astNode implements astNodeInt { + protected astNode associative = null; + + public astVar() { + this.setType(astNodeType.VAR); + } + + public astVar(String Name) { + this(); + this.setName(Name); + } + + public astVar(astVar Var) { + this.setType(Var.getType()); + this.setName(Var.getName()); + this.setAssociative(Var.getAssociative()); + } + + public astNode getAssociative() { + return associative; + } + + public void setAssociative(astNode associative) { + this.associative = associative; + } + + public String toString(int Level) { + String rstr = ""; + rstr += getTabs(Level) + "{\n"; + rstr += this.getNodeStr(Level + 1) + "\n"; + rstr += getTabs(Level) + "}"; + return rstr; + } + + @Override + public CaliType evalImpl(Environment env, boolean getref) throws caliException { + CaliType ret = new CaliNull(); + if (env.getLocals().contains(this.getName())) { + // Return local variable. + ret = env.getLocals().get(this.getName()); + } + return ret; + } +} diff --git a/cali.lang.base/src/com/cali/ast/astWhile.java b/cali.lang.base/src/com/cali/ast/astWhile.java new file mode 100644 index 0000000..dc26ceb --- /dev/null +++ b/cali.lang.base/src/com/cali/ast/astWhile.java @@ -0,0 +1,97 @@ +/* + * Copyright 2017 Austin Lehman + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.cali.ast; + +import com.cali.Environment; +import com.cali.types.CaliBool; +import com.cali.types.CaliNull; +import com.cali.types.CaliType; + +public class astWhile extends astNode implements astNodeInt +{ + private astNode expr = null; + private astStatementList instructions = new astStatementList(); + + public astWhile() { + this.setType(astNodeType.WHILE); + } + + public void addToInstructionList(astNode Node) { + this.instructions.getStatements().add(Node); + } + + public String toString() { + return this.toString(0); + } + + @Override + public String toString(int Level) { + String rstr = ""; + + rstr += getTabs(Level) + "{\n"; + rstr += this.getNodeStr(Level + 1) + ",\n"; + + if(this.expr != null) { + rstr += getTabs(Level + 1) + "\"condition\":\n"; + rstr += ((astNodeInt)this.expr).toString(Level + 1) + ",\n"; + } + + if(this.instructions != null) { + rstr += this.instructions.toString(Level + 1); + } + + rstr += getTabs(Level) + "}"; + return rstr; + } + + @Override + public CaliType evalImpl(Environment env, boolean getref) throws caliException { + CaliType ret = new CaliNull(); + CaliType etemp = this.expr.eval(env, getref); + CaliBool tmp = etemp.evalExpressionBool(); + while(tmp.getValue()) { + for(astNode inst : this.instructions.getStatements()) { + ret = inst.eval(env, getref); + if(astNode.isBreakReturnEvent(ret)) + break; + } + if(astNode.isBreakReturnEvent(ret)) + break; + else { + etemp = this.expr.eval(env, getref); + tmp = etemp.evalExpressionBool(); + } + } + return ret; + } + + public astNode getExpr() { + return expr; + } + + public void setExpr(astNode expr) { + this.expr = expr; + } + + public astStatementList getInstructions() { + return instructions; + } + + public void setInstructions(astStatementList instructions) { + this.instructions = instructions; + } +} diff --git a/cali.lang.base/src/com/cali/ast/caliException.java b/cali.lang.base/src/com/cali/ast/caliException.java new file mode 100644 index 0000000..a7b771f --- /dev/null +++ b/cali.lang.base/src/com/cali/ast/caliException.java @@ -0,0 +1,46 @@ +/* + * Copyright 2017 Austin Lehman + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.cali.ast; + + +public class caliException extends Exception { + // Serializable + private static final long serialVersionUID = 1193764482058983012L; + + private String message = ""; + private String trace = ""; + + public caliException(String Message) { + super(Message); + this.message = Message; + } + + public caliException(astNode node, String Message, String Trace) { + super(node.getFileName() + " [" + String.valueOf(node.getLineNum()) + "]: " + Message + "\n" + Trace); + this.message = Message; + this.trace = Trace; + } + + public caliException(String message, Throwable throwable) { + super(message, throwable); + } + + public String getCaliMessage() { return this.message; } + public String getCaliTrace() { return this.trace; } + + public String getCaliStackTrace() { return this.message + "\n" + this.trace; } +} \ No newline at end of file diff --git a/cali.lang.base/src/com/cali/ast/expType.java b/cali.lang.base/src/com/cali/ast/expType.java new file mode 100644 index 0000000..8d02915 --- /dev/null +++ b/cali.lang.base/src/com/cali/ast/expType.java @@ -0,0 +1,46 @@ +/* + * Copyright 2017 Austin Lehman + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.cali.ast; + +public enum expType { + UNDEF, + ASSIGNMENT, + ADD, + SUBTRACT, + MULTIPLY, + DIVIDE, + MODULUS, + EQEQ, + NOTEQ, + LT, + GT, + LTEQ, + GTEQ, + NOT, + AND, + OR, + COUNT, + INSERT, + PLEQ, + MIEQ, + MUEQ, + DIEQ, + PLPL, + MIMI, + INSTANCEOF, + INCLUDE +} diff --git a/cali.lang.base/src/com/cali/cali.cup b/cali.lang.base/src/com/cali/cali.cup new file mode 100644 index 0000000..f137ac7 --- /dev/null +++ b/cali.lang.base/src/com/cali/cali.cup @@ -0,0 +1,1612 @@ +/* + * Copyright 2017 Austin Lehman + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.cali; + +import java.math.BigDecimal; +import java.math.BigInteger; + +import java.util.*; +import java.util.concurrent.ConcurrentHashMap; +import java.util.Map; +import java_cup.runtime.*; +import com.cali.Engine; +import com.cali.ast.*; +import com.cali.types.*; +import com.cali.stdlib.console; + +/* Preliminaries to use the scanner. */ +scan with {: return lexer.next_token(); :}; + +parser code {: + public boolean syntaxErrors; + + Lexer lexer; + Engine eng = null; + String fileName; + + public parser(Lexer lex, Engine Eng, String FileName) { + super(lex); + lexer = lex; + this.eng = Eng; + this.fileName = FileName; + } + + public void report_error(String message, Object info) + { + syntaxErrors = true; + + if ( !(info instanceof Symbol) ) return; + Symbol symbol = (Symbol) info; + + if ( symbol.left < 0 || symbol.right < 0 ) return; + + astNode n = new astNode(); + n.setParserInfo(this.fileName, symbol.left, symbol.right); + caliException ce = new caliException(n, "PARSE_ERROR: Unknown symbol found at line " + symbol.left + " column " + symbol.right + ".", ""); + console.get().err(ce.getMessage()); + this.eng.setParseError(); + this.done_parsing(); // Forces parser to quit + } + + public void report_fatal_error(String message, Object info) + { + this.report_error(message, info); + this.eng.setParseError(); + this.done_parsing(); // Forces parser to quit + } + + public Engine getEngine() { + return this.eng; + } + +:}; + +/* Terminals (tokens returned by lexer). */ +terminal CLASSDEF; +terminal ENUM; +terminal INCLUDE; +terminal PUBLIC; +terminal PROTECTED; +terminal PRIVATE; +terminal STATIC; +terminal EXTERN; +terminal RETURN; +terminal TRY; +terminal CATCH; +terminal THROW; +terminal NEW; +terminal NULL; +terminal IF; +terminal ELSE; +terminal SWITCH; +terminal CASE; +terminal DEFAULT; +terminal WHILE; +terminal BREAK; +terminal FOR; +terminal INSTANCEOF; + +terminal SEMI; +terminal COLON; +terminal COMMA; +terminal LPAREN, RPAREN; +terminal LBRACKET; +terminal RBRACKET; +terminal LBRACE; +terminal RBRACE; + +terminal Boolean BOOL; +terminal BigInteger INT; +terminal BigDecimal DOUBLE; +terminal String STRING; +terminal String IDENT; +//terminal String VAR; + +terminal EQ; +terminal PLEQ, MIEQ, MUEQ, DIEQ, MODULUSEQ, PLPL, MIMI; +terminal PL, MI, MU, DI, MODULUS; +terminal UMINUS; + +terminal EQEQ; +terminal NOTEQ; +terminal LT; +terminal GT; +terminal LTEQ; +terminal GTEQ; + +terminal NOT; +terminal AND; +terminal OR; +terminal COUNT; +terminal ETCETERA; +terminal CALLBACK; +terminal INSERT; + +terminal DOT; + +/* Non terminals */ +non terminal Engine input; +non terminal Engine block; +non terminal astNode include; +non terminal astNode classDefExpr; +non terminal Boolean isStatic; +non terminal astNode externClassRef; +non terminal AccessType AccessType; +non terminal astNode classSection; +non terminal astNode classBlocks; +non terminal astNode enumBlocks; +non terminal astNode enumRec; +non terminal ArrayList extendClassList; +non terminal astNode memberDefinition; +non terminal astNode functionDefinition; +non terminal astFunctDefArgsList functDefArgList; +non terminal astNode functDefArg; +non terminal cType functDefPrimType; +non terminal astStatementList instructionListBlock; +non terminal astStatementList instructionList; +non terminal astNode instruction; +non terminal astNode returnInstruction; +non terminal astNode tryCatchBlock; +non terminal astNode includeExp; +non terminal astNode expression; +non terminal astNode operExp; +non terminal astNode indexExp; +non terminal ArrayList functCallArgList; + +non terminal astNode expNull; +non terminal astNode expBool; +non terminal astNode expInt; +non terminal astNode expDouble; +non terminal astNode expString; +non terminal astNode expList; +non terminal ArrayList expListItems; +non terminal astNode expListIndividual; +non terminal astNode expMap; +non terminal Map expMapItems; +non terminal astNode expVar; +non terminal astNode expFunctDef; +non terminal astNode expIfBlock; +non terminal astNode expIfBlockList; +non terminal ArrayList expIfElseBlockList; +non terminal astNode expIfElseBlock; +non terminal astStatementList expElse; +non terminal astNode expSwitch; +non terminal astNode expSwitchBlockList; +non terminal ArrayList expCaseBlockList; +non terminal astNode expCaseBlock; +non terminal astStatementList expDefault; +non terminal astNode expWhile; +non terminal astNode expBreak; +non terminal astNode expFor; +non terminal astNode expForExp; +non terminal astNode expEtcetera; +non terminal astNode expCallback; +non terminal astNode expNewList; +non terminal astList expNewListItems; +non terminal astNode expNewMap; +non terminal astMap expNewMapItems; +non terminal astNode expThrow; + +/* Precedences */ +/* + * Precedence operators need to be left here + * at the end! Otherwise Terminal "ILLEGAL" has not been declared + * error will happen. + */ + +precedence right THROW; +precedence right EQ; +precedence right MIEQ, PLEQ, DIEQ, MODULUSEQ, MUEQ, INSERT; +precedence right AND, OR; +precedence right EQEQ, NOTEQ, LT, GT, LTEQ, GTEQ; +precedence right MI, PL; +precedence right DI, MU, MODULUS; +precedence left NOT; +precedence right COUNT; +precedence right INSTANCEOF; +precedence right DOT; +precedence right LBRACE; +precedence left ELSE; +precedence left UMINUS; + + + +input ::= + block:r + {: + RESULT = r; + :} +; + +block ::= + classDefExpr:c + {: + this.parser.eng.addClass(c); + RESULT = this.parser.eng; + :} +| block:r classDefExpr:c + {: + r.addClass(c); + RESULT = r; + :} +| INCLUDE include:i SEMI + {: + this.parser.eng.addInclude(((astInclude)i).getPath()); + RESULT = this.parser.eng; + :} +| block:r INCLUDE include:i SEMI + {: + r.addInclude(((astInclude)i).getPath()); + RESULT = r; + :} +| error + {: + + :} +; + +include ::= + expVar:name + {: + astInclude i = new astInclude(((astVar)name).getName()); + i.setParserInfo(this.parser.fileName, nameleft, nameright); + RESULT = i; + :} +| include:i DOT expVar:name + {: + ((astInclude)i).addName(((astVar)name).getName()); + RESULT = i; + :} +; + +classDefExpr ::= + isStatic:is CLASSDEF IDENT:className classSection:ac + {: + ac.setName(className); + ac.setParserInfo(this.parser.fileName, classNameleft, classNameright); + ((astClass)ac).setStatic((boolean)is); + RESULT = ac; + :} +| isStatic:is CLASSDEF IDENT:className COLON extendClassList:cl classSection:ac + {: + ac.setName(className); + ac.setParserInfo(this.parser.fileName, classNameleft, classNameright); + ((astClass)ac).setStatic((boolean)is); + ((astClass)ac).setExtendedClasses(cl); + RESULT = ac; + :} +| isStatic:is EXTERN CLASSDEF IDENT:className COLON externClassRef:i classSection:ac + {: + ac.setName(className); + ac.setParserInfo(this.parser.fileName, classNameleft, classNameright); + ((astClass)ac).setStatic((boolean)is); + ((astClass)ac).setExtern(true); + ((astClass)ac).setExternClassName(((astInclude)i).getExternClass()); + RESULT = ac; + :} +| ENUM IDENT:enumName LBRACKET enumBlocks:eb RBRACKET + {: + eb.setName(enumName); + eb.setParserInfo(this.parser.fileName, enumNameleft, enumNameright); + ((astClass)eb).setStatic(true); + RESULT = eb; + :} +; + +extendClassList ::= + IDENT:className + {: + ArrayList list = new ArrayList(); + list.add(className); + RESULT = list; + :} +| extendClassList:ecl COMMA IDENT:className + {: + ecl.add(className); + RESULT = ecl; + :} +; + +isStatic ::= + /* Empty */ + {: + RESULT = new Boolean(false); + :} +| STATIC + {: + RESULT = new Boolean(true); + :} +; + +externClassRef ::= + expVar:name + {: + astInclude i = new astInclude(((astVar)name).getName()); + RESULT = i; + :} +| externClassRef:i DOT expVar:name + {: + ((astInclude)i).addName(((astVar)name).getName()); + RESULT = i; + :} +; + +classSection ::= + LBRACKET RBRACKET + {: + astClass ac = new astClass(); + RESULT = ac; + :} +| LBRACKET classBlocks:ac RBRACKET + {: + RESULT = ac; + :} +; + +classBlocks ::= + memberDefinition:v + {: + astClass ac = new astClass(); + ac.addMember(v.getName(), v); + RESULT = (astNode)ac; + :} +| classBlocks:ac memberDefinition:v + {: + ((astClass)ac).addMember(v.getName(), v); + RESULT = ac; + :} +| functionDefinition:f + {: + astClass ac = new astClass(); + ac.addFunction(f.getName(), f); + RESULT = (astNode)ac; + :} +| classBlocks:ac functionDefinition:f + {: + ((astClass)ac).addFunction(f.getName(), f); + RESULT = ac; + :} +; + +memberDefinition ::= + AccessType:am expVar:v SEMI + {: + ((astVar)v).setAccessType(am); + RESULT = v; + :} +| AccessType:am expVar:v EQ expNull:n SEMI + {: + n.setName(v.getName()); + n.setAccessType(am); + RESULT = n; + :} +| AccessType:am expVar:v EQ expBool:b SEMI + {: + b.setName(v.getName()); + b.setAccessType(am); + RESULT = b; + :} +| AccessType:am expVar:v EQ expInt:i SEMI + {: + i.setName(v.getName()); + i.setAccessType(am); + RESULT = i; + :} +| AccessType:am expVar:v EQ expDouble:d SEMI + {: + d.setName(v.getName()); + d.setAccessType(am); + RESULT = d; + :} +| AccessType:am expVar:v EQ expString:s SEMI + {: + s.setName(v.getName()); + s.setAccessType(am); + RESULT = s; + :} +| AccessType:am expVar:v EQ expList:l SEMI + {: + l.setName(v.getName()); + l.setAccessType(am); + RESULT = l; + :} +| AccessType:am expVar:v EQ expMap:d SEMI + {: + d.setName(v.getName()); + d.setAccessType(am); + RESULT = d; + :} +; + +enumBlocks ::= + enumRec:er + {: + astClass ac = new astClass(); + ac.setParserInfo(this.parser.fileName, erleft, erright); + ac.addMember(er.getName(), er); + RESULT = (astNode)ac; + :} +| enumBlocks:eb enumRec:er + {: + ((astClass)eb).addMember(er.getName(), er); + RESULT = eb; + :} +; + +enumRec ::= + expVar:v SEMI + {: + astString tmp = new astString(v.getName()); + tmp.setName(v.getName()); + tmp.setParserInfo(this.parser.fileName, vleft, vright); + tmp.setAccessType(AccessType.aPublic); + RESULT = tmp; + :} +| expVar:v EQ expString:s SEMI + {: + astString tmp = new astString(((astString)s).getValueString()); + tmp.setName(v.getName()); + tmp.setParserInfo(this.parser.fileName, vleft, vright); + tmp.setAccessType(AccessType.aPublic); + RESULT = tmp; + :} +; + + + +functionDefinition ::= + AccessType:am expFunctDef:f LPAREN functDefArgList:al RPAREN LBRACKET instructionList:il RBRACKET + {: + f.setParserInfo(this.parser.fileName, fleft, fright); + ((astFunctDef)f).setArgList(al); + ((astFunctDef)f).setInstructionList(il); + f.setAccessType(am); + RESULT = f; + :} +| AccessType:am expFunctDef:f LPAREN functDefArgList:al RPAREN LBRACKET RBRACKET + {: + f.setParserInfo(this.parser.fileName, fleft, fright); + ((astFunctDef)f).setArgList(al); + f.setAccessType(am); + RESULT = f; + :} +| AccessType:am EXTERN expFunctDef:f LPAREN functDefArgList:al RPAREN SEMI + {: + f.setParserInfo(this.parser.fileName, fleft, fright); + ((astFunctDef)f).setArgList(al); + ((astFunctDef)f).setExtern(true); + f.setAccessType(am); + RESULT = f; + :} +; + +functDefArgList ::= + /* Empty */ + {: + astFunctDefArgsList al = new astFunctDefArgsList(); + RESULT = al; + :} +| functDefArg:fda + {: + astFunctDefArgsList al = new astFunctDefArgsList(); + al.addNode(fda); + RESULT = al; + :} +| functDefArgList:al COMMA functDefArg:fda + {: + al.addNode(fda); + RESULT = al; + :} +| functDefPrimType:p functDefArg:fda + {: + fda.setPrimType(p); + astFunctDefArgsList al = new astFunctDefArgsList(); + al.addNode(fda); + RESULT = al; + :} +| functDefArgList:al COMMA functDefPrimType:p functDefArg:fda + {: + fda.setPrimType(p); + al.addNode(fda); + RESULT = al; + :} +; + +functDefArg ::= + expVar:av + {: + RESULT = av; + :} +| expVar:v EQ expNull:n + {: + n.setName(v.getName()); + RESULT = n; + :} +| expVar:v EQ expBool:b + {: + b.setName(v.getName()); + RESULT = b; + :} +| expVar:v EQ expInt:i + {: + i.setName(v.getName()); + RESULT = i; + :} +| expVar:v EQ expDouble:d + {: + d.setName(v.getName()); + RESULT = d; + :} +| expVar:v EQ expString:s + {: + s.setName(v.getName()); + RESULT = s; + :} +| expVar:v EQ expList:l + {: + l.setName(v.getName()); + RESULT = l; + :} +| expVar:v EQ expMap:d + {: + d.setName(v.getName()); + RESULT = d; + :} +| expEtcetera:etc + {: + RESULT = (astNode)etc; + :} +; + +functDefPrimType ::= + IDENT:s + {: + if(s.equals("bool")) RESULT = cType.cBool; + else if(s.equals("int")) RESULT = cType.cInt; + else if(s.equals("double")) RESULT = cType.cDouble; + else if(s.equals("string")) RESULT = cType.cString; + else if(s.equals("list")) RESULT = cType.cList; + else if(s.equals("map")) RESULT = cType.cMap; + else if(s.equals("object")) RESULT = cType.cObject; + else if(s.equals("callback")) RESULT = cType.cCallback; + else + { + astNode n = new astNode(); + n.setParserInfo(this.parser.fileName, sleft, sright); + throw new caliException(n, "PARSE_ERROR: Expecting primative identifier but found '" + s + "' instead.", ""); + } + :} +; + +instructionList ::= + instruction:i + {: + astStatementList il = new astStatementList(); + il.addNode(i); + RESULT = il; + :} +| instructionList:il instruction:i + {: + il.addNode(i); + RESULT = il; + :} +; + +instruction ::= + expression:e SEMI + {: + RESULT = (astNode)e; + :} +| returnInstruction:r + {: + RESULT = (astNode)r; + :} +| expIfBlock:ib + {: + RESULT = ib; + :} +| expSwitch:s + {: + RESULT = s; + :} +| expWhile:w + {: + RESULT = w; + :} +| expFor:f + {: + RESULT = f; + :} +| tryCatchBlock:tcb + {: + RESULT = (astNode)tcb; + :} +| includeExp:ie + {: + RESULT = ie; + :} +; + +includeExp ::= + INCLUDE include:i SEMI + {: + astExpression e = new astExpression(i); + e.setParserInfo(this.parser.fileName, ileft, iright); + e.seteType(expType.INCLUDE); + RESULT = e; + :} +; + +expression ::= + operExp:oe + {: + RESULT = oe; + :} +| NEW:n expVar:v LPAREN functCallArgList:al RPAREN + {: + astNewInst ni = new astNewInst(((astVar)v).getName()); + ni.setParserInfo(this.parser.fileName, nleft, nright); + astFunctDefArgsList nl = new astFunctDefArgsList(); + nl.setArgs(al); + ni.setArgs(nl); + RESULT = ni; + :} +| expNewList:nl + {: + RESULT = nl; + :} +| expNewMap:nm + {: + RESULT = nm; + :} +| expCallback:cb + {: + RESULT = cb; + :} +| expression:el INSERT expression:er + {: + astExpression e = new astExpression(el); + e.setParserInfo(this.parser.fileName, erleft, erright); + e.setRight(er); + e.seteType(expType.INSERT); + RESULT = e; + :} +| COUNT expression:el + {: + astExpression e = new astExpression(el); + e.setParserInfo(this.parser.fileName, elleft, elright); + e.seteType(expType.COUNT); + RESULT = e; + :} +| expVar:v LPAREN functCallArgList:al RPAREN + {: + astFunctCall afc = new astFunctCall(((astVar)v).getName()); + afc.setParserInfo(this.parser.fileName, vleft, vright); + astFunctDefArgsList nl = new astFunctDefArgsList(); + nl.setArgs(al); + afc.setArgs(nl); + RESULT = afc; + :} +| expression:el DOT expression:er + {: + el.setChild(er); + RESULT = el; + :} +| expression:el INSTANCEOF expression:er + {: + astExpression e = new astExpression(el); + e.setParserInfo(this.parser.fileName, erleft, erright); + e.setRight(er); + e.seteType(expType.INSTANCEOF); + RESULT = e; + :} +| expression:el indexExp:ie + {: + el.setChild(ie); + RESULT = el; + :} +| expVar:v + {: + astObj ao = new astObj(); + ao.setParserInfo(this.parser.fileName, vleft, vright); + ao.setName(v.getName()); + RESULT = ao; + :} +| expNull:n + {: + RESULT = n; + :} +| expBool:b + {: + RESULT = b; + :} +| expInt:i + {: + RESULT = i; + :} +| expDouble:d + {: + RESULT = d; + :} +| expString:s + {: + RESULT = s; + :} +| expBreak:b + {: + RESULT = b; + :} +| expThrow:t + {: + RESULT = t; + :} +| LPAREN expression:e RPAREN + {: + RESULT = e; + :} +; + +indexExp ::= + LBRACE expression:er RBRACE + {: + astObj aobj = new astObj(); + aobj.setParserInfo(this.parser.fileName, erleft, erright); + aobj.setIndex(er); + RESULT = aobj; + :} +| indexExp:ie LBRACE expression:er RBRACE + {: + astObj aobj = new astObj(); + aobj.setParserInfo(this.parser.fileName, erleft, erright); + aobj.setIndex(er); + ie.setChild(aobj); + RESULT = ie; + :} +| indexExp:ie DOT expression:er + {: + ie.setChild(er); + RESULT = ie; + :} +; + +operExp ::= + expression:el PL expression:er + {: + astExpression e = new astExpression(el); + e.setParserInfo(this.parser.fileName, erleft, erright); + e.setRight(er); + e.seteType(expType.ADD); + RESULT = e; + :} +| expression:el MI expression:er + {: + astExpression e = new astExpression(el); + e.setParserInfo(this.parser.fileName, erleft, erright); + e.setRight(er); + e.seteType(expType.SUBTRACT); + RESULT = e; + :} +| expression:el MU expression:er + {: + astExpression e = new astExpression(el); + e.setParserInfo(this.parser.fileName, erleft, erright); + e.setRight(er); + e.seteType(expType.MULTIPLY); + RESULT = e; + :} +| expression:el DI expression:er + {: + astExpression e = new astExpression(el); + e.setParserInfo(this.parser.fileName, erleft, erright); + e.setRight(er); + e.seteType(expType.DIVIDE); + RESULT = e; + :} +| expression:el MODULUS expression:er + {: + astExpression e = new astExpression(el); + e.setParserInfo(this.parser.fileName, erleft, erright); + e.setRight(er); + e.seteType(expType.MODULUS); + RESULT = e; + :} +| expression:el EQ expression:er + {: + astExpression e = new astExpression(el); + e.setParserInfo(this.parser.fileName, erleft, erright); + e.setRight(er); + e.seteType(expType.ASSIGNMENT); + RESULT = e; + :} +| expression:el PLEQ expression:er + {: + astExpression ea = new astExpression(el); + ea.setParserInfo(this.parser.fileName, erleft, erright); + ea.setRight(er); + ea.seteType(expType.ADD); + + astExpression e = new astExpression(el); + e.setParserInfo(this.parser.fileName, erleft, erright); + e.setRight(ea); + e.seteType(expType.ASSIGNMENT); + RESULT = e; + :} +| expression:el MIEQ expression:er + {: + astExpression ea = new astExpression(el); + ea.setParserInfo(this.parser.fileName, erleft, erright); + ea.setRight(er); + ea.seteType(expType.SUBTRACT); + + astExpression e = new astExpression(el); + e.setParserInfo(this.parser.fileName, erleft, erright); + e.setRight(ea); + e.seteType(expType.ASSIGNMENT); + RESULT = e; + :} +| expression:el MUEQ expression:er + {: + astExpression ea = new astExpression(el); + ea.setParserInfo(this.parser.fileName, erleft, erright); + ea.setRight(er); + ea.seteType(expType.MULTIPLY); + + astExpression e = new astExpression(el); + e.setParserInfo(this.parser.fileName, erleft, erright); + e.setRight(ea); + e.seteType(expType.ASSIGNMENT); + RESULT = e; + :} +| expression:el DIEQ expression:er + {: + astExpression ea = new astExpression(el); + ea.setParserInfo(this.parser.fileName, erleft, erright); + ea.setRight(er); + ea.seteType(expType.DIVIDE); + + astExpression e = new astExpression(el); + e.setParserInfo(this.parser.fileName, erleft, erright); + e.setRight(ea); + e.seteType(expType.ASSIGNMENT); + RESULT = e; + :} +| expression:el MODULUSEQ expression:er + {: + astExpression ea = new astExpression(el); + ea.setParserInfo(this.parser.fileName, erleft, erright); + ea.setRight(er); + ea.seteType(expType.MODULUS); + + astExpression e = new astExpression(el); + e.setParserInfo(this.parser.fileName, erleft, erright); + e.setRight(ea); + e.seteType(expType.ASSIGNMENT); + RESULT = e; + :} +| expression:el PLPL + {: + astInt ai = new astInt(1); + ai.setParserInfo(this.parser.fileName, elleft, elright); + + astExpression ea = new astExpression(el); + ea.setParserInfo(this.parser.fileName, elleft, elright); + ea.setRight(ai); + ea.seteType(expType.ADD); + + astExpression e = new astExpression(el); + e.setParserInfo(this.parser.fileName, elleft, elright); + e.setRight(ea); + e.seteType(expType.ASSIGNMENT); + RESULT = e; + :} +| expression:el MIMI + {: + astInt ai = new astInt(1); + ai.setParserInfo(this.parser.fileName, elleft, elright); + + astExpression ea = new astExpression(el); + ea.setParserInfo(this.parser.fileName, elleft, elright); + ea.setRight(ai); + ea.seteType(expType.SUBTRACT); + + astExpression e = new astExpression(el); + e.setParserInfo(this.parser.fileName, elleft, elright); + e.setRight(ea); + e.seteType(expType.ASSIGNMENT); + RESULT = e; + :} +| expression:el EQEQ expression:er + {: + astExpression e = new astExpression(el); + e.setParserInfo(this.parser.fileName, erleft, erright); + e.setRight(er); + e.seteType(expType.EQEQ); + RESULT = e; + :} +| expression:el NOTEQ expression:er + {: + astExpression e = new astExpression(el); + e.setParserInfo(this.parser.fileName, erleft, erright); + e.setRight(er); + e.seteType(expType.NOTEQ); + RESULT = e; + :} +| expression:el LT expression:er + {: + astExpression e = new astExpression(el); + e.setParserInfo(this.parser.fileName, erleft, erright); + e.setRight(er); + e.seteType(expType.LT); + RESULT = e; + :} +| expression:el GT expression:er + {: + astExpression e = new astExpression(el); + e.setParserInfo(this.parser.fileName, erleft, erright); + e.setRight(er); + e.seteType(expType.GT); + RESULT = e; + :} +| expression:el LTEQ expression:er + {: + astExpression e = new astExpression(el); + e.setParserInfo(this.parser.fileName, erleft, erright); + e.setRight(er); + e.seteType(expType.LTEQ); + RESULT = e; + :} +| expression:el GTEQ expression:er + {: + astExpression e = new astExpression(el); + e.setParserInfo(this.parser.fileName, erleft, erright); + e.setRight(er); + e.seteType(expType.GTEQ); + RESULT = e; + :} +| NOT expression:er + {: + astExpression e = new astExpression(er); + e.setParserInfo(this.parser.fileName, erleft, erright); + e.seteType(expType.NOT); + RESULT = e; + :} +| expression:el AND expression:er + {: + astExpression e = new astExpression(el); + e.setParserInfo(this.parser.fileName, erleft, erright); + e.setRight(er); + e.seteType(expType.AND); + RESULT = e; + :} +| expression:el OR expression:er + {: + astExpression e = new astExpression(el); + e.setParserInfo(this.parser.fileName, erleft, erright); + e.setRight(er); + e.seteType(expType.OR); + RESULT = e; + :} +; + +returnInstruction ::= + RETURN:r SEMI + {: + astReturn ar = new astReturn(); + ar.setParserInfo(this.parser.fileName, rleft, rright); + RESULT = ar; + :} +| RETURN:r expression:ex SEMI + {: + astReturn ar = new astReturn(); + ar.setValue(ex); + ar.setParserInfo(this.parser.fileName, rleft, rright); + RESULT = ar; + :} +; + +tryCatchBlock ::= + TRY:t instructionListBlock:til CATCH LPAREN expVar:v RPAREN instructionListBlock:cil + {: + astTryCatch atc = new astTryCatch(); + atc.setParserInfo(this.parser.fileName, tleft, tright); + atc.setName(v.getName()); + atc.setTryInstList(til); + atc.setCatchInstList(cil); + RESULT = atc; + :} +; + +instructionListBlock ::= + LBRACKET RBRACKET + {: + astStatementList il = new astStatementList(); + RESULT = il; + :} +| LBRACKET instructionList:il RBRACKET + {: + RESULT = il; + :} +; + +expIfBlock ::= + expIfBlockList:eibl + {: + RESULT = eibl; + :} +| expIfBlockList:eibl expIfElseBlockList:eiebl + {: + astIfElse aie = (astIfElse)eibl; + aie.setIfElseConditions((ArrayList)eiebl); + RESULT = aie; + :} +| expIfBlockList:eibl expElse:ee + {: + astIfElse aie = (astIfElse)eibl; + aie.setElseInstructionList(ee); + RESULT = aie; + :} +| expIfBlockList:eibl expIfElseBlockList:eiebl expElse:ee + {: + astIfElse aie = (astIfElse)eibl; + aie.setIfElseConditions((ArrayList)eiebl); + aie.setElseInstructionList(ee); + RESULT = aie; + :} +; + +expIfBlockList ::= + IF LPAREN expression:e RPAREN LBRACKET RBRACKET + {: + astIfElse aie = new astIfElse(); + aie.setParserInfo(this.parser.fileName, eleft, eright); + astConditionBlock acb = new astConditionBlock(); + acb.setExpression(e); + aie.setIfCondition(acb); + RESULT = aie; + :} +| IF LPAREN expression:e RPAREN LBRACKET instructionList:iil RBRACKET + {: + astIfElse aie = new astIfElse(); + aie.setParserInfo(this.parser.fileName, eleft, eright); + astConditionBlock acb = new astConditionBlock(); + acb.setExpression(e); + acb.setInstructionList(iil); + aie.setIfCondition(acb); + RESULT = aie; + :} +; + +expIfElseBlockList ::= + expIfElseBlock:el + {: + ArrayList iecl = new ArrayList(); + iecl.add(el); + RESULT = iecl; + :} +| expIfElseBlockList:eieb expIfElseBlock:er + {: + eieb.add(er); + RESULT = eieb; + :} +; + +expIfElseBlock ::= + ELSE IF LPAREN expression:e RPAREN LBRACKET RBRACKET + {: + astConditionBlock acb = new astConditionBlock(); + acb.setParserInfo(this.parser.fileName, eleft, eright); + acb.setExpression(e); + RESULT = acb; + :} +| ELSE IF LPAREN expression:e RPAREN LBRACKET instructionList:iil RBRACKET + {: + astConditionBlock acb = new astConditionBlock(); + acb.setParserInfo(this.parser.fileName, eleft, eright); + acb.setExpression(e); + acb.setInstructionList(iil); + RESULT = acb; + :} +; + +expElse ::= + ELSE LBRACKET RBRACKET + {: + astStatementList list = new astStatementList(); + RESULT = list; + :} +| ELSE LBRACKET instructionList:iil RBRACKET + {: + RESULT = iil; + :} +; + +expSwitch ::= + SWITCH LPAREN expression:e RPAREN LBRACKET expSwitchBlockList:sbl RBRACKET + {: + astSwitch as = (astSwitch)sbl; + as.setParserInfo(this.parser.fileName, eleft, eright); + as.setExpression(e); + RESULT = as; + :} +| SWITCH LPAREN expression:e RPAREN LBRACKET RBRACKET + {: + astSwitch as = new astSwitch(); + as.setParserInfo(this.parser.fileName, eleft, eright); + as.setExpression(e); + RESULT = as; + :} +; + +expSwitchBlockList ::= + expCaseBlockList:ecbl + {: + astSwitch as = new astSwitch(); + as.setCaseConditions(ecbl); + RESULT = as; + :} +| expCaseBlockList:ecbl expDefault:ed + {: + astSwitch as = new astSwitch(); + as.setCaseConditions(ecbl); + as.setDefaultList(ed); + RESULT = as; + :} +; + +expCaseBlockList ::= + expCaseBlock:ecb + {: + ArrayList list = new ArrayList(); + list.add(ecb); + RESULT = list; + :} +| expCaseBlockList:ecbl expCaseBlock:ecb + {: + ecbl.add(ecb); + RESULT = ecbl; + :} +; + +expCaseBlock ::= + CASE expression:e COLON LBRACKET instructionList:il RBRACKET + {: + astConditionBlock acb = new astConditionBlock(); + acb.setParserInfo(this.parser.fileName, eleft, eright); + acb.setExpression(e); + acb.setInstructionList(il); + RESULT = acb; + :} +| CASE expression:e COLON LBRACKET RBRACKET + {: + astConditionBlock acb = new astConditionBlock(); + acb.setParserInfo(this.parser.fileName, eleft, eright); + acb.setExpression(e); + RESULT = acb; + :} +; + +expDefault ::= + DEFAULT COLON LBRACKET instructionList:il RBRACKET + {: + RESULT = il; + :} +| DEFAULT COLON LBRACKET RBRACKET + {: + astStatementList list = new astStatementList(); + RESULT = list; + :} +; + +expWhile ::= + WHILE LPAREN expression:e RPAREN LBRACKET instructionList:il RBRACKET + {: + astWhile aw = new astWhile(); + aw.setParserInfo(this.parser.fileName, eleft, eright); + aw.setExpr(e); + aw.setInstructions(il); + RESULT = aw; + :} +| WHILE LPAREN expression:e RPAREN LBRACKET RBRACKET + {: + astWhile aw = new astWhile(); + aw.setParserInfo(this.parser.fileName, eleft, eright); + aw.setExpr(e); + RESULT = aw; + :} +; + +expFor ::= + FOR:f LPAREN expForExp:einit SEMI expForExp:econd SEMI expForExp:eincr RPAREN LBRACKET instructionList:il RBRACKET + {: + astFor af = new astFor(); + af.setParserInfo(this.parser.fileName, fleft, fright); + af.setExprInit(einit); + af.setExprCond(econd); + af.setExprInc(eincr); + af.setInstructions(il); + RESULT = af; + :} +| FOR:f LPAREN expForExp:einit SEMI expForExp:econd SEMI expForExp:eincr RPAREN LBRACKET RBRACKET + {: + astFor af = new astFor(); + af.setParserInfo(this.parser.fileName, fleft, fright); + af.setExprInit(einit); + af.setExprCond(econd); + af.setExprInc(eincr); + RESULT = af; + :} +| FOR:f LPAREN expVar:ev COLON expression:er RPAREN LBRACKET instructionList:il RBRACKET + {: + astFor af = new astFor(); + af.setParserInfo(this.parser.fileName, fleft, fright); + af.setIsForEach(true); + af.setEachVar(ev); + af.setEachExpr(er); + af.setInstructions(il); + RESULT = af; + :} +| FOR:f LPAREN expVar:ev COLON expression:er RPAREN LBRACKET RBRACKET + {: + astFor af = new astFor(); + af.setParserInfo(this.parser.fileName, fleft, fright); + af.setIsForEach(true); + af.setEachVar(ev); + af.setEachExpr(er); + RESULT = af; + :} +; + +expForExp ::= + /* blank */ + {: + RESULT = new astNull(); + :} +| expression:e + {: + RESULT = e; + :} +; + +functCallArgList ::= + /* Empty */ + {: + ArrayList al = new ArrayList(); + RESULT = al; + :} +| expression:e + {: + ArrayList al = new ArrayList(); + al.add(e); + RESULT = al; + :} +| functCallArgList:al COMMA expression:e + {: + al.add(e); + RESULT = al; + :} +; + +AccessType ::= + /* Empty */ + {: + RESULT = AccessType.aPrivate; + :} +| PUBLIC + {: + RESULT = AccessType.aPublic; + :} +| PROTECTED + {: + RESULT = AccessType.aProtected; + :} +| PRIVATE + {: + RESULT = AccessType.aPrivate; + :} +; + +expNull ::= + NULL:n + {: + astNull an = new astNull(); + an.setParserInfo(this.parser.fileName, nleft, nright); + RESULT = an; + :} +; + +expBool ::= + BOOL:b + {: + astBool ab = new astBool(b); + ab.setParserInfo(this.parser.fileName, bleft, bright); + RESULT = ab; + :} +; + +expInt ::= + INT:i + {: + BigInteger val = i; + if(val.compareTo(new BigInteger(String.valueOf(Long.MAX_VALUE))) == 1) + { + astNode n = new astNode(); + n.setParserInfo(this.parser.fileName, ileft, iright); + throw new caliException(n, "PARSE_ERROR: Integer out of bounds. Integer max size is " + String.valueOf(Long.MAX_VALUE) + ". <" + val.toString() + ">", ""); + } + + astInt ai = new astInt(i.longValue()); + ai.setParserInfo(this.parser.fileName, ileft, iright); + RESULT = ai; + :} +| MI INT:i + {: + BigInteger val = i.multiply(new BigInteger("-1")); + if(val.compareTo(new BigInteger(String.valueOf(Long.MIN_VALUE))) == -1) + { + astNode n = new astNode(); + n.setParserInfo(this.parser.fileName, ileft, iright); + throw new caliException(n, "PARSE_ERROR: Integer out of bounds. Integer min size is " + String.valueOf(Long.MIN_VALUE) + ". <" + val.toString() + ">", ""); + } + + astInt ai = new astInt(val.longValue()); + ai.setParserInfo(this.parser.fileName, ileft, iright); + RESULT = ai; + :} %prec UMINUS +; + +expDouble ::= + DOUBLE:d + {: + BigDecimal val = d; + if(val.compareTo(new BigDecimal(Double.MAX_VALUE)) == 1) + { + astNode n = new astNode(); + n.setParserInfo(this.parser.fileName, dleft, dright); + throw new caliException(n, "PARSE_ERROR: Double out of bounds. Double max size is " + String.valueOf(Double.MAX_VALUE) + ". <" + val.toString() + ">", ""); + } + + astDouble ad = new astDouble(d.doubleValue()); + ad.setParserInfo(this.parser.fileName, dleft, dright); + RESULT = ad; + :} +| MI DOUBLE:d + {: + BigDecimal val = d.multiply(new BigDecimal("-1.0")); + if(val.compareTo(new BigDecimal(-Double.MAX_VALUE)) == -1) + { + astNode n = new astNode(); + n.setParserInfo(this.parser.fileName, dleft, dright); + throw new caliException(n, "PARSE_ERROR: Double out of bounds. Double min size is " + String.valueOf(Double.MIN_NORMAL) + ". <" + val.toString() + ">", ""); + } + + astDouble ad = new astDouble(val.doubleValue()); + ad.setParserInfo(this.parser.fileName, dleft, dright); + RESULT = ad; + :} %prec UMINUS +; + +expString ::= + STRING:s + {: + astString as = new astString(s); + as.setParserInfo(this.parser.fileName, sleft, sright); + RESULT = as; + :} +; + +expList ::= + LBRACE expListItems:l RBRACE + {: + astList al = new astList(l); + al.setParserInfo(this.parser.fileName, lleft, lright); + RESULT = (astNode)al; + :} +| LBRACE:l RBRACE + {: + astList al = new astList(); + al.setParserInfo(this.parser.fileName, lleft, lright); + RESULT = (astNode)al; + :} +; + +expListItems ::= + expListIndividual:i + {: + ArrayList l = new ArrayList(); + l.add(i); + RESULT = l; + :} +| expListItems:l COMMA expListIndividual:i + {: + l.add(i); + RESULT = l; + :} +; + +expListIndividual ::= + expBool:b + {: + RESULT = b; + :} +| expInt:i + {: + RESULT = i; + :} +| expDouble:d + {: + RESULT = d; + :} +| expString:s + {: + RESULT = s; + :} +| expList:l + {: + RESULT = l; + :} +| expMap:d + {: + RESULT = d; + :} +; + +expMap ::= + LBRACKET expMapItems:d RBRACKET + {: + astMap ad = new astMap(d); + ad.setParserInfo(this.parser.fileName, dleft, dright); + RESULT = (astNode)ad; + :} +| LBRACKET:m RBRACKET + {: + astMap am = new astMap(); + am.setParserInfo(this.parser.fileName, mleft, mright); + RESULT = (astNode)am; + :} +; + +expMapItems ::= + expString:s COLON expListIndividual:i + {: + Map d = new ConcurrentHashMap(); + d.put(s, i); + RESULT = d; + :} +| expVar:v COLON expListIndividual:i + {: + Map d = new ConcurrentHashMap(); + d.put(v, i); + RESULT = d; + :} +| expMapItems:d COMMA expString:s COLON expListIndividual:i + {: + d.put(s, i); + RESULT = d; + :} +| expMapItems:d COMMA expVar:v COLON expListIndividual:i + {: + d.put(v, i); + RESULT = d; + :} +; + +expVar ::= + IDENT:s + {: + astVar av = new astVar(); + av.setParserInfo(this.parser.fileName, sleft, sright); + av.setName(s); + RESULT = av; + :} +; + +expFunctDef ::= + IDENT:s + {: + astFunctDef afd = new astFunctDef(s); + afd.setParserInfo(this.parser.fileName, sleft, sright); + RESULT = (astNode)afd; + :} +; + +expBreak ::= + BREAK:b + {: + astBreak ab = new astBreak(); + ab.setParserInfo(this.parser.fileName, bleft, bright); + RESULT = ab; + :} +; + +expEtcetera ::= + ETCETERA:e + {: + astEtcetera etc = new astEtcetera(); + etc.setParserInfo(this.parser.fileName, eleft, eright); + RESULT = etc; + :} +; + +expCallback ::= + CALLBACK:c IDENT:s + {: + astCallback cb = new astCallback(s); + cb.setParserInfo(this.parser.fileName, cleft, cright); + RESULT = cb; + :} +; + +expNewList ::= + LBRACE expNewListItems:el RBRACE + {: + RESULT = el; + :} +; + +expNewListItems ::= + /* Empty */ + {: + RESULT = new astList(); + :} +| expression:el + {: + astList al = new astList(); + al.add(el); + RESULT = al; + :} +| expNewListItems:nl COMMA expression:el + {: + nl.add(el); + RESULT = nl; + :} +; + +expNewMap ::= + LBRACKET expNewMapItems:em RBRACKET + {: + RESULT = em; + :} +; + +expNewMapItems ::= + /* Empty */ + {: + RESULT = new astMap(); + :} +| expression:el COLON expression:er + {: + astMap am = new astMap(); + am.setParserInfo(this.parser.fileName, elleft, elright); + am.add(el, er); + RESULT = am; + :} +| expNewMapItems:am COMMA expression:el COLON expression:er + {: + am.add(el, er); + RESULT = am; + :} +; + +expThrow ::= + THROW:t expression:e + {: + astThrow at = new astThrow(); + at.setParserInfo(this.parser.fileName, tleft, tright); + at.setExpression(e); + RESULT = at; + :} +; diff --git a/cali.lang.base/src/com/cali/parser.java b/cali.lang.base/src/com/cali/parser.java new file mode 100644 index 0000000..2e946a3 --- /dev/null +++ b/cali.lang.base/src/com/cali/parser.java @@ -0,0 +1,4860 @@ + +//---------------------------------------------------- +// The following code was generated by CUP v0.11b 20140703 (SVN rev 36) +// Wed Mar 29 21:03:29 PDT 2017 +//---------------------------------------------------- + +package com.cali; + +import java.math.BigDecimal; +import java.math.BigInteger; +import java.util.*; +import java.util.concurrent.ConcurrentHashMap; +import java.util.Map; +import java_cup.runtime.*; +import com.cali.Engine; +import com.cali.ast.*; +import com.cali.types.*; +import com.cali.stdlib.console; +import java_cup.runtime.XMLElement; + +/** CUP v0.11b 20140703 (SVN rev 36) generated parser. + * @version Wed Mar 29 21:03:29 PDT 2017 + */ +public class parser extends java_cup.runtime.lr_parser { + + /** Default constructor. */ + public parser() {super();} + + /** Constructor which sets the default scanner. */ + public parser(java_cup.runtime.Scanner s) {super(s);} + + /** Constructor which sets the default scanner. */ + public parser(java_cup.runtime.Scanner s, java_cup.runtime.SymbolFactory sf) {super(s,sf);} + + /** Production table. */ + protected static final short _production_table[][] = + unpackFromStrings(new String[] { + "\000\276\000\002\002\003\000\002\002\004\000\002\003" + + "\003\000\002\003\004\000\002\003\005\000\002\003\006" + + "\000\002\003\003\000\002\004\003\000\002\004\005\000" + + "\002\005\006\000\002\005\010\000\002\005\011\000\002" + + "\005\007\000\002\015\003\000\002\015\005\000\002\006" + + "\002\000\002\006\003\000\002\007\003\000\002\007\005" + + "\000\002\011\004\000\002\011\005\000\002\012\003\000" + + "\002\012\004\000\002\012\003\000\002\012\004\000\002" + + "\016\005\000\002\016\007\000\002\016\007\000\002\016" + + "\007\000\002\016\007\000\002\016\007\000\002\016\007" + + "\000\002\016\007\000\002\013\003\000\002\013\004\000" + + "\002\014\004\000\002\014\006\000\002\017\012\000\002" + + "\017\011\000\002\017\011\000\002\020\002\000\002\020" + + "\003\000\002\020\005\000\002\020\004\000\002\020\006" + + "\000\002\021\003\000\002\021\005\000\002\021\005\000" + + "\002\021\005\000\002\021\005\000\002\021\005\000\002" + + "\021\005\000\002\021\005\000\002\021\003\000\002\022" + + "\003\000\002\024\003\000\002\024\004\000\002\025\004" + + "\000\002\025\003\000\002\025\003\000\002\025\003\000" + + "\002\025\003\000\002\025\003\000\002\025\003\000\002" + + "\025\003\000\002\030\005\000\002\031\003\000\002\031" + + "\007\000\002\031\003\000\002\031\003\000\002\031\003" + + "\000\002\031\005\000\002\031\004\000\002\031\006\000" + + "\002\031\005\000\002\031\005\000\002\031\004\000\002" + + "\031\003\000\002\031\003\000\002\031\003\000\002\031" + + "\003\000\002\031\003\000\002\031\003\000\002\031\003" + + "\000\002\031\003\000\002\031\005\000\002\033\005\000" + + "\002\033\006\000\002\033\005\000\002\032\005\000\002" + + "\032\005\000\002\032\005\000\002\032\005\000\002\032" + + "\005\000\002\032\005\000\002\032\005\000\002\032\005" + + "\000\002\032\005\000\002\032\005\000\002\032\005\000" + + "\002\032\004\000\002\032\004\000\002\032\005\000\002" + + "\032\005\000\002\032\005\000\002\032\005\000\002\032" + + "\005\000\002\032\005\000\002\032\004\000\002\032\005" + + "\000\002\032\005\000\002\026\004\000\002\026\005\000" + + "\002\027\011\000\002\023\004\000\002\023\005\000\002" + + "\051\003\000\002\051\004\000\002\051\004\000\002\051" + + "\005\000\002\052\010\000\002\052\011\000\002\053\003" + + "\000\002\053\004\000\002\054\011\000\002\054\012\000" + + "\002\055\005\000\002\055\006\000\002\056\011\000\002" + + "\056\010\000\002\057\003\000\002\057\004\000\002\060" + + "\003\000\002\060\004\000\002\061\010\000\002\061\007" + + "\000\002\062\007\000\002\062\006\000\002\063\011\000" + + "\002\063\010\000\002\065\015\000\002\065\014\000\002" + + "\065\013\000\002\065\012\000\002\066\002\000\002\066" + + "\003\000\002\034\002\000\002\034\003\000\002\034\005" + + "\000\002\010\002\000\002\010\003\000\002\010\003\000" + + "\002\010\003\000\002\035\003\000\002\036\003\000\002" + + "\037\003\000\002\037\004\000\002\040\003\000\002\040" + + "\004\000\002\041\003\000\002\042\005\000\002\042\004" + + "\000\002\043\003\000\002\043\005\000\002\044\003\000" + + "\002\044\003\000\002\044\003\000\002\044\003\000\002" + + "\044\003\000\002\044\003\000\002\045\005\000\002\045" + + "\004\000\002\046\005\000\002\046\005\000\002\046\007" + + "\000\002\046\007\000\002\047\003\000\002\050\003\000" + + "\002\064\003\000\002\067\003\000\002\070\004\000\002" + + "\071\005\000\002\072\002\000\002\072\003\000\002\072" + + "\005\000\002\073\005\000\002\074\002\000\002\074\005" + + "\000\002\074\007\000\002\075\004" }); + + /** Access to production table. */ + public short[][] production_table() {return _production_table;} + + /** Parse-action table. */ + protected static final short[][] _action_table = + unpackFromStrings(new String[] { + "\000\u016f\000\016\003\007\004\ufff2\005\005\006\012\012" + + "\010\013\ufff2\001\002\000\006\004\043\013\044\001\002" + + "\000\004\050\027\001\002\000\004\002\026\001\002\000" + + "\016\002\ufffb\004\ufffb\005\ufffb\006\ufffb\012\ufffb\013\ufffb" + + "\001\002\000\006\004\ufff1\013\ufff1\001\002\000\016\002" + + "\uffff\004\uffff\005\uffff\006\uffff\012\uffff\013\uffff\001\002" + + "\000\004\050\017\001\002\000\016\002\001\004\ufff2\005" + + "\005\006\015\012\010\013\ufff2\001\002\000\016\002\ufffe" + + "\004\ufffe\005\ufffe\006\ufffe\012\ufffe\013\ufffe\001\002\000" + + "\004\050\017\001\002\000\006\033\021\104\022\001\002" + + "\000\104\032\uff51\033\uff51\034\uff51\035\uff51\036\uff51\037" + + "\uff51\040\uff51\041\uff51\042\uff51\043\uff51\051\uff51\052\uff51" + + "\053\uff51\054\uff51\055\uff51\056\uff51\057\uff51\060\uff51\061" + + "\uff51\062\uff51\063\uff51\064\uff51\065\uff51\067\uff51\070\uff51" + + "\071\uff51\072\uff51\073\uff51\074\uff51\076\uff51\077\uff51\103" + + "\uff51\104\uff51\001\002\000\006\033\ufffa\104\ufffa\001\002" + + "\000\016\002\ufffc\004\ufffc\005\ufffc\006\ufffc\012\ufffc\013" + + "\ufffc\001\002\000\004\050\017\001\002\000\006\033\ufff9" + + "\104\ufff9\001\002\000\006\033\025\104\022\001\002\000" + + "\016\002\ufffd\004\ufffd\005\ufffd\006\ufffd\012\ufffd\013\ufffd" + + "\001\002\000\004\002\000\001\002\000\004\040\030\001" + + "\002\000\004\050\017\001\002\000\006\041\041\050\017" + + "\001\002\000\006\041\uffe0\050\uffe0\001\002\000\006\033" + + "\035\051\034\001\002\000\004\047\036\001\002\000\006" + + "\041\uffde\050\uffde\001\002\000\100\032\uff62\033\uff62\034" + + "\uff62\035\uff62\037\uff62\041\uff62\042\uff62\043\uff62\051\uff62" + + "\052\uff62\053\uff62\054\uff62\055\uff62\056\uff62\057\uff62\060" + + "\uff62\061\uff62\062\uff62\063\uff62\064\uff62\065\uff62\067\uff62" + + "\070\uff62\071\uff62\072\uff62\073\uff62\074\uff62\076\uff62\077" + + "\uff62\103\uff62\104\uff62\001\002\000\004\033\040\001\002" + + "\000\006\041\uffdd\050\uffdd\001\002\000\016\002\ufff5\004" + + "\ufff5\005\ufff5\006\ufff5\012\ufff5\013\ufff5\001\002\000\006" + + "\041\uffdf\050\uffdf\001\002\000\004\050\u016a\001\002\000" + + "\004\004\045\001\002\000\004\050\046\001\002\000\004" + + "\034\047\001\002\000\004\050\017\001\002\000\006\040" + + "\053\104\054\001\002\000\006\040\ufff0\104\ufff0\001\002" + + "\000\016\002\ufff6\004\ufff6\005\ufff6\006\ufff6\012\ufff6\013" + + "\ufff6\001\002\000\016\007\063\010\060\011\064\013\uff6c" + + "\041\061\050\uff6c\001\002\000\004\050\017\001\002\000" + + "\006\040\uffef\104\uffef\001\002\000\016\007\uffec\010\uffec" + + "\011\uffec\013\uffec\041\uffec\050\uffec\001\002\000\016\007" + + "\063\010\060\011\064\013\uff6c\041\u0169\050\uff6c\001\002" + + "\000\006\013\uff6a\050\uff6a\001\002\000\016\002\uffee\004" + + "\uffee\005\uffee\006\uffee\012\uffee\013\uffee\001\002\000\016" + + "\007\uffea\010\uffea\011\uffea\013\uffea\041\uffea\050\uffea\001" + + "\002\000\006\013\uff6b\050\uff6b\001\002\000\006\013\uff69" + + "\050\uff69\001\002\000\006\013\066\050\067\001\002\000" + + "\004\050\u0161\001\002\000\010\033\uff51\036\uff50\051\uff51" + + "\001\002\000\006\033\u0152\051\u0151\001\002\000\004\036" + + "\072\001\002\000\012\035\uffd9\037\uffd9\050\075\101\076" + + "\001\002\000\006\035\160\037\161\001\002\000\006\035" + + "\uffcc\037\uffcc\001\002\000\014\035\uff51\037\uff51\050\uffcb" + + "\051\uff51\101\uffcb\001\002\000\006\035\uff4e\037\uff4e\001" + + "\002\000\006\050\017\101\076\001\002\000\010\035\uffd4" + + "\037\uffd4\051\102\001\002\000\006\035\uffd8\037\uffd8\001" + + "\002\000\022\021\107\040\117\042\105\044\106\045\104" + + "\046\113\047\036\062\103\001\002\000\006\045\156\046" + + "\155\001\002\000\100\032\uff66\033\uff66\034\uff66\035\uff66" + + "\037\uff66\041\uff66\042\uff66\043\uff66\051\uff66\052\uff66\053" + + "\uff66\054\uff66\055\uff66\056\uff66\057\uff66\060\uff66\061\uff66" + + "\062\uff66\063\uff66\064\uff66\065\uff66\067\uff66\070\uff66\071" + + "\uff66\072\uff66\073\uff66\074\uff66\076\uff66\077\uff66\103\uff66" + + "\104\uff66\001\002\000\022\040\117\042\105\043\151\044" + + "\106\045\104\046\113\047\036\062\103\001\002\000\100" + + "\032\uff67\033\uff67\034\uff67\035\uff67\037\uff67\041\uff67\042" + + "\uff67\043\uff67\051\uff67\052\uff67\053\uff67\054\uff67\055\uff67" + + "\056\uff67\057\uff67\060\uff67\061\uff67\062\uff67\063\uff67\064" + + "\uff67\065\uff67\067\uff67\070\uff67\071\uff67\072\uff67\073\uff67" + + "\074\uff67\076\uff67\077\uff67\103\uff67\104\uff67\001\002\000" + + "\100\032\uff68\033\uff68\034\uff68\035\uff68\037\uff68\041\uff68" + + "\042\uff68\043\uff68\051\uff68\052\uff68\053\uff68\054\uff68\055" + + "\uff68\056\uff68\057\uff68\060\uff68\061\uff68\062\uff68\063\uff68" + + "\064\uff68\065\uff68\067\uff68\070\uff68\071\uff68\072\uff68\073" + + "\uff68\074\uff68\076\uff68\077\uff68\103\uff68\104\uff68\001\002" + + "\000\006\035\uffcd\037\uffcd\001\002\000\006\035\uffd2\037" + + "\uffd2\001\002\000\006\035\uffcf\037\uffcf\001\002\000\100" + + "\032\uff64\033\uff64\034\uff64\035\uff64\037\uff64\041\uff64\042" + + "\uff64\043\uff64\051\uff64\052\uff64\053\uff64\054\uff64\055\uff64" + + "\056\uff64\057\uff64\060\uff64\061\uff64\062\uff64\063\uff64\064" + + "\uff64\065\uff64\067\uff64\070\uff64\071\uff64\072\uff64\073\uff64" + + "\074\uff64\076\uff64\077\uff64\103\uff64\104\uff64\001\002\000" + + "\006\035\uffd3\037\uffd3\001\002\000\006\035\uffd0\037\uffd0" + + "\001\002\000\006\035\uffce\037\uffce\001\002\000\010\041" + + "\121\047\036\050\017\001\002\000\006\035\uffd1\037\uffd1" + + "\001\002\000\014\033\uff56\035\uff56\037\uff56\041\uff56\043" + + "\uff56\001\002\000\004\034\145\001\002\000\006\035\135" + + "\041\136\001\002\000\004\034\125\001\002\000\020\040" + + "\117\042\105\044\106\045\104\046\113\047\036\062\103" + + "\001\002\000\010\035\uff58\041\uff58\043\uff58\001\002\000" + + "\010\035\uff5d\041\uff5d\043\uff5d\001\002\000\010\035\uff5a" + + "\041\uff5a\043\uff5a\001\002\000\006\035\uff54\041\uff54\001" + + "\002\000\010\035\uff59\041\uff59\043\uff59\001\002\000\010" + + "\035\uff5b\041\uff5b\043\uff5b\001\002\000\010\035\uff5c\041" + + "\uff5c\043\uff5c\001\002\000\006\047\036\050\017\001\002" + + "\000\014\033\uff57\035\uff57\037\uff57\041\uff57\043\uff57\001" + + "\002\000\004\034\143\001\002\000\004\034\141\001\002" + + "\000\020\040\117\042\105\044\106\045\104\046\113\047" + + "\036\062\103\001\002\000\006\035\uff52\041\uff52\001\002" + + "\000\020\040\117\042\105\044\106\045\104\046\113\047" + + "\036\062\103\001\002\000\006\035\uff53\041\uff53\001\002" + + "\000\020\040\117\042\105\044\106\045\104\046\113\047" + + "\036\062\103\001\002\000\006\035\uff55\041\uff55\001\002" + + "\000\006\035\152\043\153\001\002\000\006\035\uff5f\043" + + "\uff5f\001\002\000\014\033\uff60\035\uff60\037\uff60\041\uff60" + + "\043\uff60\001\002\000\020\040\117\042\105\044\106\045" + + "\104\046\113\047\036\062\103\001\002\000\014\033\uff61" + + "\035\uff61\037\uff61\041\uff61\043\uff61\001\002\000\006\035" + + "\uff5e\043\uff5e\001\002\000\100\032\uff63\033\uff63\034\uff63" + + "\035\uff63\037\uff63\041\uff63\042\uff63\043\uff63\051\uff63\052" + + "\uff63\053\uff63\054\uff63\055\uff63\056\uff63\057\uff63\060\uff63" + + "\061\uff63\062\uff63\063\uff63\064\uff63\065\uff63\067\uff63\070" + + "\uff63\071\uff63\072\uff63\073\uff63\074\uff63\076\uff63\077\uff63" + + "\103\uff63\104\uff63\001\002\000\100\032\uff65\033\uff65\034" + + "\uff65\035\uff65\037\uff65\041\uff65\042\uff65\043\uff65\051\uff65" + + "\052\uff65\053\uff65\054\uff65\055\uff65\056\uff65\057\uff65\060" + + "\uff65\061\uff65\062\uff65\063\uff65\064\uff65\065\uff65\067\uff65" + + "\070\uff65\071\uff65\072\uff65\073\uff65\074\uff65\076\uff65\077" + + "\uff65\103\uff65\104\uff65\001\002\000\006\035\uffd6\037\uffd6" + + "\001\002\000\006\050\075\101\076\001\002\000\004\040" + + "\162\001\002\000\062\006\207\014\204\015\210\017\173" + + "\020\206\021\107\022\176\024\214\027\222\030\211\031" + + "\170\036\166\040\164\041\205\042\217\044\106\045\104" + + "\046\113\047\036\050\017\062\103\075\172\100\230\102" + + "\221\001\002\000\100\032\uffad\033\uffad\034\uffad\035\uffad" + + "\037\uffad\041\uffad\042\uffad\043\uffad\051\uffad\052\uffad\053" + + "\uffad\054\uffad\055\uffad\056\uffad\057\uffad\060\uffad\061\uffad" + + "\062\uffad\063\uffad\064\uffad\065\uffad\067\uffad\070\uffad\071" + + "\uffad\072\uffad\073\uffad\074\uffad\076\uffad\077\uffad\103\uffad" + + "\104\uffad\001\002\000\046\017\173\020\206\021\107\030" + + "\211\035\uff47\036\166\040\164\041\uff47\042\217\044\106" + + "\045\104\046\113\047\036\050\017\062\103\075\172\100" + + "\230\102\221\001\002\000\064\006\uff8d\014\uff8d\015\uff8d" + + "\017\uff8d\020\uff8d\021\uff8d\022\uff8d\023\u0134\024\uff8d\027" + + "\uff8d\030\uff8d\031\uff8d\036\uff8d\040\uff8d\041\uff8d\042\uff8d" + + "\044\uff8d\045\uff8d\046\uff8d\047\uff8d\050\uff8d\062\uff8d\075" + + "\uff8d\100\uff8d\102\uff8d\001\002\000\042\017\173\020\206" + + "\021\107\030\211\036\166\040\164\042\217\044\106\045" + + "\104\046\113\047\036\050\017\062\103\075\172\100\230" + + "\102\221\001\002\000\062\006\uffc5\014\uffc5\015\uffc5\017" + + "\uffc5\020\uffc5\021\uffc5\022\uffc5\024\uffc5\027\uffc5\030\uffc5" + + "\031\uffc5\036\uffc5\040\uffc5\041\uffc5\042\uffc5\044\uffc5\045" + + "\uffc5\046\uffc5\047\uffc5\050\uffc5\062\uffc5\075\uffc5\100\uffc5" + + "\102\uffc5\001\002\000\004\036\u011d\001\002\000\100\032" + + "\uffae\033\uffae\034\uffae\035\uffae\037\uffae\041\uffae\042\uffae" + + "\043\uffae\051\uffae\052\uffae\053\uffae\054\uffae\055\uffae\056" + + "\uffae\057\uffae\060\uffae\061\uffae\062\uffae\063\uffae\064\uffae" + + "\065\uffae\067\uffae\070\uffae\071\uffae\072\uffae\073\uffae\074" + + "\uffae\076\uffae\077\uffae\103\uffae\104\uffae\001\002\000\042" + + "\017\173\020\206\021\107\030\211\036\166\040\164\042" + + "\217\044\106\045\104\046\113\047\036\050\017\062\103" + + "\075\172\100\230\102\221\001\002\000\042\017\173\020" + + "\206\021\107\030\211\036\166\040\164\042\217\044\106" + + "\045\104\046\113\047\036\050\017\062\103\075\172\100" + + "\230\102\221\001\002\000\100\032\uffbc\033\uffbc\034\uffbc" + + "\035\uffbc\037\uffbc\041\uffbc\042\uffbc\043\uffbc\051\uffbc\052" + + "\uffbc\053\uffbc\054\uffbc\055\uffbc\056\uffbc\057\uffbc\060\uffbc" + + "\061\uffbc\062\uffbc\063\uffbc\064\uffbc\065\uffbc\067\uffbc\070" + + "\uffbc\071\uffbc\072\uffbc\073\uffbc\074\uffbc\076\uffbc\077\uffbc" + + "\103\uffbc\104\uffbc\001\002\000\100\032\uffb2\033\uffb2\034" + + "\uffb2\035\uffb2\037\uffb2\041\uffb2\042\uffb2\043\uffb2\051\uffb2" + + "\052\uffb2\053\uffb2\054\uffb2\055\uffb2\056\uffb2\057\uffb2\060" + + "\uffb2\061\uffb2\062\uffb2\063\uffb2\064\uffb2\065\uffb2\067\uffb2" + + "\070\uffb2\071\uffb2\072\uffb2\073\uffb2\074\uffb2\076\uffb2\077" + + "\uffb2\103\uffb2\104\uffb2\001\002\000\004\036\u0114\001\002" + + "\000\062\006\uffca\014\uffca\015\uffca\017\uffca\020\uffca\021" + + "\uffca\022\uffca\024\uffca\027\uffca\030\uffca\031\uffca\036\uffca" + + "\040\uffca\041\uffca\042\uffca\044\uffca\045\uffca\046\uffca\047" + + "\uffca\050\uffca\062\uffca\075\uffca\100\uffca\102\uffca\001\002" + + "\000\062\006\uffc4\014\uffc4\015\uffc4\017\uffc4\020\uffc4\021" + + "\uffc4\022\uffc4\024\uffc4\027\uffc4\030\uffc4\031\uffc4\036\uffc4" + + "\040\uffc4\041\uffc4\042\uffc4\044\uffc4\045\uffc4\046\uffc4\047" + + "\uffc4\050\uffc4\062\uffc4\075\uffc4\100\uffc4\102\uffc4\001\002" + + "\000\100\032\uffaf\033\uffaf\034\uffaf\035\uffaf\037\uffaf\041" + + "\uffaf\042\uffaf\043\uffaf\051\uffaf\052\uffaf\053\uffaf\054\uffaf" + + "\055\uffaf\056\uffaf\057\uffaf\060\uffaf\061\uffaf\062\uffaf\063" + + "\uffaf\064\uffaf\065\uffaf\067\uffaf\070\uffaf\071\uffaf\072\uffaf" + + "\073\uffaf\074\uffaf\076\uffaf\077\uffaf\103\uffaf\104\uffaf\001" + + "\002\000\102\032\uffb4\033\uffb4\034\uffb4\035\uffb4\036\u0111" + + "\037\uffb4\041\uffb4\042\uffb4\043\uffb4\051\uffb4\052\uffb4\053" + + "\uffb4\054\uffb4\055\uffb4\056\uffb4\057\uffb4\060\uffb4\061\uffb4" + + "\062\uffb4\063\uffb4\064\uffb4\065\uffb4\067\uffb4\070\uffb4\071" + + "\uffb4\072\uffb4\073\uffb4\074\uffb4\076\uffb4\077\uffb4\103\uffb4" + + "\104\uffb4\001\002\000\066\032\264\033\u0110\042\244\051" + + "\261\052\260\053\255\054\241\055\242\056\237\057\252" + + "\060\247\061\254\062\256\063\246\064\253\065\265\067" + + "\263\070\236\071\235\072\245\073\250\074\262\076\234" + + "\077\240\103\251\104\257\001\002\000\044\017\173\020" + + "\206\021\107\030\211\033\u010d\036\166\040\164\042\217" + + "\044\106\045\104\046\113\047\036\050\017\062\103\075" + + "\172\100\230\102\221\001\002\000\016\007\uffdb\010\uffdb" + + "\011\uffdb\013\uffdb\041\uffdb\050\uffdb\001\002\000\004\050" + + "\017\001\002\000\004\050\017\001\002\000\004\040\373" + + "\001\002\000\100\032\uff4f\033\uff4f\034\uff4f\035\uff4f\037" + + "\uff4f\041\uff4f\042\uff4f\043\uff4f\051\uff4f\052\uff4f\053\uff4f" + + "\054\uff4f\055\uff4f\056\uff4f\057\uff4f\060\uff4f\061\uff4f\062" + + "\uff4f\063\uff4f\064\uff4f\065\uff4f\067\uff4f\070\uff4f\071\uff4f" + + "\072\uff4f\073\uff4f\074\uff4f\076\uff4f\077\uff4f\103\uff4f\104" + + "\uff4f\001\002\000\100\032\uffb3\033\uffb3\034\uffb3\035\uffb3" + + "\037\uffb3\041\uffb3\042\uffb3\043\uffb3\051\uffb3\052\uffb3\053" + + "\uffb3\054\uffb3\055\uffb3\056\uffb3\057\uffb3\060\uffb3\061\uffb3" + + "\062\uffb3\063\uffb3\064\uffb3\065\uffb3\067\uffb3\070\uffb3\071" + + "\uffb3\072\uffb3\073\uffb3\074\uffb3\076\uffb3\077\uffb3\103\uffb3" + + "\104\uffb3\001\002\000\062\006\207\014\204\015\210\017" + + "\173\020\206\021\107\022\176\024\214\027\222\030\211" + + "\031\170\036\166\040\164\041\371\042\217\044\106\045" + + "\104\046\113\047\036\050\017\062\103\075\172\100\230" + + "\102\221\001\002\000\004\036\341\001\002\000\062\006" + + "\uffc6\014\uffc6\015\uffc6\017\uffc6\020\uffc6\021\uffc6\022\uffc6" + + "\024\uffc6\027\uffc6\030\uffc6\031\uffc6\036\uffc6\040\uffc6\041" + + "\uffc6\042\uffc6\044\uffc6\045\uffc6\046\uffc6\047\uffc6\050\uffc6" + + "\062\uffc6\075\uffc6\100\uffc6\102\uffc6\001\002\000\100\032" + + "\uffb1\033\uffb1\034\uffb1\035\uffb1\037\uffb1\041\uffb1\042\uffb1" + + "\043\uffb1\051\uffb1\052\uffb1\053\uffb1\054\uffb1\055\uffb1\056" + + "\uffb1\057\uffb1\060\uffb1\061\uffb1\062\uffb1\063\uffb1\064\uffb1" + + "\065\uffb1\067\uffb1\070\uffb1\071\uffb1\072\uffb1\073\uffb1\074" + + "\uffb1\076\uffb1\077\uffb1\103\uffb1\104\uffb1\001\002\000\046" + + "\017\173\020\206\021\107\030\211\035\uff4b\036\166\040" + + "\164\042\217\043\uff4b\044\106\045\104\046\113\047\036" + + "\050\017\062\103\075\172\100\230\102\221\001\002\000" + + "\062\006\uffc3\014\uffc3\015\uffc3\017\uffc3\020\uffc3\021\uffc3" + + "\022\uffc3\024\uffc3\027\uffc3\030\uffc3\031\uffc3\036\uffc3\040" + + "\uffc3\041\uffc3\042\uffc3\044\uffc3\045\uffc3\046\uffc3\047\uffc3" + + "\050\uffc3\062\uffc3\075\uffc3\100\uffc3\102\uffc3\001\002\000" + + "\004\050\333\001\002\000\004\036\323\001\002\000\100" + + "\032\uffb0\033\uffb0\034\uffb0\035\uffb0\037\uffb0\041\uffb0\042" + + "\uffb0\043\uffb0\051\uffb0\052\uffb0\053\uffb0\054\uffb0\055\uffb0" + + "\056\uffb0\057\uffb0\060\uffb0\061\uffb0\062\uffb0\063\uffb0\064" + + "\uffb0\065\uffb0\067\uffb0\070\uffb0\071\uffb0\072\uffb0\073\uffb0" + + "\074\uffb0\076\uffb0\077\uffb0\103\uffb0\104\uffb0\001\002\000" + + "\062\006\uffc2\014\uffc2\015\uffc2\017\uffc2\020\uffc2\021\uffc2" + + "\022\uffc2\024\uffc2\027\uffc2\030\uffc2\031\uffc2\036\uffc2\040" + + "\uffc2\041\uffc2\042\uffc2\044\uffc2\045\uffc2\046\uffc2\047\uffc2" + + "\050\uffc2\062\uffc2\075\uffc2\100\uffc2\102\uffc2\001\002\000" + + "\062\006\uffc7\014\uffc7\015\uffc7\017\uffc7\020\uffc7\021\uffc7" + + "\022\uffc7\024\uffc7\027\uffc7\030\uffc7\031\uffc7\036\uffc7\040" + + "\uffc7\041\uffc7\042\uffc7\044\uffc7\045\uffc7\046\uffc7\047\uffc7" + + "\050\uffc7\062\uffc7\075\uffc7\100\uffc7\102\uffc7\001\002\000" + + "\062\006\uffc1\014\uffc1\015\uffc1\017\uffc1\020\uffc1\021\uffc1" + + "\022\uffc1\024\uffc1\027\uffc1\030\uffc1\031\uffc1\036\uffc1\040" + + "\uffc1\041\uffc1\042\uffc1\044\uffc1\045\uffc1\046\uffc1\047\uffc1" + + "\050\uffc1\062\uffc1\075\uffc1\100\uffc1\102\uffc1\001\002\000" + + "\100\032\uffbd\033\uffbd\034\uffbd\035\uffbd\037\uffbd\041\uffbd" + + "\042\uffbd\043\uffbd\051\uffbd\052\uffbd\053\uffbd\054\uffbd\055" + + "\uffbd\056\uffbd\057\uffbd\060\uffbd\061\uffbd\062\uffbd\063\uffbd" + + "\064\uffbd\065\uffbd\067\uffbd\070\uffbd\071\uffbd\072\uffbd\073" + + "\uffbd\074\uffbd\076\uffbd\077\uffbd\103\uffbd\104\uffbd\001\002" + + "\000\042\017\173\020\206\021\107\030\211\036\166\040" + + "\164\042\217\044\106\045\104\046\113\047\036\050\017" + + "\062\103\075\172\100\230\102\221\001\002\000\100\032" + + "\uffbf\033\uffbf\034\uffbf\035\uffbf\037\uffbf\041\uffbf\042\uffbf" + + "\043\uffbf\051\uffbf\052\uffbf\053\uffbf\054\uffbf\055\uffbf\056" + + "\uffbf\057\uffbf\060\uffbf\061\uffbf\062\uffbf\063\uffbf\064\uffbf" + + "\065\uffbf\067\uffbf\070\uffbf\071\uffbf\072\uffbf\073\uffbf\074" + + "\uffbf\076\uffbf\077\uffbf\103\uffbf\104\uffbf\001\002\000\100" + + "\032\uffbb\033\uffbb\034\uffbb\035\uffbb\037\uffbb\041\uffbb\042" + + "\uffbb\043\uffbb\051\uffbb\052\uffbb\053\uffbb\054\uffbb\055\uffbb" + + "\056\uffbb\057\uffbb\060\uffbb\061\uffbb\062\uffbb\063\uffbb\064" + + "\uffbb\065\uffbb\067\uffbb\070\uffbb\071\uffbb\072\uffbb\073\uffbb" + + "\074\uffbb\076\uffbb\077\uffbb\103\uffbb\104\uffbb\001\002\000" + + "\100\032\264\033\uffb9\034\uffb9\035\uffb9\037\uffb9\041\uffb9" + + "\042\244\043\uffb9\051\uffb9\052\uffb9\053\uffb9\054\uffb9\055" + + "\uffb9\056\uffb9\057\uffb9\060\uffb9\061\uffb9\062\uffb9\063\uffb9" + + "\064\uffb9\065\uffb9\067\uffb9\070\uffb9\071\uffb9\072\uffb9\073" + + "\uffb9\074\uffb9\076\uffb9\077\uffb9\103\uffb9\104\257\001\002" + + "\000\042\017\173\020\206\021\107\030\211\036\166\040" + + "\164\042\217\044\106\045\104\046\113\047\036\050\017" + + "\062\103\075\172\100\230\102\221\001\002\000\042\017" + + "\173\020\206\021\107\030\211\036\166\040\164\042\217" + + "\044\106\045\104\046\113\047\036\050\017\062\103\075" + + "\172\100\230\102\221\001\002\000\042\017\173\020\206" + + "\021\107\030\211\036\166\040\164\042\217\044\106\045" + + "\104\046\113\047\036\050\017\062\103\075\172\100\230" + + "\102\221\001\002\000\042\017\173\020\206\021\107\030" + + "\211\036\166\040\164\042\217\044\106\045\104\046\113" + + "\047\036\050\017\062\103\075\172\100\230\102\221\001" + + "\002\000\042\017\173\020\206\021\107\030\211\036\166" + + "\040\164\042\217\044\106\045\104\046\113\047\036\050" + + "\017\062\103\075\172\100\230\102\221\001\002\000\042" + + "\017\173\020\206\021\107\030\211\036\166\040\164\042" + + "\217\044\106\045\104\046\113\047\036\050\017\062\103" + + "\075\172\100\230\102\221\001\002\000\042\017\173\020" + + "\206\021\107\030\211\036\166\040\164\042\217\044\106" + + "\045\104\046\113\047\036\050\017\062\103\075\172\100" + + "\230\102\221\001\002\000\100\032\uffb5\033\uffb5\034\uffb5" + + "\035\uffb5\037\uffb5\041\uffb5\042\307\043\uffb5\051\uffb5\052" + + "\uffb5\053\uffb5\054\uffb5\055\uffb5\056\uffb5\057\uffb5\060\uffb5" + + "\061\uffb5\062\uffb5\063\uffb5\064\uffb5\065\uffb5\067\uffb5\070" + + "\uffb5\071\uffb5\072\uffb5\073\uffb5\074\uffb5\076\uffb5\077\uffb5" + + "\103\uffb5\104\310\001\002\000\042\017\173\020\206\021" + + "\107\030\211\036\166\040\164\042\217\044\106\045\104" + + "\046\113\047\036\050\017\062\103\075\172\100\230\102" + + "\221\001\002\000\042\017\173\020\206\021\107\030\211" + + "\036\166\040\164\042\217\044\106\045\104\046\113\047" + + "\036\050\017\062\103\075\172\100\230\102\221\001\002" + + "\000\042\017\173\020\206\021\107\030\211\036\166\040" + + "\164\042\217\044\106\045\104\046\113\047\036\050\017" + + "\062\103\075\172\100\230\102\221\001\002\000\100\032" + + "\uff9c\033\uff9c\034\uff9c\035\uff9c\037\uff9c\041\uff9c\042\uff9c" + + "\043\uff9c\051\uff9c\052\uff9c\053\uff9c\054\uff9c\055\uff9c\056" + + "\uff9c\057\uff9c\060\uff9c\061\uff9c\062\uff9c\063\uff9c\064\uff9c" + + "\065\uff9c\067\uff9c\070\uff9c\071\uff9c\072\uff9c\073\uff9c\074" + + "\uff9c\076\uff9c\077\uff9c\103\uff9c\104\uff9c\001\002\000\042" + + "\017\173\020\206\021\107\030\211\036\166\040\164\042" + + "\217\044\106\045\104\046\113\047\036\050\017\062\103" + + "\075\172\100\230\102\221\001\002\000\042\017\173\020" + + "\206\021\107\030\211\036\166\040\164\042\217\044\106" + + "\045\104\046\113\047\036\050\017\062\103\075\172\100" + + "\230\102\221\001\002\000\100\032\uff9d\033\uff9d\034\uff9d" + + "\035\uff9d\037\uff9d\041\uff9d\042\uff9d\043\uff9d\051\uff9d\052" + + "\uff9d\053\uff9d\054\uff9d\055\uff9d\056\uff9d\057\uff9d\060\uff9d" + + "\061\uff9d\062\uff9d\063\uff9d\064\uff9d\065\uff9d\067\uff9d\070" + + "\uff9d\071\uff9d\072\uff9d\073\uff9d\074\uff9d\076\uff9d\077\uff9d" + + "\103\uff9d\104\uff9d\001\002\000\042\017\173\020\206\021" + + "\107\030\211\036\166\040\164\042\217\044\106\045\104" + + "\046\113\047\036\050\017\062\103\075\172\100\230\102" + + "\221\001\002\000\042\017\173\020\206\021\107\030\211" + + "\036\166\040\164\042\217\044\106\045\104\046\113\047" + + "\036\050\017\062\103\075\172\100\230\102\221\001\002" + + "\000\042\017\173\020\206\021\107\030\211\036\166\040" + + "\164\042\217\044\106\045\104\046\113\047\036\050\017" + + "\062\103\075\172\100\230\102\221\001\002\000\042\017" + + "\173\020\206\021\107\030\211\036\166\040\164\042\217" + + "\044\106\045\104\046\113\047\036\050\017\062\103\075" + + "\172\100\230\102\221\001\002\000\042\017\173\020\206" + + "\021\107\030\211\036\166\040\164\042\217\044\106\045" + + "\104\046\113\047\036\050\017\062\103\075\172\100\230" + + "\102\221\001\002\000\042\017\173\020\206\021\107\030" + + "\211\036\166\040\164\042\217\044\106\045\104\046\113" + + "\047\036\050\017\062\103\075\172\100\230\102\221\001" + + "\002\000\042\017\173\020\206\021\107\030\211\036\166" + + "\040\164\042\217\044\106\045\104\046\113\047\036\050" + + "\017\062\103\075\172\100\230\102\221\001\002\000\042" + + "\017\173\020\206\021\107\030\211\036\166\040\164\042" + + "\217\044\106\045\104\046\113\047\036\050\017\062\103" + + "\075\172\100\230\102\221\001\002\000\042\017\173\020" + + "\206\021\107\030\211\036\166\040\164\042\217\044\106" + + "\045\104\046\113\047\036\050\017\062\103\075\172\100" + + "\230\102\221\001\002\000\042\017\173\020\206\021\107" + + "\030\211\036\166\040\164\042\217\044\106\045\104\046" + + "\113\047\036\050\017\062\103\075\172\100\230\102\221" + + "\001\002\000\042\017\173\020\206\021\107\030\211\036" + + "\166\040\164\042\217\044\106\045\104\046\113\047\036" + + "\050\017\062\103\075\172\100\230\102\221\001\002\000" + + "\100\032\264\033\uffa4\034\uffa4\035\uffa4\037\uffa4\041\uffa4" + + "\042\244\043\uffa4\051\uffa4\052\uffa4\053\uffa4\054\uffa4\055" + + "\uffa4\056\uffa4\057\uffa4\060\uffa4\061\uffa4\062\uffa4\063\246" + + "\064\253\065\265\067\uffa4\070\uffa4\071\uffa4\072\uffa4\073" + + "\uffa4\074\uffa4\076\uffa4\077\uffa4\103\uffa4\104\257\001\002" + + "\000\100\032\264\033\uffb6\034\uffb6\035\uffb6\037\uffb6\041" + + "\uffb6\042\244\043\uffb6\051\uffb6\052\uffb6\053\uffb6\054\uffb6" + + "\055\uffb6\056\uffb6\057\uffb6\060\uffb6\061\uffb6\062\uffb6\063" + + "\uffb6\064\uffb6\065\uffb6\067\uffb6\070\uffb6\071\uffb6\072\uffb6" + + "\073\uffb6\074\uffb6\076\uffb6\077\uffb6\103\uffb6\104\257\001" + + "\002\000\100\032\264\033\uff9b\034\uff9b\035\uff9b\037\uff9b" + + "\041\uff9b\042\244\043\uff9b\051\uff9b\052\uff9b\053\uff9b\054" + + "\uff9b\055\uff9b\056\uff9b\057\uff9b\060\uff9b\061\254\062\256" + + "\063\246\064\253\065\265\067\263\070\236\071\235\072" + + "\245\073\250\074\262\076\uff9b\077\uff9b\103\uff9b\104\257" + + "\001\002\000\100\032\264\033\uff96\034\uff96\035\uff96\037" + + "\uff96\041\uff96\042\244\043\uff96\051\uff96\052\uff96\053\uff96" + + "\054\uff96\055\uff96\056\uff96\057\uff96\060\uff96\061\254\062" + + "\256\063\246\064\253\065\265\067\263\070\236\071\235" + + "\072\245\073\250\074\262\076\uff96\077\uff96\103\uff96\104" + + "\257\001\002\000\100\032\264\033\uffa3\034\uffa3\035\uffa3" + + "\037\uffa3\041\uffa3\042\244\043\uffa3\051\261\052\260\053" + + "\255\054\241\055\242\056\237\057\uffa3\060\uffa3\061\254" + + "\062\256\063\246\064\253\065\265\067\263\070\236\071" + + "\235\072\245\073\250\074\262\076\234\077\240\103\251" + + "\104\257\001\002\000\100\032\264\033\uffa2\034\uffa2\035" + + "\uffa2\037\uffa2\041\uffa2\042\244\043\uffa2\051\uffa2\052\260" + + "\053\255\054\241\055\242\056\237\057\uffa2\060\uffa2\061" + + "\254\062\256\063\246\064\253\065\265\067\263\070\236" + + "\071\235\072\245\073\250\074\262\076\234\077\240\103" + + "\251\104\257\001\002\000\100\032\uffb7\033\uffb7\034\uffb7" + + "\035\uffb7\037\uffb7\041\uffb7\042\244\043\uffb7\051\uffb7\052" + + "\uffb7\053\uffb7\054\uffb7\055\uffb7\056\uffb7\057\uffb7\060\uffb7" + + "\061\uffb7\062\uffb7\063\uffb7\064\uffb7\065\uffb7\067\uffb7\070" + + "\uffb7\071\uffb7\072\uffb7\073\uffb7\074\uffb7\076\uffb7\077\uffb7" + + "\103\uffb7\104\257\001\002\000\100\032\264\033\uffa7\034" + + "\uffa7\035\uffa7\037\uffa7\041\uffa7\042\244\043\uffa7\051\uffa7" + + "\052\uffa7\053\uffa7\054\uffa7\055\uffa7\056\uffa7\057\uffa7\060" + + "\uffa7\061\254\062\256\063\246\064\253\065\265\067\uffa7" + + "\070\uffa7\071\uffa7\072\uffa7\073\uffa7\074\uffa7\076\uffa7\077" + + "\uffa7\103\uffa7\104\257\001\002\000\100\032\264\033\uffa1" + + "\034\uffa1\035\uffa1\037\uffa1\041\uffa1\042\244\043\uffa1\051" + + "\uffa1\052\260\053\255\054\241\055\242\056\237\057\uffa1" + + "\060\uffa1\061\254\062\256\063\246\064\253\065\265\067" + + "\263\070\236\071\235\072\245\073\250\074\262\076\234" + + "\077\240\103\251\104\257\001\002\000\100\032\264\033" + + "\uffa8\034\uffa8\035\uffa8\037\uffa8\041\uffa8\042\244\043\uffa8" + + "\051\uffa8\052\uffa8\053\uffa8\054\uffa8\055\uffa8\056\uffa8\057" + + "\uffa8\060\uffa8\061\254\062\256\063\246\064\253\065\265" + + "\067\uffa8\070\uffa8\071\uffa8\072\uffa8\073\uffa8\074\uffa8\076" + + "\uffa8\077\uffa8\103\uffa8\104\257\001\002\000\100\032\264" + + "\033\uffa5\034\uffa5\035\uffa5\037\uffa5\041\uffa5\042\244\043" + + "\uffa5\051\uffa5\052\uffa5\053\uffa5\054\uffa5\055\uffa5\056\uffa5" + + "\057\uffa5\060\uffa5\061\uffa5\062\uffa5\063\246\064\253\065" + + "\265\067\uffa5\070\uffa5\071\uffa5\072\uffa5\073\uffa5\074\uffa5" + + "\076\uffa5\077\uffa5\103\uffa5\104\257\001\002\000\100\032" + + "\264\033\uffba\034\uffba\035\uffba\037\uffba\041\uffba\042\244" + + "\043\uffba\051\uffba\052\260\053\255\054\241\055\242\056" + + "\237\057\uffba\060\uffba\061\254\062\256\063\246\064\253" + + "\065\265\067\263\070\236\071\235\072\245\073\250\074" + + "\262\076\234\077\240\103\251\104\257\001\002\000\100" + + "\032\264\033\uff97\034\uff97\035\uff97\037\uff97\041\uff97\042" + + "\244\043\uff97\051\uff97\052\uff97\053\uff97\054\uff97\055\uff97" + + "\056\uff97\057\uff97\060\uff97\061\254\062\256\063\246\064" + + "\253\065\265\067\263\070\236\071\235\072\245\073\250" + + "\074\262\076\uff97\077\uff97\103\uff97\104\257\001\002\000" + + "\100\032\264\033\uffa6\034\uffa6\035\uffa6\037\uffa6\041\uffa6" + + "\042\244\043\uffa6\051\uffa6\052\uffa6\053\uffa6\054\uffa6\055" + + "\uffa6\056\uffa6\057\uffa6\060\uffa6\061\uffa6\062\uffa6\063\246" + + "\064\253\065\265\067\uffa6\070\uffa6\071\uffa6\072\uffa6\073" + + "\uffa6\074\uffa6\076\uffa6\077\uffa6\103\uffa6\104\257\001\002" + + "\000\100\032\264\033\uff98\034\uff98\035\uff98\037\uff98\041" + + "\uff98\042\244\043\uff98\051\uff98\052\uff98\053\uff98\054\uff98" + + "\055\uff98\056\uff98\057\uff98\060\uff98\061\254\062\256\063" + + "\246\064\253\065\265\067\263\070\236\071\235\072\245" + + "\073\250\074\262\076\uff98\077\uff98\103\uff98\104\257\001" + + "\002\000\066\032\264\042\244\043\306\051\261\052\260" + + "\053\255\054\241\055\242\056\237\057\252\060\247\061" + + "\254\062\256\063\246\064\253\065\265\067\263\070\236" + + "\071\235\072\245\073\250\074\262\076\234\077\240\103" + + "\251\104\257\001\002\000\100\032\uffab\033\uffab\034\uffab" + + "\035\uffab\037\uffab\041\uffab\042\uffab\043\uffab\051\uffab\052" + + "\uffab\053\uffab\054\uffab\055\uffab\056\uffab\057\uffab\060\uffab" + + "\061\uffab\062\uffab\063\uffab\064\uffab\065\uffab\067\uffab\070" + + "\uffab\071\uffab\072\uffab\073\uffab\074\uffab\076\uffab\077\uffab" + + "\103\uffab\104\uffab\001\002\000\042\017\173\020\206\021" + + "\107\030\211\036\166\040\164\042\217\044\106\045\104" + + "\046\113\047\036\050\017\062\103\075\172\100\230\102" + + "\221\001\002\000\042\017\173\020\206\021\107\030\211" + + "\036\166\040\164\042\217\044\106\045\104\046\113\047" + + "\036\050\017\062\103\075\172\100\230\102\221\001\002" + + "\000\100\032\uffa9\033\uffa9\034\uffa9\035\uffa9\037\uffa9\041" + + "\uffa9\042\244\043\uffa9\051\uffa9\052\uffa9\053\uffa9\054\uffa9" + + "\055\uffa9\056\uffa9\057\uffa9\060\uffa9\061\uffa9\062\uffa9\063" + + "\uffa9\064\uffa9\065\uffa9\067\uffa9\070\uffa9\071\uffa9\072\uffa9" + + "\073\uffa9\074\uffa9\076\uffa9\077\uffa9\103\uffa9\104\257\001" + + "\002\000\066\032\264\042\244\043\313\051\261\052\260" + + "\053\255\054\241\055\242\056\237\057\252\060\247\061" + + "\254\062\256\063\246\064\253\065\265\067\263\070\236" + + "\071\235\072\245\073\250\074\262\076\234\077\240\103" + + "\251\104\257\001\002\000\100\032\uffaa\033\uffaa\034\uffaa" + + "\035\uffaa\037\uffaa\041\uffaa\042\uffaa\043\uffaa\051\uffaa\052" + + "\uffaa\053\uffaa\054\uffaa\055\uffaa\056\uffaa\057\uffaa\060\uffaa" + + "\061\uffaa\062\uffaa\063\uffaa\064\uffaa\065\uffaa\067\uffaa\070" + + "\uffaa\071\uffaa\072\uffaa\073\uffaa\074\uffaa\076\uffaa\077\uffaa" + + "\103\uffaa\104\uffaa\001\002\000\100\032\264\033\uff9f\034" + + "\uff9f\035\uff9f\037\uff9f\041\uff9f\042\244\043\uff9f\051\uff9f" + + "\052\260\053\255\054\241\055\242\056\237\057\uff9f\060" + + "\uff9f\061\254\062\256\063\246\064\253\065\265\067\263" + + "\070\236\071\235\072\245\073\250\074\262\076\234\077" + + "\240\103\251\104\257\001\002\000\100\032\264\033\uffa0" + + "\034\uffa0\035\uffa0\037\uffa0\041\uffa0\042\244\043\uffa0\051" + + "\uffa0\052\260\053\255\054\241\055\242\056\237\057\uffa0" + + "\060\uffa0\061\254\062\256\063\246\064\253\065\265\067" + + "\263\070\236\071\235\072\245\073\250\074\262\076\234" + + "\077\240\103\251\104\257\001\002\000\100\032\264\033" + + "\uff93\034\uff93\035\uff93\037\uff93\041\uff93\042\244\043\uff93" + + "\051\uff93\052\uff93\053\uff93\054\uff93\055\uff93\056\uff93\057" + + "\uff93\060\uff93\061\254\062\256\063\246\064\253\065\265" + + "\067\263\070\236\071\235\072\245\073\250\074\262\076" + + "\234\077\240\103\uff93\104\257\001\002\000\100\032\264" + + "\033\uff9e\034\uff9e\035\uff9e\037\uff9e\041\uff9e\042\244\043" + + "\uff9e\051\uff9e\052\260\053\255\054\241\055\242\056\237" + + "\057\uff9e\060\uff9e\061\254\062\256\063\246\064\253\065" + + "\265\067\263\070\236\071\235\072\245\073\250\074\262" + + "\076\234\077\240\103\251\104\257\001\002\000\100\032" + + "\264\033\uff9a\034\uff9a\035\uff9a\037\uff9a\041\uff9a\042\244" + + "\043\uff9a\051\uff9a\052\uff9a\053\uff9a\054\uff9a\055\uff9a\056" + + "\uff9a\057\uff9a\060\uff9a\061\254\062\256\063\246\064\253" + + "\065\265\067\263\070\236\071\235\072\245\073\250\074" + + "\262\076\uff9a\077\uff9a\103\uff9a\104\257\001\002\000\100" + + "\032\264\033\uff99\034\uff99\035\uff99\037\uff99\041\uff99\042" + + "\244\043\uff99\051\uff99\052\uff99\053\uff99\054\uff99\055\uff99" + + "\056\uff99\057\uff99\060\uff99\061\254\062\256\063\246\064" + + "\253\065\265\067\263\070\236\071\235\072\245\073\250" + + "\074\262\076\uff99\077\uff99\103\uff99\104\257\001\002\000" + + "\100\032\264\033\uff94\034\uff94\035\uff94\037\uff94\041\uff94" + + "\042\244\043\uff94\051\uff94\052\uff94\053\uff94\054\uff94\055" + + "\uff94\056\uff94\057\uff94\060\uff94\061\254\062\256\063\246" + + "\064\253\065\265\067\263\070\236\071\235\072\245\073" + + "\250\074\262\076\234\077\240\103\uff94\104\257\001\002" + + "\000\042\017\173\020\206\021\107\030\211\036\166\040" + + "\164\042\217\044\106\045\104\046\113\047\036\050\017" + + "\062\103\075\172\100\230\102\221\001\002\000\066\032" + + "\264\037\325\042\244\051\261\052\260\053\255\054\241" + + "\055\242\056\237\057\252\060\247\061\254\062\256\063" + + "\246\064\253\065\265\067\263\070\236\071\235\072\245" + + "\073\250\074\262\076\234\077\240\103\251\104\257\001" + + "\002\000\004\040\326\001\002\000\062\006\207\014\204" + + "\015\210\017\173\020\206\021\107\022\176\024\214\027" + + "\222\030\211\031\170\036\166\040\164\041\327\042\217" + + "\044\106\045\104\046\113\047\036\050\017\062\103\075" + + "\172\100\230\102\221\001\002\000\062\006\uff76\014\uff76" + + "\015\uff76\017\uff76\020\uff76\021\uff76\022\uff76\024\uff76\027" + + "\uff76\030\uff76\031\uff76\036\uff76\040\uff76\041\uff76\042\uff76" + + "\044\uff76\045\uff76\046\uff76\047\uff76\050\uff76\062\uff76\075" + + "\uff76\100\uff76\102\uff76\001\002\000\062\006\207\014\204" + + "\015\210\017\173\020\206\021\107\022\176\024\214\027" + + "\222\030\211\031\170\036\166\040\164\041\332\042\217" + + "\044\106\045\104\046\113\047\036\050\017\062\103\075" + + "\172\100\230\102\221\001\002\000\062\006\uffc9\014\uffc9" + + "\015\uffc9\017\uffc9\020\uffc9\021\uffc9\022\uffc9\024\uffc9\027" + + "\uffc9\030\uffc9\031\uffc9\036\uffc9\040\uffc9\041\uffc9\042\uffc9" + + "\044\uffc9\045\uffc9\046\uffc9\047\uffc9\050\uffc9\062\uffc9\075" + + "\uffc9\100\uffc9\102\uffc9\001\002\000\062\006\uff77\014\uff77" + + "\015\uff77\017\uff77\020\uff77\021\uff77\022\uff77\024\uff77\027" + + "\uff77\030\uff77\031\uff77\036\uff77\040\uff77\041\uff77\042\uff77" + + "\044\uff77\045\uff77\046\uff77\047\uff77\050\uff77\062\uff77\075" + + "\uff77\100\uff77\102\uff77\001\002\000\100\032\uff4d\033\uff4d" + + "\034\uff4d\035\uff4d\037\uff4d\041\uff4d\042\uff4d\043\uff4d\051" + + "\uff4d\052\uff4d\053\uff4d\054\uff4d\055\uff4d\056\uff4d\057\uff4d" + + "\060\uff4d\061\uff4d\062\uff4d\063\uff4d\064\uff4d\065\uff4d\067" + + "\uff4d\070\uff4d\071\uff4d\072\uff4d\073\uff4d\074\uff4d\076\uff4d" + + "\077\uff4d\103\uff4d\104\uff4d\001\002\000\070\032\264\035" + + "\uff4a\042\244\043\uff4a\051\261\052\260\053\255\054\241" + + "\055\242\056\237\057\252\060\247\061\254\062\256\063" + + "\246\064\253\065\265\067\263\070\236\071\235\072\245" + + "\073\250\074\262\076\234\077\240\103\251\104\257\001" + + "\002\000\006\035\336\043\337\001\002\000\042\017\173" + + "\020\206\021\107\030\211\036\166\040\164\042\217\044" + + "\106\045\104\046\113\047\036\050\017\062\103\075\172" + + "\100\230\102\221\001\002\000\100\032\uff4c\033\uff4c\034" + + "\uff4c\035\uff4c\037\uff4c\041\uff4c\042\uff4c\043\uff4c\051\uff4c" + + "\052\uff4c\053\uff4c\054\uff4c\055\uff4c\056\uff4c\057\uff4c\060" + + "\uff4c\061\uff4c\062\uff4c\063\uff4c\064\uff4c\065\uff4c\067\uff4c" + + "\070\uff4c\071\uff4c\072\uff4c\073\uff4c\074\uff4c\076\uff4c\077" + + "\uff4c\103\uff4c\104\uff4c\001\002\000\070\032\264\035\uff49" + + "\042\244\043\uff49\051\261\052\260\053\255\054\241\055" + + "\242\056\237\057\252\060\247\061\254\062\256\063\246" + + "\064\253\065\265\067\263\070\236\071\235\072\245\073" + + "\250\074\262\076\234\077\240\103\251\104\257\001\002" + + "\000\042\017\173\020\206\021\107\030\211\036\166\040" + + "\164\042\217\044\106\045\104\046\113\047\036\050\017" + + "\062\103\075\172\100\230\102\221\001\002\000\066\032" + + "\264\037\343\042\244\051\261\052\260\053\255\054\241" + + "\055\242\056\237\057\252\060\247\061\254\062\256\063" + + "\246\064\253\065\265\067\263\070\236\071\235\072\245" + + "\073\250\074\262\076\234\077\240\103\251\104\257\001" + + "\002\000\004\040\344\001\002\000\006\025\351\041\346" + + "\001\002\000\004\041\370\001\002\000\062\006\uff80\014" + + "\uff80\015\uff80\017\uff80\020\uff80\021\uff80\022\uff80\024\uff80" + + "\027\uff80\030\uff80\031\uff80\036\uff80\040\uff80\041\uff80\042" + + "\uff80\044\uff80\045\uff80\046\uff80\047\uff80\050\uff80\062\uff80" + + "\075\uff80\100\uff80\102\uff80\001\002\000\010\025\351\026" + + "\360\041\uff7f\001\002\000\010\025\uff7d\026\uff7d\041\uff7d" + + "\001\002\000\042\017\173\020\206\021\107\030\211\036" + + "\166\040\164\042\217\044\106\045\104\046\113\047\036" + + "\050\017\062\103\075\172\100\230\102\221\001\002\000" + + "\066\032\264\034\353\042\244\051\261\052\260\053\255" + + "\054\241\055\242\056\237\057\252\060\247\061\254\062" + + "\256\063\246\064\253\065\265\067\263\070\236\071\235" + + "\072\245\073\250\074\262\076\234\077\240\103\251\104" + + "\257\001\002\000\004\040\354\001\002\000\062\006\207" + + "\014\204\015\210\017\173\020\206\021\107\022\176\024" + + "\214\027\222\030\211\031\170\036\166\040\164\041\355" + + "\042\217\044\106\045\104\046\113\047\036\050\017\062" + + "\103\075\172\100\230\102\221\001\002\000\010\025\uff7a" + + "\026\uff7a\041\uff7a\001\002\000\062\006\207\014\204\015" + + "\210\017\173\020\206\021\107\022\176\024\214\027\222" + + "\030\211\031\170\036\166\040\164\041\357\042\217\044" + + "\106\045\104\046\113\047\036\050\017\062\103\075\172" + + "\100\230\102\221\001\002\000\010\025\uff7b\026\uff7b\041" + + "\uff7b\001\002\000\004\034\363\001\002\000\004\041\uff7e" + + "\001\002\000\010\025\uff7c\026\uff7c\041\uff7c\001\002\000" + + "\004\040\364\001\002\000\062\006\207\014\204\015\210" + + "\017\173\020\206\021\107\022\176\024\214\027\222\030" + + "\211\031\170\036\166\040\164\041\365\042\217\044\106" + + "\045\104\046\113\047\036\050\017\062\103\075\172\100" + + "\230\102\221\001\002\000\004\041\uff78\001\002\000\062" + + "\006\207\014\204\015\210\017\173\020\206\021\107\022" + + "\176\024\214\027\222\030\211\031\170\036\166\040\164" + + "\041\367\042\217\044\106\045\104\046\113\047\036\050" + + "\017\062\103\075\172\100\230\102\221\001\002\000\004" + + "\041\uff79\001\002\000\062\006\uff81\014\uff81\015\uff81\017" + + "\uff81\020\uff81\021\uff81\022\uff81\024\uff81\027\uff81\030\uff81" + + "\031\uff81\036\uff81\040\uff81\041\uff81\042\uff81\044\uff81\045" + + "\uff81\046\uff81\047\uff81\050\uff81\062\uff81\075\uff81\100\uff81" + + "\102\uff81\001\002\000\016\007\uffdc\010\uffdc\011\uffdc\013" + + "\uffdc\041\uffdc\050\uffdc\001\002\000\004\016\377\001\002" + + "\000\062\006\207\014\204\015\210\017\173\020\206\021" + + "\107\022\176\024\214\027\222\030\211\031\170\036\166" + + "\040\164\041\374\042\217\044\106\045\104\046\113\047" + + "\036\050\017\062\103\075\172\100\230\102\221\001\002" + + "\000\064\006\uff8f\014\uff8f\015\uff8f\016\uff8f\017\uff8f\020" + + "\uff8f\021\uff8f\022\uff8f\024\uff8f\027\uff8f\030\uff8f\031\uff8f" + + "\036\uff8f\040\uff8f\041\uff8f\042\uff8f\044\uff8f\045\uff8f\046" + + "\uff8f\047\uff8f\050\uff8f\062\uff8f\075\uff8f\100\uff8f\102\uff8f" + + "\001\002\000\062\006\207\014\204\015\210\017\173\020" + + "\206\021\107\022\176\024\214\027\222\030\211\031\170" + + "\036\166\040\164\041\376\042\217\044\106\045\104\046" + + "\113\047\036\050\017\062\103\075\172\100\230\102\221" + + "\001\002\000\064\006\uff8e\014\uff8e\015\uff8e\016\uff8e\017" + + "\uff8e\020\uff8e\021\uff8e\022\uff8e\024\uff8e\027\uff8e\030\uff8e" + + "\031\uff8e\036\uff8e\040\uff8e\041\uff8e\042\uff8e\044\uff8e\045" + + "\uff8e\046\uff8e\047\uff8e\050\uff8e\062\uff8e\075\uff8e\100\uff8e" + + "\102\uff8e\001\002\000\004\036\u0100\001\002\000\004\050" + + "\017\001\002\000\004\037\u0102\001\002\000\004\040\373" + + "\001\002\000\062\006\uff90\014\uff90\015\uff90\017\uff90\020" + + "\uff90\021\uff90\022\uff90\024\uff90\027\uff90\030\uff90\031\uff90" + + "\036\uff90\040\uff90\041\uff90\042\uff90\044\uff90\045\uff90\046" + + "\uff90\047\uff90\050\uff90\062\uff90\075\uff90\100\uff90\102\uff90" + + "\001\002\000\006\033\u0105\104\022\001\002\000\062\006" + + "\uffc0\014\uffc0\015\uffc0\017\uffc0\020\uffc0\021\uffc0\022\uffc0" + + "\024\uffc0\027\uffc0\030\uffc0\031\uffc0\036\uffc0\040\uffc0\041" + + "\uffc0\042\uffc0\044\uffc0\045\uffc0\046\uffc0\047\uffc0\050\uffc0" + + "\062\uffc0\075\uffc0\100\uffc0\102\uffc0\001\002\000\004\036" + + "\u0107\001\002\000\046\017\173\020\206\021\107\030\211" + + "\035\uff6f\036\166\037\uff6f\040\164\042\217\044\106\045" + + "\104\046\113\047\036\050\017\062\103\075\172\100\230" + + "\102\221\001\002\000\070\032\264\035\uff6e\037\uff6e\042" + + "\244\051\261\052\260\053\255\054\241\055\242\056\237" + + "\057\252\060\247\061\254\062\256\063\246\064\253\065" + + "\265\067\263\070\236\071\235\072\245\073\250\074\262" + + "\076\234\077\240\103\251\104\257\001\002\000\006\035" + + "\u010a\037\u010b\001\002\000\042\017\173\020\206\021\107" + + "\030\211\036\166\040\164\042\217\044\106\045\104\046" + + "\113\047\036\050\017\062\103\075\172\100\230\102\221" + + "\001\002\000\100\032\uffbe\033\uffbe\034\uffbe\035\uffbe\037" + + "\uffbe\041\uffbe\042\uffbe\043\uffbe\051\uffbe\052\uffbe\053\uffbe" + + "\054\uffbe\055\uffbe\056\uffbe\057\uffbe\060\uffbe\061\uffbe\062" + + "\uffbe\063\uffbe\064\uffbe\065\uffbe\067\uffbe\070\uffbe\071\uffbe" + + "\072\uffbe\073\uffbe\074\uffbe\076\uffbe\077\uffbe\103\uffbe\104" + + "\uffbe\001\002\000\070\032\264\035\uff6d\037\uff6d\042\244" + + "\051\261\052\260\053\255\054\241\055\242\056\237\057" + + "\252\060\247\061\254\062\256\063\246\064\253\065\265" + + "\067\263\070\236\071\235\072\245\073\250\074\262\076" + + "\234\077\240\103\251\104\257\001\002\000\062\006\uff92" + + "\014\uff92\015\uff92\017\uff92\020\uff92\021\uff92\022\uff92\024" + + "\uff92\027\uff92\030\uff92\031\uff92\036\uff92\040\uff92\041\uff92" + + "\042\uff92\044\uff92\045\uff92\046\uff92\047\uff92\050\uff92\062" + + "\uff92\075\uff92\100\uff92\102\uff92\001\002\000\066\032\264" + + "\033\u010f\042\244\051\261\052\260\053\255\054\241\055" + + "\242\056\237\057\252\060\247\061\254\062\256\063\246" + + "\064\253\065\265\067\263\070\236\071\235\072\245\073" + + "\250\074\262\076\234\077\240\103\251\104\257\001\002" + + "\000\062\006\uff91\014\uff91\015\uff91\017\uff91\020\uff91\021" + + "\uff91\022\uff91\024\uff91\027\uff91\030\uff91\031\uff91\036\uff91" + + "\040\uff91\041\uff91\042\uff91\044\uff91\045\uff91\046\uff91\047" + + "\uff91\050\uff91\062\uff91\075\uff91\100\uff91\102\uff91\001\002" + + "\000\062\006\uffc8\014\uffc8\015\uffc8\017\uffc8\020\uffc8\021" + + "\uffc8\022\uffc8\024\uffc8\027\uffc8\030\uffc8\031\uffc8\036\uffc8" + + "\040\uffc8\041\uffc8\042\uffc8\044\uffc8\045\uffc8\046\uffc8\047" + + "\uffc8\050\uffc8\062\uffc8\075\uffc8\100\uffc8\102\uffc8\001\002" + + "\000\046\017\173\020\206\021\107\030\211\035\uff6f\036" + + "\166\037\uff6f\040\164\042\217\044\106\045\104\046\113" + + "\047\036\050\017\062\103\075\172\100\230\102\221\001" + + "\002\000\006\035\u010a\037\u0113\001\002\000\100\032\uffb8" + + "\033\uffb8\034\uffb8\035\uffb8\037\uffb8\041\uffb8\042\uffb8\043" + + "\uffb8\051\uffb8\052\uffb8\053\uffb8\054\uffb8\055\uffb8\056\uffb8" + + "\057\uffb8\060\uffb8\061\uffb8\062\uffb8\063\uffb8\064\uffb8\065" + + "\uffb8\067\uffb8\070\uffb8\071\uffb8\072\uffb8\073\uffb8\074\uffb8" + + "\076\uffb8\077\uffb8\103\uffb8\104\uffb8\001\002\000\042\017" + + "\173\020\206\021\107\030\211\036\166\040\164\042\217" + + "\044\106\045\104\046\113\047\036\050\017\062\103\075" + + "\172\100\230\102\221\001\002\000\066\032\264\037\u0116" + + "\042\244\051\261\052\260\053\255\054\241\055\242\056" + + "\237\057\252\060\247\061\254\062\256\063\246\064\253" + + "\065\265\067\263\070\236\071\235\072\245\073\250\074" + + "\262\076\234\077\240\103\251\104\257\001\002\000\004" + + "\040\u0117\001\002\000\062\006\207\014\204\015\210\017" + + "\173\020\206\021\107\022\176\024\214\027\222\030\211" + + "\031\170\036\166\040\164\041\u0118\042\217\044\106\045" + + "\104\046\113\047\036\050\017\062\103\075\172\100\230" + + "\102\221\001\002\000\064\006\uff89\014\uff89\015\uff89\017" + + "\uff89\020\uff89\021\uff89\022\uff89\023\uff89\024\uff89\027\uff89" + + "\030\uff89\031\uff89\036\uff89\040\uff89\041\uff89\042\uff89\044" + + "\uff89\045\uff89\046\uff89\047\uff89\050\uff89\062\uff89\075\uff89" + + "\100\uff89\102\uff89\001\002\000\062\006\207\014\204\015" + + "\210\017\173\020\206\021\107\022\176\024\214\027\222" + + "\030\211\031\170\036\166\040\164\041\u011a\042\217\044" + + "\106\045\104\046\113\047\036\050\017\062\103\075\172" + + "\100\230\102\221\001\002\000\064\006\uff88\014\uff88\015" + + "\uff88\017\uff88\020\uff88\021\uff88\022\uff88\023\uff88\024\uff88" + + "\027\uff88\030\uff88\031\uff88\036\uff88\040\uff88\041\uff88\042" + + "\uff88\044\uff88\045\uff88\046\uff88\047\uff88\050\uff88\062\uff88" + + "\075\uff88\100\uff88\102\uff88\001\002\000\100\032\264\033" + + "\uff44\034\uff44\035\uff44\037\uff44\041\uff44\042\244\043\uff44" + + "\051\261\052\260\053\255\054\241\055\242\056\237\057" + + "\uff44\060\uff44\061\254\062\256\063\246\064\253\065\265" + + "\067\263\070\236\071\235\072\245\073\250\074\262\076" + + "\234\077\240\103\251\104\257\001\002\000\100\032\264" + + "\033\uff95\034\uff95\035\uff95\037\uff95\041\uff95\042\244\043" + + "\uff95\051\uff95\052\uff95\053\uff95\054\uff95\055\uff95\056\uff95" + + "\057\uff95\060\uff95\061\uff95\062\uff95\063\uff95\064\uff95\065" + + "\uff95\067\uff95\070\uff95\071\uff95\072\uff95\073\uff95\074\uff95" + + "\076\uff95\077\uff95\103\uff95\104\257\001\002\000\044\017" + + "\173\020\206\021\107\030\211\033\uff71\036\166\040\164" + + "\042\217\044\106\045\104\046\113\047\036\050\017\062" + + "\103\075\172\100\230\102\221\001\002\000\072\032\uffb4" + + "\033\uffb4\034\u012a\036\u0111\042\uffb4\051\uffb4\052\uffb4\053" + + "\uffb4\054\uffb4\055\uffb4\056\uffb4\057\uffb4\060\uffb4\061\uffb4" + + "\062\uffb4\063\uffb4\064\uffb4\065\uffb4\067\uffb4\070\uffb4\071" + + "\uffb4\072\uffb4\073\uffb4\074\uffb4\076\uffb4\077\uffb4\103\uffb4" + + "\104\uffb4\001\002\000\004\033\u0121\001\002\000\070\032" + + "\264\033\uff70\037\uff70\042\244\051\261\052\260\053\255" + + "\054\241\055\242\056\237\057\252\060\247\061\254\062" + + "\256\063\246\064\253\065\265\067\263\070\236\071\235" + + "\072\245\073\250\074\262\076\234\077\240\103\251\104" + + "\257\001\002\000\044\017\173\020\206\021\107\030\211" + + "\033\uff71\036\166\040\164\042\217\044\106\045\104\046" + + "\113\047\036\050\017\062\103\075\172\100\230\102\221" + + "\001\002\000\004\033\u0123\001\002\000\044\017\173\020" + + "\206\021\107\030\211\036\166\037\uff71\040\164\042\217" + + "\044\106\045\104\046\113\047\036\050\017\062\103\075" + + "\172\100\230\102\221\001\002\000\004\037\u0125\001\002" + + "\000\004\040\u0126\001\002\000\062\006\207\014\204\015" + + "\210\017\173\020\206\021\107\022\176\024\214\027\222" + + "\030\211\031\170\036\166\040\164\041\u0127\042\217\044" + + "\106\045\104\046\113\047\036\050\017\062\103\075\172" + + "\100\230\102\221\001\002\000\062\006\uff74\014\uff74\015" + + "\uff74\017\uff74\020\uff74\021\uff74\022\uff74\024\uff74\027\uff74" + + "\030\uff74\031\uff74\036\uff74\040\uff74\041\uff74\042\uff74\044" + + "\uff74\045\uff74\046\uff74\047\uff74\050\uff74\062\uff74\075\uff74" + + "\100\uff74\102\uff74\001\002\000\062\006\207\014\204\015" + + "\210\017\173\020\206\021\107\022\176\024\214\027\222" + + "\030\211\031\170\036\166\040\164\041\u0129\042\217\044" + + "\106\045\104\046\113\047\036\050\017\062\103\075\172" + + "\100\230\102\221\001\002\000\062\006\uff75\014\uff75\015" + + "\uff75\017\uff75\020\uff75\021\uff75\022\uff75\024\uff75\027\uff75" + + "\030\uff75\031\uff75\036\uff75\040\uff75\041\uff75\042\uff75\044" + + "\uff75\045\uff75\046\uff75\047\uff75\050\uff75\062\uff75\075\uff75" + + "\100\uff75\102\uff75\001\002\000\042\017\173\020\206\021" + + "\107\030\211\036\166\040\164\042\217\044\106\045\104" + + "\046\113\047\036\050\017\062\103\075\172\100\230\102" + + "\221\001\002\000\066\032\264\037\u012c\042\244\051\261" + + "\052\260\053\255\054\241\055\242\056\237\057\252\060" + + "\247\061\254\062\256\063\246\064\253\065\265\067\263" + + "\070\236\071\235\072\245\073\250\074\262\076\234\077" + + "\240\103\251\104\257\001\002\000\004\040\u012d\001\002" + + "\000\062\006\207\014\204\015\210\017\173\020\206\021" + + "\107\022\176\024\214\027\222\030\211\031\170\036\166" + + "\040\164\041\u012e\042\217\044\106\045\104\046\113\047" + + "\036\050\017\062\103\075\172\100\230\102\221\001\002" + + "\000\062\006\uff72\014\uff72\015\uff72\017\uff72\020\uff72\021" + + "\uff72\022\uff72\024\uff72\027\uff72\030\uff72\031\uff72\036\uff72" + + "\040\uff72\041\uff72\042\uff72\044\uff72\045\uff72\046\uff72\047" + + "\uff72\050\uff72\062\uff72\075\uff72\100\uff72\102\uff72\001\002" + + "\000\062\006\207\014\204\015\210\017\173\020\206\021" + + "\107\022\176\024\214\027\222\030\211\031\170\036\166" + + "\040\164\041\u0130\042\217\044\106\045\104\046\113\047" + + "\036\050\017\062\103\075\172\100\230\102\221\001\002" + + "\000\062\006\uff73\014\uff73\015\uff73\017\uff73\020\uff73\021" + + "\uff73\022\uff73\024\uff73\027\uff73\030\uff73\031\uff73\036\uff73" + + "\040\uff73\041\uff73\042\uff73\044\uff73\045\uff73\046\uff73\047" + + "\uff73\050\uff73\062\uff73\075\uff73\100\uff73\102\uff73\001\002" + + "\000\066\032\264\037\u0132\042\244\051\261\052\260\053" + + "\255\054\241\055\242\056\237\057\252\060\247\061\254" + + "\062\256\063\246\064\253\065\265\067\263\070\236\071" + + "\235\072\245\073\250\074\262\076\234\077\240\103\251" + + "\104\257\001\002\000\100\032\uffac\033\uffac\034\uffac\035" + + "\uffac\037\uffac\041\uffac\042\uffac\043\uffac\051\uffac\052\uffac" + + "\053\uffac\054\uffac\055\uffac\056\uffac\057\uffac\060\uffac\061" + + "\uffac\062\uffac\063\uffac\064\uffac\065\uffac\067\uffac\070\uffac" + + "\071\uffac\072\uffac\073\uffac\074\uffac\076\uffac\077\uffac\103" + + "\uffac\104\uffac\001\002\000\064\006\uff8c\014\uff8c\015\uff8c" + + "\017\uff8c\020\uff8c\021\uff8c\022\uff8c\023\u0134\024\uff8c\027" + + "\uff8c\030\uff8c\031\uff8c\036\uff8c\040\uff8c\041\uff8c\042\uff8c" + + "\044\uff8c\045\uff8c\046\uff8c\047\uff8c\050\uff8c\062\uff8c\075" + + "\uff8c\100\uff8c\102\uff8c\001\002\000\006\022\u0137\040\u0138" + + "\001\002\000\064\006\uff87\014\uff87\015\uff87\017\uff87\020" + + "\uff87\021\uff87\022\uff87\023\uff87\024\uff87\027\uff87\030\uff87" + + "\031\uff87\036\uff87\040\uff87\041\uff87\042\uff87\044\uff87\045" + + "\uff87\046\uff87\047\uff87\050\uff87\062\uff87\075\uff87\100\uff87" + + "\102\uff87\001\002\000\062\006\uff8b\014\uff8b\015\uff8b\017" + + "\uff8b\020\uff8b\021\uff8b\022\uff8b\024\uff8b\027\uff8b\030\uff8b" + + "\031\uff8b\036\uff8b\040\uff8b\041\uff8b\042\uff8b\044\uff8b\045" + + "\uff8b\046\uff8b\047\uff8b\050\uff8b\062\uff8b\075\uff8b\100\uff8b" + + "\102\uff8b\001\002\000\004\036\u013c\001\002\000\062\006" + + "\207\014\204\015\210\017\173\020\206\021\107\022\176" + + "\024\214\027\222\030\211\031\170\036\166\040\164\041" + + "\u0139\042\217\044\106\045\104\046\113\047\036\050\017" + + "\062\103\075\172\100\230\102\221\001\002\000\062\006" + + "\uff83\014\uff83\015\uff83\017\uff83\020\uff83\021\uff83\022\uff83" + + "\024\uff83\027\uff83\030\uff83\031\uff83\036\uff83\040\uff83\041" + + "\uff83\042\uff83\044\uff83\045\uff83\046\uff83\047\uff83\050\uff83" + + "\062\uff83\075\uff83\100\uff83\102\uff83\001\002\000\062\006" + + "\207\014\204\015\210\017\173\020\206\021\107\022\176" + + "\024\214\027\222\030\211\031\170\036\166\040\164\041" + + "\u013b\042\217\044\106\045\104\046\113\047\036\050\017" + + "\062\103\075\172\100\230\102\221\001\002\000\062\006" + + "\uff82\014\uff82\015\uff82\017\uff82\020\uff82\021\uff82\022\uff82" + + "\024\uff82\027\uff82\030\uff82\031\uff82\036\uff82\040\uff82\041" + + "\uff82\042\uff82\044\uff82\045\uff82\046\uff82\047\uff82\050\uff82" + + "\062\uff82\075\uff82\100\uff82\102\uff82\001\002\000\042\017" + + "\173\020\206\021\107\030\211\036\166\040\164\042\217" + + "\044\106\045\104\046\113\047\036\050\017\062\103\075" + + "\172\100\230\102\221\001\002\000\066\032\264\037\u013e" + + "\042\244\051\261\052\260\053\255\054\241\055\242\056" + + "\237\057\252\060\247\061\254\062\256\063\246\064\253" + + "\065\265\067\263\070\236\071\235\072\245\073\250\074" + + "\262\076\234\077\240\103\251\104\257\001\002\000\004" + + "\040\u013f\001\002\000\062\006\207\014\204\015\210\017" + + "\173\020\206\021\107\022\176\024\214\027\222\030\211" + + "\031\170\036\166\040\164\041\u0140\042\217\044\106\045" + + "\104\046\113\047\036\050\017\062\103\075\172\100\230" + + "\102\221\001\002\000\064\006\uff85\014\uff85\015\uff85\017" + + "\uff85\020\uff85\021\uff85\022\uff85\023\uff85\024\uff85\027\uff85" + + "\030\uff85\031\uff85\036\uff85\040\uff85\041\uff85\042\uff85\044" + + "\uff85\045\uff85\046\uff85\047\uff85\050\uff85\062\uff85\075\uff85" + + "\100\uff85\102\uff85\001\002\000\062\006\207\014\204\015" + + "\210\017\173\020\206\021\107\022\176\024\214\027\222" + + "\030\211\031\170\036\166\040\164\041\u0142\042\217\044" + + "\106\045\104\046\113\047\036\050\017\062\103\075\172" + + "\100\230\102\221\001\002\000\064\006\uff84\014\uff84\015" + + "\uff84\017\uff84\020\uff84\021\uff84\022\uff84\023\uff84\024\uff84" + + "\027\uff84\030\uff84\031\uff84\036\uff84\040\uff84\041\uff84\042" + + "\uff84\044\uff84\045\uff84\046\uff84\047\uff84\050\uff84\062\uff84" + + "\075\uff84\100\uff84\102\uff84\001\002\000\064\006\uff86\014" + + "\uff86\015\uff86\017\uff86\020\uff86\021\uff86\022\uff86\023\uff86" + + "\024\uff86\027\uff86\030\uff86\031\uff86\036\uff86\040\uff86\041" + + "\uff86\042\uff86\044\uff86\045\uff86\046\uff86\047\uff86\050\uff86" + + "\062\uff86\075\uff86\100\uff86\102\uff86\001\002\000\062\006" + + "\uff8a\014\uff8a\015\uff8a\017\uff8a\020\uff8a\021\uff8a\022\uff8a" + + "\024\uff8a\027\uff8a\030\uff8a\031\uff8a\036\uff8a\040\uff8a\041" + + "\uff8a\042\uff8a\044\uff8a\045\uff8a\046\uff8a\047\uff8a\050\uff8a" + + "\062\uff8a\075\uff8a\100\uff8a\102\uff8a\001\002\000\006\035" + + "\u0149\041\u014a\001\002\000\066\032\264\034\u0147\042\244" + + "\051\261\052\260\053\255\054\241\055\242\056\237\057" + + "\252\060\247\061\254\062\256\063\246\064\253\065\265" + + "\067\263\070\236\071\235\072\245\073\250\074\262\076" + + "\234\077\240\103\251\104\257\001\002\000\042\017\173" + + "\020\206\021\107\030\211\036\166\040\164\042\217\044" + + "\106\045\104\046\113\047\036\050\017\062\103\075\172" + + "\100\230\102\221\001\002\000\070\032\264\035\uff46\041" + + "\uff46\042\244\051\261\052\260\053\255\054\241\055\242" + + "\056\237\057\252\060\247\061\254\062\256\063\246\064" + + "\253\065\265\067\263\070\236\071\235\072\245\073\250" + + "\074\262\076\234\077\240\103\251\104\257\001\002\000" + + "\042\017\173\020\206\021\107\030\211\036\166\040\164" + + "\042\217\044\106\045\104\046\113\047\036\050\017\062" + + "\103\075\172\100\230\102\221\001\002\000\100\032\uff48" + + "\033\uff48\034\uff48\035\uff48\037\uff48\041\uff48\042\uff48\043" + + "\uff48\051\uff48\052\uff48\053\uff48\054\uff48\055\uff48\056\uff48" + + "\057\uff48\060\uff48\061\uff48\062\uff48\063\uff48\064\uff48\065" + + "\uff48\067\uff48\070\uff48\071\uff48\072\uff48\073\uff48\074\uff48" + + "\076\uff48\077\uff48\103\uff48\104\uff48\001\002\000\066\032" + + "\264\034\u014c\042\244\051\261\052\260\053\255\054\241" + + "\055\242\056\237\057\252\060\247\061\254\062\256\063" + + "\246\064\253\065\265\067\263\070\236\071\235\072\245" + + "\073\250\074\262\076\234\077\240\103\251\104\257\001" + + "\002\000\042\017\173\020\206\021\107\030\211\036\166" + + "\040\164\042\217\044\106\045\104\046\113\047\036\050" + + "\017\062\103\075\172\100\230\102\221\001\002\000\070" + + "\032\264\035\uff45\041\uff45\042\244\051\261\052\260\053" + + "\255\054\241\055\242\056\237\057\252\060\247\061\254" + + "\062\256\063\246\064\253\065\265\067\263\070\236\071" + + "\235\072\245\073\250\074\262\076\234\077\240\103\251" + + "\104\257\001\002\000\006\050\017\101\076\001\002\000" + + "\006\035\uffd7\037\uffd7\001\002\000\006\035\uffd5\037\uffd5" + + "\001\002\000\022\021\107\040\117\042\105\044\106\045" + + "\104\046\113\047\036\062\103\001\002\000\016\007\uffe8" + + "\010\uffe8\011\uffe8\013\uffe8\041\uffe8\050\uffe8\001\002\000" + + "\004\033\u0160\001\002\000\004\033\u015f\001\002\000\004" + + "\033\u015e\001\002\000\004\033\u015d\001\002\000\004\033" + + "\u015c\001\002\000\004\033\u015b\001\002\000\004\033\u015a" + + "\001\002\000\016\007\uffe5\010\uffe5\011\uffe5\013\uffe5\041" + + "\uffe5\050\uffe5\001\002\000\016\007\uffe2\010\uffe2\011\uffe2" + + "\013\uffe2\041\uffe2\050\uffe2\001\002\000\016\007\uffe4\010" + + "\uffe4\011\uffe4\013\uffe4\041\uffe4\050\uffe4\001\002\000\016" + + "\007\uffe7\010\uffe7\011\uffe7\013\uffe7\041\uffe7\050\uffe7\001" + + "\002\000\016\007\uffe3\010\uffe3\011\uffe3\013\uffe3\041\uffe3" + + "\050\uffe3\001\002\000\016\007\uffe6\010\uffe6\011\uffe6\013" + + "\uffe6\041\uffe6\050\uffe6\001\002\000\016\007\uffe1\010\uffe1" + + "\011\uffe1\013\uffe1\041\uffe1\050\uffe1\001\002\000\004\036" + + "\uff50\001\002\000\004\036\u0163\001\002\000\012\035\uffd9" + + "\037\uffd9\050\075\101\076\001\002\000\006\035\160\037" + + "\u0165\001\002\000\004\033\u0166\001\002\000\016\007\uffda" + + "\010\uffda\011\uffda\013\uffda\041\uffda\050\uffda\001\002\000" + + "\016\007\uffeb\010\uffeb\011\uffeb\013\uffeb\041\uffeb\050\uffeb" + + "\001\002\000\016\007\uffe9\010\uffe9\011\uffe9\013\uffe9\041" + + "\uffe9\050\uffe9\001\002\000\016\002\uffed\004\uffed\005\uffed" + + "\006\uffed\012\uffed\013\uffed\001\002\000\006\034\u016c\040" + + "\053\001\002\000\016\002\ufff8\004\ufff8\005\ufff8\006\ufff8" + + "\012\ufff8\013\ufff8\001\002\000\004\050\u016e\001\002\000" + + "\006\035\u016f\040\053\001\002\000\006\035\ufff4\040\ufff4" + + "\001\002\000\004\050\u0171\001\002\000\016\002\ufff7\004" + + "\ufff7\005\ufff7\006\ufff7\012\ufff7\013\ufff7\001\002\000\006" + + "\035\ufff3\040\ufff3\001\002" }); + + /** Access to parse-action table. */ + public short[][] action_table() {return _action_table;} + + /** reduce_goto table. */ + protected static final short[][] _reduce_table = + unpackFromStrings(new String[] { + "\000\u016f\000\012\002\005\003\012\005\010\006\003\001" + + "\001\000\002\001\001\000\002\001\001\000\002\001\001" + + "\000\002\001\001\000\002\001\001\000\002\001\001\000" + + "\006\004\023\047\017\001\001\000\006\005\013\006\003" + + "\001\001\000\002\001\001\000\006\004\015\047\017\001" + + "\001\000\002\001\001\000\002\001\001\000\002\001\001" + + "\000\002\001\001\000\004\047\022\001\001\000\002\001" + + "\001\000\002\001\001\000\002\001\001\000\002\001\001" + + "\000\002\001\001\000\010\013\030\014\031\047\032\001" + + "\001\000\006\014\041\047\032\001\001\000\002\001\001" + + "\000\002\001\001\000\004\041\036\001\001\000\002\001" + + "\001\000\002\001\001\000\002\001\001\000\002\001\001" + + "\000\002\001\001\000\002\001\001\000\002\001\001\000" + + "\002\001\001\000\002\001\001\000\002\001\001\000\006" + + "\007\047\047\050\001\001\000\004\011\051\001\001\000" + + "\002\001\001\000\002\001\001\000\012\010\064\012\056" + + "\016\055\017\061\001\001\000\004\047\054\001\001\000" + + "\002\001\001\000\002\001\001\000\010\010\064\016\u0166" + + "\017\u0167\001\001\000\002\001\001\000\002\001\001\000" + + "\002\001\001\000\002\001\001\000\002\001\001\000\006" + + "\047\067\050\070\001\001\000\004\050\u0161\001\001\000" + + "\002\001\001\000\002\001\001\000\002\001\001\000\014" + + "\020\072\021\100\022\076\047\077\067\073\001\001\000" + + "\002\001\001\000\002\001\001\000\002\001\001\000\002" + + "\001\001\000\010\021\156\047\077\067\073\001\001\000" + + "\002\001\001\000\002\001\001\000\020\035\113\036\110" + + "\037\117\040\114\041\111\042\115\045\107\001\001\000" + + "\002\001\001\000\002\001\001\000\022\036\126\037\133" + + "\040\132\041\127\042\131\043\146\044\147\045\125\001" + + "\001\000\002\001\001\000\002\001\001\000\002\001\001" + + "\000\002\001\001\000\002\001\001\000\002\001\001\000" + + "\002\001\001\000\002\001\001\000\002\001\001\000\010" + + "\041\121\046\122\047\123\001\001\000\002\001\001\000" + + "\002\001\001\000\002\001\001\000\002\001\001\000\002" + + "\001\001\000\020\036\126\037\133\040\132\041\127\042" + + "\131\044\130\045\125\001\001\000\002\001\001\000\002" + + "\001\001\000\002\001\001\000\002\001\001\000\002\001" + + "\001\000\002\001\001\000\002\001\001\000\006\041\136" + + "\047\137\001\001\000\002\001\001\000\002\001\001\000" + + "\002\001\001\000\020\036\126\037\133\040\132\041\127" + + "\042\131\044\141\045\125\001\001\000\002\001\001\000" + + "\020\036\126\037\133\040\132\041\127\042\131\044\143" + + "\045\125\001\001\000\002\001\001\000\020\036\126\037" + + "\133\040\132\041\127\042\131\044\145\045\125\001\001" + + "\000\002\001\001\000\002\001\001\000\002\001\001\000" + + "\002\001\001\000\020\036\126\037\133\040\132\041\127" + + "\042\131\044\153\045\125\001\001\000\002\001\001\000" + + "\002\001\001\000\002\001\001\000\002\001\001\000\002" + + "\001\001\000\012\021\u014e\022\u014d\047\077\067\073\001" + + "\001\000\002\001\001\000\060\024\212\025\176\026\224" + + "\027\223\030\225\031\202\032\230\035\211\036\174\037" + + "\215\040\222\041\200\047\201\051\214\052\164\056\166" + + "\063\177\064\170\065\217\070\231\071\226\073\173\075" + + "\162\001\001\000\002\001\001\000\036\031\u0145\032\230" + + "\035\211\036\174\037\215\040\222\041\200\047\201\064" + + "\170\070\231\071\226\073\173\074\u0144\075\162\001\001" + + "\000\010\053\u0132\054\u0134\055\u0135\001\001\000\034\031" + + "\u0130\032\230\035\211\036\174\037\215\040\222\041\200" + + "\047\201\064\170\070\231\071\226\073\173\075\162\001" + + "\001\000\002\001\001\000\002\001\001\000\002\001\001" + + "\000\034\031\u011b\032\230\035\211\036\174\037\215\040" + + "\222\041\200\047\201\064\170\070\231\071\226\073\173" + + "\075\162\001\001\000\034\031\u011a\032\230\035\211\036" + + "\174\037\215\040\222\041\200\047\201\064\170\070\231" + + "\071\226\073\173\075\162\001\001\000\002\001\001\000" + + "\002\001\001\000\002\001\001\000\002\001\001\000\002" + + "\001\001\000\002\001\001\000\002\001\001\000\004\033" + + "\242\001\001\000\034\031\u010d\032\230\035\211\036\174" + + "\037\215\040\222\041\200\047\201\064\170\070\231\071" + + "\226\073\173\075\162\001\001\000\002\001\001\000\004" + + "\047\u0105\001\001\000\006\004\u0103\047\017\001\001\000" + + "\004\023\371\001\001\000\002\001\001\000\002\001\001" + + "\000\056\025\330\026\224\027\223\030\225\031\202\032" + + "\230\035\211\036\174\037\215\040\222\041\200\047\201" + + "\051\214\052\164\056\166\063\177\064\170\065\217\070" + + "\231\071\226\073\173\075\162\001\001\000\002\001\001" + + "\000\002\001\001\000\002\001\001\000\036\031\333\032" + + "\230\035\211\036\174\037\215\040\222\041\200\047\201" + + "\064\170\070\231\071\226\072\334\073\173\075\162\001" + + "\001\000\002\001\001\000\002\001\001\000\002\001\001" + + "\000\002\001\001\000\002\001\001\000\002\001\001\000" + + "\002\001\001\000\002\001\001\000\034\031\232\032\230" + + "\035\211\036\174\037\215\040\222\041\200\047\201\064" + + "\170\070\231\071\226\073\173\075\162\001\001\000\002" + + "\001\001\000\002\001\001\000\004\033\242\001\001\000" + + "\034\031\321\032\230\035\211\036\174\037\215\040\222" + + "\041\200\047\201\064\170\070\231\071\226\073\173\075" + + "\162\001\001\000\034\031\320\032\230\035\211\036\174" + + "\037\215\040\222\041\200\047\201\064\170\070\231\071" + + "\226\073\173\075\162\001\001\000\034\031\317\032\230" + + "\035\211\036\174\037\215\040\222\041\200\047\201\064" + + "\170\070\231\071\226\073\173\075\162\001\001\000\034" + + "\031\316\032\230\035\211\036\174\037\215\040\222\041" + + "\200\047\201\064\170\070\231\071\226\073\173\075\162" + + "\001\001\000\034\031\315\032\230\035\211\036\174\037" + + "\215\040\222\041\200\047\201\064\170\070\231\071\226" + + "\073\173\075\162\001\001\000\034\031\314\032\230\035" + + "\211\036\174\037\215\040\222\041\200\047\201\064\170" + + "\070\231\071\226\073\173\075\162\001\001\000\034\031" + + "\313\032\230\035\211\036\174\037\215\040\222\041\200" + + "\047\201\064\170\070\231\071\226\073\173\075\162\001" + + "\001\000\002\001\001\000\034\031\304\032\230\035\211" + + "\036\174\037\215\040\222\041\200\047\201\064\170\070" + + "\231\071\226\073\173\075\162\001\001\000\034\031\303" + + "\032\230\035\211\036\174\037\215\040\222\041\200\047" + + "\201\064\170\070\231\071\226\073\173\075\162\001\001" + + "\000\034\031\302\032\230\035\211\036\174\037\215\040" + + "\222\041\200\047\201\064\170\070\231\071\226\073\173" + + "\075\162\001\001\000\002\001\001\000\034\031\301\032" + + "\230\035\211\036\174\037\215\040\222\041\200\047\201" + + "\064\170\070\231\071\226\073\173\075\162\001\001\000" + + "\034\031\300\032\230\035\211\036\174\037\215\040\222" + + "\041\200\047\201\064\170\070\231\071\226\073\173\075" + + "\162\001\001\000\002\001\001\000\034\031\277\032\230" + + "\035\211\036\174\037\215\040\222\041\200\047\201\064" + + "\170\070\231\071\226\073\173\075\162\001\001\000\034" + + "\031\276\032\230\035\211\036\174\037\215\040\222\041" + + "\200\047\201\064\170\070\231\071\226\073\173\075\162" + + "\001\001\000\034\031\275\032\230\035\211\036\174\037" + + "\215\040\222\041\200\047\201\064\170\070\231\071\226" + + "\073\173\075\162\001\001\000\034\031\274\032\230\035" + + "\211\036\174\037\215\040\222\041\200\047\201\064\170" + + "\070\231\071\226\073\173\075\162\001\001\000\034\031" + + "\273\032\230\035\211\036\174\037\215\040\222\041\200" + + "\047\201\064\170\070\231\071\226\073\173\075\162\001" + + "\001\000\034\031\272\032\230\035\211\036\174\037\215" + + "\040\222\041\200\047\201\064\170\070\231\071\226\073" + + "\173\075\162\001\001\000\034\031\271\032\230\035\211" + + "\036\174\037\215\040\222\041\200\047\201\064\170\070" + + "\231\071\226\073\173\075\162\001\001\000\034\031\270" + + "\032\230\035\211\036\174\037\215\040\222\041\200\047" + + "\201\064\170\070\231\071\226\073\173\075\162\001\001" + + "\000\034\031\267\032\230\035\211\036\174\037\215\040" + + "\222\041\200\047\201\064\170\070\231\071\226\073\173" + + "\075\162\001\001\000\034\031\266\032\230\035\211\036" + + "\174\037\215\040\222\041\200\047\201\064\170\070\231" + + "\071\226\073\173\075\162\001\001\000\034\031\265\032" + + "\230\035\211\036\174\037\215\040\222\041\200\047\201" + + "\064\170\070\231\071\226\073\173\075\162\001\001\000" + + "\004\033\242\001\001\000\004\033\242\001\001\000\004" + + "\033\242\001\001\000\004\033\242\001\001\000\004\033" + + "\242\001\001\000\004\033\242\001\001\000\004\033\242" + + "\001\001\000\004\033\242\001\001\000\004\033\242\001" + + "\001\000\004\033\242\001\001\000\004\033\242\001\001" + + "\000\004\033\242\001\001\000\004\033\242\001\001\000" + + "\004\033\242\001\001\000\004\033\242\001\001\000\004" + + "\033\242\001\001\000\002\001\001\000\034\031\311\032" + + "\230\035\211\036\174\037\215\040\222\041\200\047\201" + + "\064\170\070\231\071\226\073\173\075\162\001\001\000" + + "\034\031\310\032\230\035\211\036\174\037\215\040\222" + + "\041\200\047\201\064\170\070\231\071\226\073\173\075" + + "\162\001\001\000\004\033\242\001\001\000\004\033\242" + + "\001\001\000\002\001\001\000\004\033\242\001\001\000" + + "\004\033\242\001\001\000\004\033\242\001\001\000\004" + + "\033\242\001\001\000\004\033\242\001\001\000\004\033" + + "\242\001\001\000\004\033\242\001\001\000\034\031\323" + + "\032\230\035\211\036\174\037\215\040\222\041\200\047" + + "\201\064\170\070\231\071\226\073\173\075\162\001\001" + + "\000\004\033\242\001\001\000\002\001\001\000\060\024" + + "\327\025\176\026\224\027\223\030\225\031\202\032\230" + + "\035\211\036\174\037\215\040\222\041\200\047\201\051" + + "\214\052\164\056\166\063\177\064\170\065\217\070\231" + + "\071\226\073\173\075\162\001\001\000\002\001\001\000" + + "\056\025\330\026\224\027\223\030\225\031\202\032\230" + + "\035\211\036\174\037\215\040\222\041\200\047\201\051" + + "\214\052\164\056\166\063\177\064\170\065\217\070\231" + + "\071\226\073\173\075\162\001\001\000\002\001\001\000" + + "\002\001\001\000\002\001\001\000\004\033\242\001\001" + + "\000\002\001\001\000\034\031\337\032\230\035\211\036" + + "\174\037\215\040\222\041\200\047\201\064\170\070\231" + + "\071\226\073\173\075\162\001\001\000\002\001\001\000" + + "\004\033\242\001\001\000\034\031\341\032\230\035\211" + + "\036\174\037\215\040\222\041\200\047\201\064\170\070" + + "\231\071\226\073\173\075\162\001\001\000\004\033\242" + + "\001\001\000\002\001\001\000\010\057\344\060\346\061" + + "\347\001\001\000\002\001\001\000\002\001\001\000\006" + + "\061\361\062\360\001\001\000\002\001\001\000\034\031" + + "\351\032\230\035\211\036\174\037\215\040\222\041\200" + + "\047\201\064\170\070\231\071\226\073\173\075\162\001" + + "\001\000\004\033\242\001\001\000\002\001\001\000\060" + + "\024\355\025\176\026\224\027\223\030\225\031\202\032" + + "\230\035\211\036\174\037\215\040\222\041\200\047\201" + + "\051\214\052\164\056\166\063\177\064\170\065\217\070" + + "\231\071\226\073\173\075\162\001\001\000\002\001\001" + + "\000\056\025\330\026\224\027\223\030\225\031\202\032" + + "\230\035\211\036\174\037\215\040\222\041\200\047\201" + + "\051\214\052\164\056\166\063\177\064\170\065\217\070" + + "\231\071\226\073\173\075\162\001\001\000\002\001\001" + + "\000\002\001\001\000\002\001\001\000\002\001\001\000" + + "\002\001\001\000\060\024\365\025\176\026\224\027\223" + + "\030\225\031\202\032\230\035\211\036\174\037\215\040" + + "\222\041\200\047\201\051\214\052\164\056\166\063\177" + + "\064\170\065\217\070\231\071\226\073\173\075\162\001" + + "\001\000\002\001\001\000\056\025\330\026\224\027\223" + + "\030\225\031\202\032\230\035\211\036\174\037\215\040" + + "\222\041\200\047\201\051\214\052\164\056\166\063\177" + + "\064\170\065\217\070\231\071\226\073\173\075\162\001" + + "\001\000\002\001\001\000\002\001\001\000\002\001\001" + + "\000\002\001\001\000\060\024\374\025\176\026\224\027" + + "\223\030\225\031\202\032\230\035\211\036\174\037\215" + + "\040\222\041\200\047\201\051\214\052\164\056\166\063" + + "\177\064\170\065\217\070\231\071\226\073\173\075\162" + + "\001\001\000\002\001\001\000\056\025\330\026\224\027" + + "\223\030\225\031\202\032\230\035\211\036\174\037\215" + + "\040\222\041\200\047\201\051\214\052\164\056\166\063" + + "\177\064\170\065\217\070\231\071\226\073\173\075\162" + + "\001\001\000\002\001\001\000\002\001\001\000\004\047" + + "\u0100\001\001\000\002\001\001\000\004\023\u0102\001\001" + + "\000\002\001\001\000\002\001\001\000\002\001\001\000" + + "\002\001\001\000\036\031\u0107\032\230\034\u0108\035\211" + + "\036\174\037\215\040\222\041\200\047\201\064\170\070" + + "\231\071\226\073\173\075\162\001\001\000\004\033\242" + + "\001\001\000\002\001\001\000\034\031\u010b\032\230\035" + + "\211\036\174\037\215\040\222\041\200\047\201\064\170" + + "\070\231\071\226\073\173\075\162\001\001\000\002\001" + + "\001\000\004\033\242\001\001\000\002\001\001\000\004" + + "\033\242\001\001\000\002\001\001\000\002\001\001\000" + + "\036\031\u0107\032\230\034\u0111\035\211\036\174\037\215" + + "\040\222\041\200\047\201\064\170\070\231\071\226\073" + + "\173\075\162\001\001\000\002\001\001\000\002\001\001" + + "\000\034\031\u0114\032\230\035\211\036\174\037\215\040" + + "\222\041\200\047\201\064\170\070\231\071\226\073\173" + + "\075\162\001\001\000\004\033\242\001\001\000\002\001" + + "\001\000\060\024\u0118\025\176\026\224\027\223\030\225" + + "\031\202\032\230\035\211\036\174\037\215\040\222\041" + + "\200\047\201\051\214\052\164\056\166\063\177\064\170" + + "\065\217\070\231\071\226\073\173\075\162\001\001\000" + + "\002\001\001\000\056\025\330\026\224\027\223\030\225" + + "\031\202\032\230\035\211\036\174\037\215\040\222\041" + + "\200\047\201\051\214\052\164\056\166\063\177\064\170" + + "\065\217\070\231\071\226\073\173\075\162\001\001\000" + + "\002\001\001\000\004\033\242\001\001\000\004\033\242" + + "\001\001\000\036\031\u011f\032\230\035\211\036\174\037" + + "\215\040\222\041\200\047\u011d\064\170\066\u011e\070\231" + + "\071\226\073\173\075\162\001\001\000\002\001\001\000" + + "\002\001\001\000\004\033\242\001\001\000\036\031\u011f" + + "\032\230\035\211\036\174\037\215\040\222\041\200\047" + + "\201\064\170\066\u0121\070\231\071\226\073\173\075\162" + + "\001\001\000\002\001\001\000\036\031\u011f\032\230\035" + + "\211\036\174\037\215\040\222\041\200\047\201\064\170" + + "\066\u0123\070\231\071\226\073\173\075\162\001\001\000" + + "\002\001\001\000\002\001\001\000\060\024\u0127\025\176" + + "\026\224\027\223\030\225\031\202\032\230\035\211\036" + + "\174\037\215\040\222\041\200\047\201\051\214\052\164" + + "\056\166\063\177\064\170\065\217\070\231\071\226\073" + + "\173\075\162\001\001\000\002\001\001\000\056\025\330" + + "\026\224\027\223\030\225\031\202\032\230\035\211\036" + + "\174\037\215\040\222\041\200\047\201\051\214\052\164" + + "\056\166\063\177\064\170\065\217\070\231\071\226\073" + + "\173\075\162\001\001\000\002\001\001\000\034\031\u012a" + + "\032\230\035\211\036\174\037\215\040\222\041\200\047" + + "\201\064\170\070\231\071\226\073\173\075\162\001\001" + + "\000\004\033\242\001\001\000\002\001\001\000\060\024" + + "\u012e\025\176\026\224\027\223\030\225\031\202\032\230" + + "\035\211\036\174\037\215\040\222\041\200\047\201\051" + + "\214\052\164\056\166\063\177\064\170\065\217\070\231" + + "\071\226\073\173\075\162\001\001\000\002\001\001\000" + + "\056\025\330\026\224\027\223\030\225\031\202\032\230" + + "\035\211\036\174\037\215\040\222\041\200\047\201\051" + + "\214\052\164\056\166\063\177\064\170\065\217\070\231" + + "\071\226\073\173\075\162\001\001\000\002\001\001\000" + + "\004\033\242\001\001\000\002\001\001\000\006\054\u0142" + + "\055\u0143\001\001\000\002\001\001\000\002\001\001\000" + + "\002\001\001\000\002\001\001\000\060\024\u0139\025\176" + + "\026\224\027\223\030\225\031\202\032\230\035\211\036" + + "\174\037\215\040\222\041\200\047\201\051\214\052\164" + + "\056\166\063\177\064\170\065\217\070\231\071\226\073" + + "\173\075\162\001\001\000\002\001\001\000\056\025\330" + + "\026\224\027\223\030\225\031\202\032\230\035\211\036" + + "\174\037\215\040\222\041\200\047\201\051\214\052\164" + + "\056\166\063\177\064\170\065\217\070\231\071\226\073" + + "\173\075\162\001\001\000\002\001\001\000\034\031\u013c" + + "\032\230\035\211\036\174\037\215\040\222\041\200\047" + + "\201\064\170\070\231\071\226\073\173\075\162\001\001" + + "\000\004\033\242\001\001\000\002\001\001\000\060\024" + + "\u0140\025\176\026\224\027\223\030\225\031\202\032\230" + + "\035\211\036\174\037\215\040\222\041\200\047\201\051" + + "\214\052\164\056\166\063\177\064\170\065\217\070\231" + + "\071\226\073\173\075\162\001\001\000\002\001\001\000" + + "\056\025\330\026\224\027\223\030\225\031\202\032\230" + + "\035\211\036\174\037\215\040\222\041\200\047\201\051" + + "\214\052\164\056\166\063\177\064\170\065\217\070\231" + + "\071\226\073\173\075\162\001\001\000\002\001\001\000" + + "\002\001\001\000\002\001\001\000\002\001\001\000\004" + + "\033\242\001\001\000\034\031\u0147\032\230\035\211\036" + + "\174\037\215\040\222\041\200\047\201\064\170\070\231" + + "\071\226\073\173\075\162\001\001\000\004\033\242\001" + + "\001\000\034\031\u014a\032\230\035\211\036\174\037\215" + + "\040\222\041\200\047\201\064\170\070\231\071\226\073" + + "\173\075\162\001\001\000\002\001\001\000\004\033\242" + + "\001\001\000\034\031\u014c\032\230\035\211\036\174\037" + + "\215\040\222\041\200\047\201\064\170\070\231\071\226" + + "\073\173\075\162\001\001\000\004\033\242\001\001\000" + + "\010\021\u014f\047\077\067\073\001\001\000\002\001\001" + + "\000\002\001\001\000\020\035\u0155\036\u0153\037\u0158\040" + + "\u0156\041\u0154\042\u0157\045\u0152\001\001\000\002\001\001" + + "\000\002\001\001\000\002\001\001\000\002\001\001\000" + + "\002\001\001\000\002\001\001\000\002\001\001\000\002" + + "\001\001\000\002\001\001\000\002\001\001\000\002\001" + + "\001\000\002\001\001\000\002\001\001\000\002\001\001" + + "\000\002\001\001\000\002\001\001\000\002\001\001\000" + + "\014\020\u0163\021\100\022\076\047\077\067\073\001\001" + + "\000\002\001\001\000\002\001\001\000\002\001\001\000" + + "\002\001\001\000\002\001\001\000\002\001\001\000\004" + + "\011\u016a\001\001\000\002\001\001\000\004\015\u016c\001" + + "\001\000\004\011\u016f\001\001\000\002\001\001\000\002" + + "\001\001\000\002\001\001\000\002\001\001" }); + + /** Access to reduce_goto table. */ + public short[][] reduce_table() {return _reduce_table;} + + /** Instance of action encapsulation class. */ + protected CUP$parser$actions action_obj; + + /** Action encapsulation object initializer. */ + protected void init_actions() + { + action_obj = new CUP$parser$actions(this); + } + + /** Invoke a user supplied parse action. */ + public java_cup.runtime.Symbol do_action( + int act_num, + java_cup.runtime.lr_parser parser, + java.util.Stack stack, + int top) + throws java.lang.Exception + { + /* call code in generated class */ + return action_obj.CUP$parser$do_action(act_num, parser, stack, top); + } + + /** Indicates start state. */ + public int start_state() {return 0;} + /** Indicates start production. */ + public int start_production() {return 1;} + + /** EOF Symbol index. */ + public int EOF_sym() {return 0;} + + /** error Symbol index. */ + public int error_sym() {return 1;} + + + /** Scan to get the next Symbol. */ + public java_cup.runtime.Symbol scan() + throws java.lang.Exception + { + return lexer.next_token(); + } + + + public boolean syntaxErrors; + + Lexer lexer; + Engine eng = null; + String fileName; + + public parser(Lexer lex, Engine Eng, String FileName) { + super(lex); + lexer = lex; + this.eng = Eng; + this.fileName = FileName; + } + + public void report_error(String message, Object info) + { + syntaxErrors = true; + + if ( !(info instanceof Symbol) ) return; + Symbol symbol = (Symbol) info; + + if ( symbol.left < 0 || symbol.right < 0 ) return; + + astNode n = new astNode(); + n.setParserInfo(this.fileName, symbol.left, symbol.right); + caliException ce = new caliException(n, "PARSE_ERROR: Unknown symbol found at line " + symbol.left + " column " + symbol.right + ".", ""); + console.get().err(ce.getMessage()); + this.eng.setParseError(); + this.done_parsing(); // Forces parser to quit + } + + public void report_fatal_error(String message, Object info) + { + this.report_error(message, info); + this.eng.setParseError(); + this.done_parsing(); // Forces parser to quit + } + + public Engine getEngine() { + return this.eng; + } + + +} + +/** Cup generated class to encapsulate user supplied action code.*/ +class CUP$parser$actions { + private final parser parser; + + /** Constructor */ + CUP$parser$actions(parser parser) { + this.parser = parser; + } + + /** Method 0 with the actual generated action code for actions 0 to 300. */ + public final java_cup.runtime.Symbol CUP$parser$do_action_part00000000( + int CUP$parser$act_num, + java_cup.runtime.lr_parser CUP$parser$parser, + java.util.Stack CUP$parser$stack, + int CUP$parser$top) + throws java.lang.Exception + { + /* Symbol object for return from actions */ + java_cup.runtime.Symbol CUP$parser$result; + + /* select the action based on the action number */ + switch (CUP$parser$act_num) + { + /*. . . . . . . . . . . . . . . . . . . .*/ + case 0: // input ::= block + { + Engine RESULT =null; + int rleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int rright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + Engine r = (Engine)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + RESULT = r; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("input",0, ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 1: // $START ::= input EOF + { + Object RESULT =null; + int start_valleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).left; + int start_valright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).right; + Engine start_val = (Engine)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-1)).value; + RESULT = start_val; + CUP$parser$result = parser.getSymbolFactory().newSymbol("$START",0, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + /* ACCEPT */ + CUP$parser$parser.done_parsing(); + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 2: // block ::= classDefExpr + { + Engine RESULT =null; + int cleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int cright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode c = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + this.parser.eng.addClass(c); + RESULT = this.parser.eng; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("block",1, ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 3: // block ::= block classDefExpr + { + Engine RESULT =null; + int rleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).left; + int rright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).right; + Engine r = (Engine)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-1)).value; + int cleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int cright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode c = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + r.addClass(c); + RESULT = r; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("block",1, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 4: // block ::= INCLUDE include SEMI + { + Engine RESULT =null; + int ileft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).left; + int iright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).right; + astNode i = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-1)).value; + + this.parser.eng.addInclude(((astInclude)i).getPath()); + RESULT = this.parser.eng; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("block",1, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 5: // block ::= block INCLUDE include SEMI + { + Engine RESULT =null; + int rleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-3)).left; + int rright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-3)).right; + Engine r = (Engine)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-3)).value; + int ileft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).left; + int iright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).right; + astNode i = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-1)).value; + + r.addInclude(((astInclude)i).getPath()); + RESULT = r; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("block",1, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-3)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 6: // block ::= error + { + Engine RESULT =null; + + + + CUP$parser$result = parser.getSymbolFactory().newSymbol("block",1, ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 7: // include ::= expVar + { + astNode RESULT =null; + int nameleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int nameright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode name = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + astInclude i = new astInclude(((astVar)name).getName()); + i.setParserInfo(this.parser.fileName, nameleft, nameright); + RESULT = i; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("include",2, ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 8: // include ::= include DOT expVar + { + astNode RESULT =null; + int ileft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).left; + int iright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).right; + astNode i = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-2)).value; + int nameleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int nameright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode name = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + ((astInclude)i).addName(((astVar)name).getName()); + RESULT = i; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("include",2, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 9: // classDefExpr ::= isStatic CLASSDEF IDENT classSection + { + astNode RESULT =null; + int isleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-3)).left; + int isright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-3)).right; + Boolean is = (Boolean)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-3)).value; + int classNameleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).left; + int classNameright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).right; + String className = (String)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-1)).value; + int acleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int acright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode ac = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + ac.setName(className); + ac.setParserInfo(this.parser.fileName, classNameleft, classNameright); + ((astClass)ac).setStatic((boolean)is); + RESULT = ac; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("classDefExpr",3, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-3)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 10: // classDefExpr ::= isStatic CLASSDEF IDENT COLON extendClassList classSection + { + astNode RESULT =null; + int isleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-5)).left; + int isright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-5)).right; + Boolean is = (Boolean)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-5)).value; + int classNameleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-3)).left; + int classNameright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-3)).right; + String className = (String)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-3)).value; + int clleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).left; + int clright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).right; + ArrayList cl = (ArrayList)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-1)).value; + int acleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int acright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode ac = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + ac.setName(className); + ac.setParserInfo(this.parser.fileName, classNameleft, classNameright); + ((astClass)ac).setStatic((boolean)is); + ((astClass)ac).setExtendedClasses(cl); + RESULT = ac; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("classDefExpr",3, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-5)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 11: // classDefExpr ::= isStatic EXTERN CLASSDEF IDENT COLON externClassRef classSection + { + astNode RESULT =null; + int isleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-6)).left; + int isright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-6)).right; + Boolean is = (Boolean)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-6)).value; + int classNameleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-3)).left; + int classNameright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-3)).right; + String className = (String)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-3)).value; + int ileft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).left; + int iright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).right; + astNode i = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-1)).value; + int acleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int acright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode ac = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + ac.setName(className); + ac.setParserInfo(this.parser.fileName, classNameleft, classNameright); + ((astClass)ac).setStatic((boolean)is); + ((astClass)ac).setExtern(true); + ((astClass)ac).setExternClassName(((astInclude)i).getExternClass()); + RESULT = ac; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("classDefExpr",3, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-6)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 12: // classDefExpr ::= ENUM IDENT LBRACKET enumBlocks RBRACKET + { + astNode RESULT =null; + int enumNameleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-3)).left; + int enumNameright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-3)).right; + String enumName = (String)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-3)).value; + int ebleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).left; + int ebright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).right; + astNode eb = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-1)).value; + + eb.setName(enumName); + eb.setParserInfo(this.parser.fileName, enumNameleft, enumNameright); + ((astClass)eb).setStatic(true); + RESULT = eb; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("classDefExpr",3, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-4)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 13: // extendClassList ::= IDENT + { + ArrayList RESULT =null; + int classNameleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int classNameright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + String className = (String)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + ArrayList list = new ArrayList(); + list.add(className); + RESULT = list; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("extendClassList",11, ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 14: // extendClassList ::= extendClassList COMMA IDENT + { + ArrayList RESULT =null; + int eclleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).left; + int eclright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).right; + ArrayList ecl = (ArrayList)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-2)).value; + int classNameleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int classNameright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + String className = (String)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + ecl.add(className); + RESULT = ecl; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("extendClassList",11, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 15: // isStatic ::= + { + Boolean RESULT =null; + + RESULT = new Boolean(false); + + CUP$parser$result = parser.getSymbolFactory().newSymbol("isStatic",4, ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 16: // isStatic ::= STATIC + { + Boolean RESULT =null; + + RESULT = new Boolean(true); + + CUP$parser$result = parser.getSymbolFactory().newSymbol("isStatic",4, ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 17: // externClassRef ::= expVar + { + astNode RESULT =null; + int nameleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int nameright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode name = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + astInclude i = new astInclude(((astVar)name).getName()); + RESULT = i; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("externClassRef",5, ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 18: // externClassRef ::= externClassRef DOT expVar + { + astNode RESULT =null; + int ileft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).left; + int iright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).right; + astNode i = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-2)).value; + int nameleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int nameright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode name = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + ((astInclude)i).addName(((astVar)name).getName()); + RESULT = i; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("externClassRef",5, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 19: // classSection ::= LBRACKET RBRACKET + { + astNode RESULT =null; + + astClass ac = new astClass(); + RESULT = ac; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("classSection",7, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 20: // classSection ::= LBRACKET classBlocks RBRACKET + { + astNode RESULT =null; + int acleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).left; + int acright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).right; + astNode ac = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-1)).value; + + RESULT = ac; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("classSection",7, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 21: // classBlocks ::= memberDefinition + { + astNode RESULT =null; + int vleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int vright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode v = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + astClass ac = new astClass(); + ac.addMember(v.getName(), v); + RESULT = (astNode)ac; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("classBlocks",8, ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 22: // classBlocks ::= classBlocks memberDefinition + { + astNode RESULT =null; + int acleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).left; + int acright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).right; + astNode ac = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-1)).value; + int vleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int vright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode v = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + ((astClass)ac).addMember(v.getName(), v); + RESULT = ac; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("classBlocks",8, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 23: // classBlocks ::= functionDefinition + { + astNode RESULT =null; + int fleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int fright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode f = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + astClass ac = new astClass(); + ac.addFunction(f.getName(), f); + RESULT = (astNode)ac; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("classBlocks",8, ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 24: // classBlocks ::= classBlocks functionDefinition + { + astNode RESULT =null; + int acleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).left; + int acright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).right; + astNode ac = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-1)).value; + int fleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int fright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode f = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + ((astClass)ac).addFunction(f.getName(), f); + RESULT = ac; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("classBlocks",8, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 25: // memberDefinition ::= AccessType expVar SEMI + { + astNode RESULT =null; + int amleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).left; + int amright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).right; + AccessType am = (AccessType)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-2)).value; + int vleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).left; + int vright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).right; + astNode v = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-1)).value; + + ((astVar)v).setAccessType(am); + RESULT = v; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("memberDefinition",12, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 26: // memberDefinition ::= AccessType expVar EQ expNull SEMI + { + astNode RESULT =null; + int amleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-4)).left; + int amright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-4)).right; + AccessType am = (AccessType)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-4)).value; + int vleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-3)).left; + int vright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-3)).right; + astNode v = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-3)).value; + int nleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).left; + int nright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).right; + astNode n = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-1)).value; + + n.setName(v.getName()); + n.setAccessType(am); + RESULT = n; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("memberDefinition",12, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-4)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 27: // memberDefinition ::= AccessType expVar EQ expBool SEMI + { + astNode RESULT =null; + int amleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-4)).left; + int amright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-4)).right; + AccessType am = (AccessType)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-4)).value; + int vleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-3)).left; + int vright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-3)).right; + astNode v = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-3)).value; + int bleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).left; + int bright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).right; + astNode b = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-1)).value; + + b.setName(v.getName()); + b.setAccessType(am); + RESULT = b; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("memberDefinition",12, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-4)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 28: // memberDefinition ::= AccessType expVar EQ expInt SEMI + { + astNode RESULT =null; + int amleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-4)).left; + int amright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-4)).right; + AccessType am = (AccessType)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-4)).value; + int vleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-3)).left; + int vright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-3)).right; + astNode v = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-3)).value; + int ileft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).left; + int iright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).right; + astNode i = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-1)).value; + + i.setName(v.getName()); + i.setAccessType(am); + RESULT = i; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("memberDefinition",12, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-4)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 29: // memberDefinition ::= AccessType expVar EQ expDouble SEMI + { + astNode RESULT =null; + int amleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-4)).left; + int amright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-4)).right; + AccessType am = (AccessType)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-4)).value; + int vleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-3)).left; + int vright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-3)).right; + astNode v = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-3)).value; + int dleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).left; + int dright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).right; + astNode d = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-1)).value; + + d.setName(v.getName()); + d.setAccessType(am); + RESULT = d; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("memberDefinition",12, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-4)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 30: // memberDefinition ::= AccessType expVar EQ expString SEMI + { + astNode RESULT =null; + int amleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-4)).left; + int amright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-4)).right; + AccessType am = (AccessType)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-4)).value; + int vleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-3)).left; + int vright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-3)).right; + astNode v = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-3)).value; + int sleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).left; + int sright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).right; + astNode s = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-1)).value; + + s.setName(v.getName()); + s.setAccessType(am); + RESULT = s; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("memberDefinition",12, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-4)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 31: // memberDefinition ::= AccessType expVar EQ expList SEMI + { + astNode RESULT =null; + int amleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-4)).left; + int amright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-4)).right; + AccessType am = (AccessType)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-4)).value; + int vleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-3)).left; + int vright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-3)).right; + astNode v = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-3)).value; + int lleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).left; + int lright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).right; + astNode l = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-1)).value; + + l.setName(v.getName()); + l.setAccessType(am); + RESULT = l; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("memberDefinition",12, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-4)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 32: // memberDefinition ::= AccessType expVar EQ expMap SEMI + { + astNode RESULT =null; + int amleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-4)).left; + int amright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-4)).right; + AccessType am = (AccessType)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-4)).value; + int vleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-3)).left; + int vright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-3)).right; + astNode v = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-3)).value; + int dleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).left; + int dright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).right; + astNode d = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-1)).value; + + d.setName(v.getName()); + d.setAccessType(am); + RESULT = d; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("memberDefinition",12, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-4)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 33: // enumBlocks ::= enumRec + { + astNode RESULT =null; + int erleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int erright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode er = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + astClass ac = new astClass(); + ac.setParserInfo(this.parser.fileName, erleft, erright); + ac.addMember(er.getName(), er); + RESULT = (astNode)ac; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("enumBlocks",9, ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 34: // enumBlocks ::= enumBlocks enumRec + { + astNode RESULT =null; + int ebleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).left; + int ebright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).right; + astNode eb = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-1)).value; + int erleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int erright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode er = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + ((astClass)eb).addMember(er.getName(), er); + RESULT = eb; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("enumBlocks",9, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 35: // enumRec ::= expVar SEMI + { + astNode RESULT =null; + int vleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).left; + int vright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).right; + astNode v = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-1)).value; + + astString tmp = new astString(v.getName()); + tmp.setName(v.getName()); + tmp.setParserInfo(this.parser.fileName, vleft, vright); + tmp.setAccessType(AccessType.aPublic); + RESULT = tmp; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("enumRec",10, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 36: // enumRec ::= expVar EQ expString SEMI + { + astNode RESULT =null; + int vleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-3)).left; + int vright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-3)).right; + astNode v = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-3)).value; + int sleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).left; + int sright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).right; + astNode s = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-1)).value; + + astString tmp = new astString(((astString)s).getValueString()); + tmp.setName(v.getName()); + tmp.setParserInfo(this.parser.fileName, vleft, vright); + tmp.setAccessType(AccessType.aPublic); + RESULT = tmp; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("enumRec",10, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-3)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 37: // functionDefinition ::= AccessType expFunctDef LPAREN functDefArgList RPAREN LBRACKET instructionList RBRACKET + { + astNode RESULT =null; + int amleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-7)).left; + int amright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-7)).right; + AccessType am = (AccessType)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-7)).value; + int fleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-6)).left; + int fright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-6)).right; + astNode f = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-6)).value; + int alleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-4)).left; + int alright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-4)).right; + astFunctDefArgsList al = (astFunctDefArgsList)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-4)).value; + int illeft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).left; + int ilright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).right; + astStatementList il = (astStatementList)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-1)).value; + + f.setParserInfo(this.parser.fileName, fleft, fright); + ((astFunctDef)f).setArgList(al); + ((astFunctDef)f).setInstructionList(il); + f.setAccessType(am); + RESULT = f; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("functionDefinition",13, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-7)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 38: // functionDefinition ::= AccessType expFunctDef LPAREN functDefArgList RPAREN LBRACKET RBRACKET + { + astNode RESULT =null; + int amleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-6)).left; + int amright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-6)).right; + AccessType am = (AccessType)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-6)).value; + int fleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-5)).left; + int fright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-5)).right; + astNode f = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-5)).value; + int alleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-3)).left; + int alright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-3)).right; + astFunctDefArgsList al = (astFunctDefArgsList)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-3)).value; + + f.setParserInfo(this.parser.fileName, fleft, fright); + ((astFunctDef)f).setArgList(al); + f.setAccessType(am); + RESULT = f; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("functionDefinition",13, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-6)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 39: // functionDefinition ::= AccessType EXTERN expFunctDef LPAREN functDefArgList RPAREN SEMI + { + astNode RESULT =null; + int amleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-6)).left; + int amright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-6)).right; + AccessType am = (AccessType)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-6)).value; + int fleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-4)).left; + int fright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-4)).right; + astNode f = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-4)).value; + int alleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).left; + int alright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).right; + astFunctDefArgsList al = (astFunctDefArgsList)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-2)).value; + + f.setParserInfo(this.parser.fileName, fleft, fright); + ((astFunctDef)f).setArgList(al); + ((astFunctDef)f).setExtern(true); + f.setAccessType(am); + RESULT = f; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("functionDefinition",13, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-6)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 40: // functDefArgList ::= + { + astFunctDefArgsList RESULT =null; + + astFunctDefArgsList al = new astFunctDefArgsList(); + RESULT = al; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("functDefArgList",14, ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 41: // functDefArgList ::= functDefArg + { + astFunctDefArgsList RESULT =null; + int fdaleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int fdaright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode fda = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + astFunctDefArgsList al = new astFunctDefArgsList(); + al.addNode(fda); + RESULT = al; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("functDefArgList",14, ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 42: // functDefArgList ::= functDefArgList COMMA functDefArg + { + astFunctDefArgsList RESULT =null; + int alleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).left; + int alright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).right; + astFunctDefArgsList al = (astFunctDefArgsList)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-2)).value; + int fdaleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int fdaright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode fda = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + al.addNode(fda); + RESULT = al; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("functDefArgList",14, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 43: // functDefArgList ::= functDefPrimType functDefArg + { + astFunctDefArgsList RESULT =null; + int pleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).left; + int pright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).right; + cType p = (cType)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-1)).value; + int fdaleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int fdaright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode fda = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + fda.setPrimType(p); + astFunctDefArgsList al = new astFunctDefArgsList(); + al.addNode(fda); + RESULT = al; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("functDefArgList",14, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 44: // functDefArgList ::= functDefArgList COMMA functDefPrimType functDefArg + { + astFunctDefArgsList RESULT =null; + int alleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-3)).left; + int alright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-3)).right; + astFunctDefArgsList al = (astFunctDefArgsList)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-3)).value; + int pleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).left; + int pright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).right; + cType p = (cType)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-1)).value; + int fdaleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int fdaright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode fda = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + fda.setPrimType(p); + al.addNode(fda); + RESULT = al; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("functDefArgList",14, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-3)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 45: // functDefArg ::= expVar + { + astNode RESULT =null; + int avleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int avright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode av = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + RESULT = av; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("functDefArg",15, ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 46: // functDefArg ::= expVar EQ expNull + { + astNode RESULT =null; + int vleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).left; + int vright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).right; + astNode v = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-2)).value; + int nleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int nright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode n = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + n.setName(v.getName()); + RESULT = n; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("functDefArg",15, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 47: // functDefArg ::= expVar EQ expBool + { + astNode RESULT =null; + int vleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).left; + int vright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).right; + astNode v = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-2)).value; + int bleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int bright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode b = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + b.setName(v.getName()); + RESULT = b; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("functDefArg",15, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 48: // functDefArg ::= expVar EQ expInt + { + astNode RESULT =null; + int vleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).left; + int vright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).right; + astNode v = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-2)).value; + int ileft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int iright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode i = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + i.setName(v.getName()); + RESULT = i; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("functDefArg",15, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 49: // functDefArg ::= expVar EQ expDouble + { + astNode RESULT =null; + int vleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).left; + int vright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).right; + astNode v = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-2)).value; + int dleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int dright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode d = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + d.setName(v.getName()); + RESULT = d; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("functDefArg",15, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 50: // functDefArg ::= expVar EQ expString + { + astNode RESULT =null; + int vleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).left; + int vright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).right; + astNode v = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-2)).value; + int sleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int sright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode s = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + s.setName(v.getName()); + RESULT = s; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("functDefArg",15, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 51: // functDefArg ::= expVar EQ expList + { + astNode RESULT =null; + int vleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).left; + int vright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).right; + astNode v = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-2)).value; + int lleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int lright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode l = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + l.setName(v.getName()); + RESULT = l; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("functDefArg",15, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 52: // functDefArg ::= expVar EQ expMap + { + astNode RESULT =null; + int vleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).left; + int vright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).right; + astNode v = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-2)).value; + int dleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int dright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode d = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + d.setName(v.getName()); + RESULT = d; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("functDefArg",15, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 53: // functDefArg ::= expEtcetera + { + astNode RESULT =null; + int etcleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int etcright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode etc = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + RESULT = (astNode)etc; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("functDefArg",15, ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 54: // functDefPrimType ::= IDENT + { + cType RESULT =null; + int sleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int sright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + String s = (String)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + if(s.equals("bool")) RESULT = cType.cBool; + else if(s.equals("int")) RESULT = cType.cInt; + else if(s.equals("double")) RESULT = cType.cDouble; + else if(s.equals("string")) RESULT = cType.cString; + else if(s.equals("list")) RESULT = cType.cList; + else if(s.equals("map")) RESULT = cType.cMap; + else if(s.equals("object")) RESULT = cType.cObject; + else if(s.equals("callback")) RESULT = cType.cCallback; + else + { + astNode n = new astNode(); + n.setParserInfo(this.parser.fileName, sleft, sright); + throw new caliException(n, "PARSE_ERROR: Expecting primative identifier but found '" + s + "' instead.", ""); + } + + CUP$parser$result = parser.getSymbolFactory().newSymbol("functDefPrimType",16, ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 55: // instructionList ::= instruction + { + astStatementList RESULT =null; + int ileft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int iright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode i = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + astStatementList il = new astStatementList(); + il.addNode(i); + RESULT = il; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("instructionList",18, ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 56: // instructionList ::= instructionList instruction + { + astStatementList RESULT =null; + int illeft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).left; + int ilright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).right; + astStatementList il = (astStatementList)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-1)).value; + int ileft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int iright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode i = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + il.addNode(i); + RESULT = il; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("instructionList",18, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 57: // instruction ::= expression SEMI + { + astNode RESULT =null; + int eleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).left; + int eright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).right; + astNode e = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-1)).value; + + RESULT = (astNode)e; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("instruction",19, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 58: // instruction ::= returnInstruction + { + astNode RESULT =null; + int rleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int rright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode r = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + RESULT = (astNode)r; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("instruction",19, ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 59: // instruction ::= expIfBlock + { + astNode RESULT =null; + int ibleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int ibright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode ib = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + RESULT = ib; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("instruction",19, ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 60: // instruction ::= expSwitch + { + astNode RESULT =null; + int sleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int sright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode s = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + RESULT = s; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("instruction",19, ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 61: // instruction ::= expWhile + { + astNode RESULT =null; + int wleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int wright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode w = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + RESULT = w; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("instruction",19, ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 62: // instruction ::= expFor + { + astNode RESULT =null; + int fleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int fright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode f = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + RESULT = f; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("instruction",19, ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 63: // instruction ::= tryCatchBlock + { + astNode RESULT =null; + int tcbleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int tcbright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode tcb = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + RESULT = (astNode)tcb; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("instruction",19, ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 64: // instruction ::= includeExp + { + astNode RESULT =null; + int ieleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int ieright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode ie = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + RESULT = ie; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("instruction",19, ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 65: // includeExp ::= INCLUDE include SEMI + { + astNode RESULT =null; + int ileft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).left; + int iright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).right; + astNode i = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-1)).value; + + astExpression e = new astExpression(i); + e.setParserInfo(this.parser.fileName, ileft, iright); + e.seteType(expType.INCLUDE); + RESULT = e; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("includeExp",22, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 66: // expression ::= operExp + { + astNode RESULT =null; + int oeleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int oeright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode oe = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + RESULT = oe; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expression",23, ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 67: // expression ::= NEW expVar LPAREN functCallArgList RPAREN + { + astNode RESULT =null; + int nleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-4)).left; + int nright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-4)).right; + Object n = (Object)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-4)).value; + int vleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-3)).left; + int vright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-3)).right; + astNode v = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-3)).value; + int alleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).left; + int alright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).right; + ArrayList al = (ArrayList)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-1)).value; + + astNewInst ni = new astNewInst(((astVar)v).getName()); + ni.setParserInfo(this.parser.fileName, nleft, nright); + astFunctDefArgsList nl = new astFunctDefArgsList(); + nl.setArgs(al); + ni.setArgs(nl); + RESULT = ni; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expression",23, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-4)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 68: // expression ::= expNewList + { + astNode RESULT =null; + int nlleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int nlright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode nl = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + RESULT = nl; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expression",23, ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 69: // expression ::= expNewMap + { + astNode RESULT =null; + int nmleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int nmright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode nm = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + RESULT = nm; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expression",23, ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 70: // expression ::= expCallback + { + astNode RESULT =null; + int cbleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int cbright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode cb = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + RESULT = cb; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expression",23, ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 71: // expression ::= expression INSERT expression + { + astNode RESULT =null; + int elleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).left; + int elright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).right; + astNode el = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-2)).value; + int erleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int erright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode er = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + astExpression e = new astExpression(el); + e.setParserInfo(this.parser.fileName, erleft, erright); + e.setRight(er); + e.seteType(expType.INSERT); + RESULT = e; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expression",23, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 72: // expression ::= COUNT expression + { + astNode RESULT =null; + int elleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int elright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode el = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + astExpression e = new astExpression(el); + e.setParserInfo(this.parser.fileName, elleft, elright); + e.seteType(expType.COUNT); + RESULT = e; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expression",23, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 73: // expression ::= expVar LPAREN functCallArgList RPAREN + { + astNode RESULT =null; + int vleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-3)).left; + int vright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-3)).right; + astNode v = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-3)).value; + int alleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).left; + int alright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).right; + ArrayList al = (ArrayList)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-1)).value; + + astFunctCall afc = new astFunctCall(((astVar)v).getName()); + afc.setParserInfo(this.parser.fileName, vleft, vright); + astFunctDefArgsList nl = new astFunctDefArgsList(); + nl.setArgs(al); + afc.setArgs(nl); + RESULT = afc; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expression",23, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-3)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 74: // expression ::= expression DOT expression + { + astNode RESULT =null; + int elleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).left; + int elright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).right; + astNode el = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-2)).value; + int erleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int erright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode er = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + el.setChild(er); + RESULT = el; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expression",23, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 75: // expression ::= expression INSTANCEOF expression + { + astNode RESULT =null; + int elleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).left; + int elright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).right; + astNode el = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-2)).value; + int erleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int erright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode er = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + astExpression e = new astExpression(el); + e.setParserInfo(this.parser.fileName, erleft, erright); + e.setRight(er); + e.seteType(expType.INSTANCEOF); + RESULT = e; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expression",23, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 76: // expression ::= expression indexExp + { + astNode RESULT =null; + int elleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).left; + int elright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).right; + astNode el = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-1)).value; + int ieleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int ieright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode ie = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + el.setChild(ie); + RESULT = el; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expression",23, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 77: // expression ::= expVar + { + astNode RESULT =null; + int vleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int vright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode v = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + astObj ao = new astObj(); + ao.setParserInfo(this.parser.fileName, vleft, vright); + ao.setName(v.getName()); + RESULT = ao; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expression",23, ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 78: // expression ::= expNull + { + astNode RESULT =null; + int nleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int nright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode n = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + RESULT = n; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expression",23, ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 79: // expression ::= expBool + { + astNode RESULT =null; + int bleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int bright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode b = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + RESULT = b; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expression",23, ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 80: // expression ::= expInt + { + astNode RESULT =null; + int ileft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int iright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode i = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + RESULT = i; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expression",23, ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 81: // expression ::= expDouble + { + astNode RESULT =null; + int dleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int dright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode d = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + RESULT = d; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expression",23, ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 82: // expression ::= expString + { + astNode RESULT =null; + int sleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int sright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode s = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + RESULT = s; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expression",23, ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 83: // expression ::= expBreak + { + astNode RESULT =null; + int bleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int bright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode b = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + RESULT = b; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expression",23, ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 84: // expression ::= expThrow + { + astNode RESULT =null; + int tleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int tright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode t = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + RESULT = t; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expression",23, ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 85: // expression ::= LPAREN expression RPAREN + { + astNode RESULT =null; + int eleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).left; + int eright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).right; + astNode e = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-1)).value; + + RESULT = e; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expression",23, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 86: // indexExp ::= LBRACE expression RBRACE + { + astNode RESULT =null; + int erleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).left; + int erright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).right; + astNode er = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-1)).value; + + astObj aobj = new astObj(); + aobj.setParserInfo(this.parser.fileName, erleft, erright); + aobj.setIndex(er); + RESULT = aobj; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("indexExp",25, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 87: // indexExp ::= indexExp LBRACE expression RBRACE + { + astNode RESULT =null; + int ieleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-3)).left; + int ieright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-3)).right; + astNode ie = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-3)).value; + int erleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).left; + int erright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).right; + astNode er = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-1)).value; + + astObj aobj = new astObj(); + aobj.setParserInfo(this.parser.fileName, erleft, erright); + aobj.setIndex(er); + ie.setChild(aobj); + RESULT = ie; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("indexExp",25, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-3)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 88: // indexExp ::= indexExp DOT expression + { + astNode RESULT =null; + int ieleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).left; + int ieright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).right; + astNode ie = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-2)).value; + int erleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int erright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode er = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + ie.setChild(er); + RESULT = ie; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("indexExp",25, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 89: // operExp ::= expression PL expression + { + astNode RESULT =null; + int elleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).left; + int elright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).right; + astNode el = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-2)).value; + int erleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int erright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode er = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + astExpression e = new astExpression(el); + e.setParserInfo(this.parser.fileName, erleft, erright); + e.setRight(er); + e.seteType(expType.ADD); + RESULT = e; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("operExp",24, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 90: // operExp ::= expression MI expression + { + astNode RESULT =null; + int elleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).left; + int elright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).right; + astNode el = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-2)).value; + int erleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int erright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode er = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + astExpression e = new astExpression(el); + e.setParserInfo(this.parser.fileName, erleft, erright); + e.setRight(er); + e.seteType(expType.SUBTRACT); + RESULT = e; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("operExp",24, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 91: // operExp ::= expression MU expression + { + astNode RESULT =null; + int elleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).left; + int elright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).right; + astNode el = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-2)).value; + int erleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int erright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode er = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + astExpression e = new astExpression(el); + e.setParserInfo(this.parser.fileName, erleft, erright); + e.setRight(er); + e.seteType(expType.MULTIPLY); + RESULT = e; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("operExp",24, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 92: // operExp ::= expression DI expression + { + astNode RESULT =null; + int elleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).left; + int elright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).right; + astNode el = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-2)).value; + int erleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int erright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode er = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + astExpression e = new astExpression(el); + e.setParserInfo(this.parser.fileName, erleft, erright); + e.setRight(er); + e.seteType(expType.DIVIDE); + RESULT = e; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("operExp",24, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 93: // operExp ::= expression MODULUS expression + { + astNode RESULT =null; + int elleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).left; + int elright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).right; + astNode el = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-2)).value; + int erleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int erright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode er = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + astExpression e = new astExpression(el); + e.setParserInfo(this.parser.fileName, erleft, erright); + e.setRight(er); + e.seteType(expType.MODULUS); + RESULT = e; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("operExp",24, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 94: // operExp ::= expression EQ expression + { + astNode RESULT =null; + int elleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).left; + int elright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).right; + astNode el = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-2)).value; + int erleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int erright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode er = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + astExpression e = new astExpression(el); + e.setParserInfo(this.parser.fileName, erleft, erright); + e.setRight(er); + e.seteType(expType.ASSIGNMENT); + RESULT = e; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("operExp",24, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 95: // operExp ::= expression PLEQ expression + { + astNode RESULT =null; + int elleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).left; + int elright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).right; + astNode el = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-2)).value; + int erleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int erright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode er = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + astExpression ea = new astExpression(el); + ea.setParserInfo(this.parser.fileName, erleft, erright); + ea.setRight(er); + ea.seteType(expType.ADD); + + astExpression e = new astExpression(el); + e.setParserInfo(this.parser.fileName, erleft, erright); + e.setRight(ea); + e.seteType(expType.ASSIGNMENT); + RESULT = e; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("operExp",24, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 96: // operExp ::= expression MIEQ expression + { + astNode RESULT =null; + int elleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).left; + int elright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).right; + astNode el = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-2)).value; + int erleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int erright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode er = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + astExpression ea = new astExpression(el); + ea.setParserInfo(this.parser.fileName, erleft, erright); + ea.setRight(er); + ea.seteType(expType.SUBTRACT); + + astExpression e = new astExpression(el); + e.setParserInfo(this.parser.fileName, erleft, erright); + e.setRight(ea); + e.seteType(expType.ASSIGNMENT); + RESULT = e; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("operExp",24, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 97: // operExp ::= expression MUEQ expression + { + astNode RESULT =null; + int elleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).left; + int elright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).right; + astNode el = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-2)).value; + int erleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int erright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode er = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + astExpression ea = new astExpression(el); + ea.setParserInfo(this.parser.fileName, erleft, erright); + ea.setRight(er); + ea.seteType(expType.MULTIPLY); + + astExpression e = new astExpression(el); + e.setParserInfo(this.parser.fileName, erleft, erright); + e.setRight(ea); + e.seteType(expType.ASSIGNMENT); + RESULT = e; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("operExp",24, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 98: // operExp ::= expression DIEQ expression + { + astNode RESULT =null; + int elleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).left; + int elright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).right; + astNode el = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-2)).value; + int erleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int erright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode er = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + astExpression ea = new astExpression(el); + ea.setParserInfo(this.parser.fileName, erleft, erright); + ea.setRight(er); + ea.seteType(expType.DIVIDE); + + astExpression e = new astExpression(el); + e.setParserInfo(this.parser.fileName, erleft, erright); + e.setRight(ea); + e.seteType(expType.ASSIGNMENT); + RESULT = e; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("operExp",24, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 99: // operExp ::= expression MODULUSEQ expression + { + astNode RESULT =null; + int elleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).left; + int elright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).right; + astNode el = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-2)).value; + int erleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int erright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode er = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + astExpression ea = new astExpression(el); + ea.setParserInfo(this.parser.fileName, erleft, erright); + ea.setRight(er); + ea.seteType(expType.MODULUS); + + astExpression e = new astExpression(el); + e.setParserInfo(this.parser.fileName, erleft, erright); + e.setRight(ea); + e.seteType(expType.ASSIGNMENT); + RESULT = e; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("operExp",24, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 100: // operExp ::= expression PLPL + { + astNode RESULT =null; + int elleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).left; + int elright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).right; + astNode el = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-1)).value; + + astInt ai = new astInt(1); + ai.setParserInfo(this.parser.fileName, elleft, elright); + + astExpression ea = new astExpression(el); + ea.setParserInfo(this.parser.fileName, elleft, elright); + ea.setRight(ai); + ea.seteType(expType.ADD); + + astExpression e = new astExpression(el); + e.setParserInfo(this.parser.fileName, elleft, elright); + e.setRight(ea); + e.seteType(expType.ASSIGNMENT); + RESULT = e; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("operExp",24, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 101: // operExp ::= expression MIMI + { + astNode RESULT =null; + int elleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).left; + int elright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).right; + astNode el = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-1)).value; + + astInt ai = new astInt(1); + ai.setParserInfo(this.parser.fileName, elleft, elright); + + astExpression ea = new astExpression(el); + ea.setParserInfo(this.parser.fileName, elleft, elright); + ea.setRight(ai); + ea.seteType(expType.SUBTRACT); + + astExpression e = new astExpression(el); + e.setParserInfo(this.parser.fileName, elleft, elright); + e.setRight(ea); + e.seteType(expType.ASSIGNMENT); + RESULT = e; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("operExp",24, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 102: // operExp ::= expression EQEQ expression + { + astNode RESULT =null; + int elleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).left; + int elright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).right; + astNode el = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-2)).value; + int erleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int erright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode er = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + astExpression e = new astExpression(el); + e.setParserInfo(this.parser.fileName, erleft, erright); + e.setRight(er); + e.seteType(expType.EQEQ); + RESULT = e; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("operExp",24, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 103: // operExp ::= expression NOTEQ expression + { + astNode RESULT =null; + int elleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).left; + int elright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).right; + astNode el = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-2)).value; + int erleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int erright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode er = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + astExpression e = new astExpression(el); + e.setParserInfo(this.parser.fileName, erleft, erright); + e.setRight(er); + e.seteType(expType.NOTEQ); + RESULT = e; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("operExp",24, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 104: // operExp ::= expression LT expression + { + astNode RESULT =null; + int elleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).left; + int elright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).right; + astNode el = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-2)).value; + int erleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int erright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode er = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + astExpression e = new astExpression(el); + e.setParserInfo(this.parser.fileName, erleft, erright); + e.setRight(er); + e.seteType(expType.LT); + RESULT = e; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("operExp",24, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 105: // operExp ::= expression GT expression + { + astNode RESULT =null; + int elleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).left; + int elright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).right; + astNode el = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-2)).value; + int erleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int erright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode er = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + astExpression e = new astExpression(el); + e.setParserInfo(this.parser.fileName, erleft, erright); + e.setRight(er); + e.seteType(expType.GT); + RESULT = e; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("operExp",24, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 106: // operExp ::= expression LTEQ expression + { + astNode RESULT =null; + int elleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).left; + int elright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).right; + astNode el = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-2)).value; + int erleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int erright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode er = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + astExpression e = new astExpression(el); + e.setParserInfo(this.parser.fileName, erleft, erright); + e.setRight(er); + e.seteType(expType.LTEQ); + RESULT = e; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("operExp",24, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 107: // operExp ::= expression GTEQ expression + { + astNode RESULT =null; + int elleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).left; + int elright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).right; + astNode el = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-2)).value; + int erleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int erright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode er = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + astExpression e = new astExpression(el); + e.setParserInfo(this.parser.fileName, erleft, erright); + e.setRight(er); + e.seteType(expType.GTEQ); + RESULT = e; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("operExp",24, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 108: // operExp ::= NOT expression + { + astNode RESULT =null; + int erleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int erright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode er = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + astExpression e = new astExpression(er); + e.setParserInfo(this.parser.fileName, erleft, erright); + e.seteType(expType.NOT); + RESULT = e; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("operExp",24, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 109: // operExp ::= expression AND expression + { + astNode RESULT =null; + int elleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).left; + int elright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).right; + astNode el = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-2)).value; + int erleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int erright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode er = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + astExpression e = new astExpression(el); + e.setParserInfo(this.parser.fileName, erleft, erright); + e.setRight(er); + e.seteType(expType.AND); + RESULT = e; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("operExp",24, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 110: // operExp ::= expression OR expression + { + astNode RESULT =null; + int elleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).left; + int elright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).right; + astNode el = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-2)).value; + int erleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int erright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode er = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + astExpression e = new astExpression(el); + e.setParserInfo(this.parser.fileName, erleft, erright); + e.setRight(er); + e.seteType(expType.OR); + RESULT = e; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("operExp",24, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 111: // returnInstruction ::= RETURN SEMI + { + astNode RESULT =null; + int rleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).left; + int rright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).right; + Object r = (Object)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-1)).value; + + astReturn ar = new astReturn(); + ar.setParserInfo(this.parser.fileName, rleft, rright); + RESULT = ar; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("returnInstruction",20, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 112: // returnInstruction ::= RETURN expression SEMI + { + astNode RESULT =null; + int rleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).left; + int rright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).right; + Object r = (Object)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-2)).value; + int exleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).left; + int exright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).right; + astNode ex = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-1)).value; + + astReturn ar = new astReturn(); + ar.setValue(ex); + ar.setParserInfo(this.parser.fileName, rleft, rright); + RESULT = ar; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("returnInstruction",20, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 113: // tryCatchBlock ::= TRY instructionListBlock CATCH LPAREN expVar RPAREN instructionListBlock + { + astNode RESULT =null; + int tleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-6)).left; + int tright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-6)).right; + Object t = (Object)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-6)).value; + int tilleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-5)).left; + int tilright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-5)).right; + astStatementList til = (astStatementList)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-5)).value; + int vleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).left; + int vright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).right; + astNode v = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-2)).value; + int cilleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int cilright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astStatementList cil = (astStatementList)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + astTryCatch atc = new astTryCatch(); + atc.setParserInfo(this.parser.fileName, tleft, tright); + atc.setName(v.getName()); + atc.setTryInstList(til); + atc.setCatchInstList(cil); + RESULT = atc; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("tryCatchBlock",21, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-6)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 114: // instructionListBlock ::= LBRACKET RBRACKET + { + astStatementList RESULT =null; + + astStatementList il = new astStatementList(); + RESULT = il; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("instructionListBlock",17, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 115: // instructionListBlock ::= LBRACKET instructionList RBRACKET + { + astStatementList RESULT =null; + int illeft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).left; + int ilright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).right; + astStatementList il = (astStatementList)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-1)).value; + + RESULT = il; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("instructionListBlock",17, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 116: // expIfBlock ::= expIfBlockList + { + astNode RESULT =null; + int eiblleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int eiblright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode eibl = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + RESULT = eibl; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expIfBlock",39, ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 117: // expIfBlock ::= expIfBlockList expIfElseBlockList + { + astNode RESULT =null; + int eiblleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).left; + int eiblright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).right; + astNode eibl = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-1)).value; + int eieblleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int eieblright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + ArrayList eiebl = (ArrayList)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + astIfElse aie = (astIfElse)eibl; + aie.setIfElseConditions((ArrayList)eiebl); + RESULT = aie; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expIfBlock",39, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 118: // expIfBlock ::= expIfBlockList expElse + { + astNode RESULT =null; + int eiblleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).left; + int eiblright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).right; + astNode eibl = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-1)).value; + int eeleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int eeright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astStatementList ee = (astStatementList)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + astIfElse aie = (astIfElse)eibl; + aie.setElseInstructionList(ee); + RESULT = aie; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expIfBlock",39, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 119: // expIfBlock ::= expIfBlockList expIfElseBlockList expElse + { + astNode RESULT =null; + int eiblleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).left; + int eiblright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).right; + astNode eibl = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-2)).value; + int eieblleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).left; + int eieblright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).right; + ArrayList eiebl = (ArrayList)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-1)).value; + int eeleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int eeright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astStatementList ee = (astStatementList)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + astIfElse aie = (astIfElse)eibl; + aie.setIfElseConditions((ArrayList)eiebl); + aie.setElseInstructionList(ee); + RESULT = aie; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expIfBlock",39, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 120: // expIfBlockList ::= IF LPAREN expression RPAREN LBRACKET RBRACKET + { + astNode RESULT =null; + int eleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-3)).left; + int eright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-3)).right; + astNode e = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-3)).value; + + astIfElse aie = new astIfElse(); + aie.setParserInfo(this.parser.fileName, eleft, eright); + astConditionBlock acb = new astConditionBlock(); + acb.setExpression(e); + aie.setIfCondition(acb); + RESULT = aie; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expIfBlockList",40, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-5)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 121: // expIfBlockList ::= IF LPAREN expression RPAREN LBRACKET instructionList RBRACKET + { + astNode RESULT =null; + int eleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-4)).left; + int eright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-4)).right; + astNode e = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-4)).value; + int iilleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).left; + int iilright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).right; + astStatementList iil = (astStatementList)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-1)).value; + + astIfElse aie = new astIfElse(); + aie.setParserInfo(this.parser.fileName, eleft, eright); + astConditionBlock acb = new astConditionBlock(); + acb.setExpression(e); + acb.setInstructionList(iil); + aie.setIfCondition(acb); + RESULT = aie; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expIfBlockList",40, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-6)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 122: // expIfElseBlockList ::= expIfElseBlock + { + ArrayList RESULT =null; + int elleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int elright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode el = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + ArrayList iecl = new ArrayList(); + iecl.add(el); + RESULT = iecl; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expIfElseBlockList",41, ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 123: // expIfElseBlockList ::= expIfElseBlockList expIfElseBlock + { + ArrayList RESULT =null; + int eiebleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).left; + int eiebright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).right; + ArrayList eieb = (ArrayList)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-1)).value; + int erleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int erright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode er = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + eieb.add(er); + RESULT = eieb; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expIfElseBlockList",41, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 124: // expIfElseBlock ::= ELSE IF LPAREN expression RPAREN LBRACKET RBRACKET + { + astNode RESULT =null; + int eleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-3)).left; + int eright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-3)).right; + astNode e = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-3)).value; + + astConditionBlock acb = new astConditionBlock(); + acb.setParserInfo(this.parser.fileName, eleft, eright); + acb.setExpression(e); + RESULT = acb; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expIfElseBlock",42, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-6)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 125: // expIfElseBlock ::= ELSE IF LPAREN expression RPAREN LBRACKET instructionList RBRACKET + { + astNode RESULT =null; + int eleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-4)).left; + int eright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-4)).right; + astNode e = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-4)).value; + int iilleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).left; + int iilright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).right; + astStatementList iil = (astStatementList)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-1)).value; + + astConditionBlock acb = new astConditionBlock(); + acb.setParserInfo(this.parser.fileName, eleft, eright); + acb.setExpression(e); + acb.setInstructionList(iil); + RESULT = acb; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expIfElseBlock",42, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-7)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 126: // expElse ::= ELSE LBRACKET RBRACKET + { + astStatementList RESULT =null; + + astStatementList list = new astStatementList(); + RESULT = list; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expElse",43, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 127: // expElse ::= ELSE LBRACKET instructionList RBRACKET + { + astStatementList RESULT =null; + int iilleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).left; + int iilright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).right; + astStatementList iil = (astStatementList)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-1)).value; + + RESULT = iil; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expElse",43, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-3)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 128: // expSwitch ::= SWITCH LPAREN expression RPAREN LBRACKET expSwitchBlockList RBRACKET + { + astNode RESULT =null; + int eleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-4)).left; + int eright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-4)).right; + astNode e = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-4)).value; + int sblleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).left; + int sblright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).right; + astNode sbl = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-1)).value; + + astSwitch as = (astSwitch)sbl; + as.setParserInfo(this.parser.fileName, eleft, eright); + as.setExpression(e); + RESULT = as; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expSwitch",44, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-6)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 129: // expSwitch ::= SWITCH LPAREN expression RPAREN LBRACKET RBRACKET + { + astNode RESULT =null; + int eleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-3)).left; + int eright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-3)).right; + astNode e = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-3)).value; + + astSwitch as = new astSwitch(); + as.setParserInfo(this.parser.fileName, eleft, eright); + as.setExpression(e); + RESULT = as; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expSwitch",44, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-5)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 130: // expSwitchBlockList ::= expCaseBlockList + { + astNode RESULT =null; + int ecblleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int ecblright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + ArrayList ecbl = (ArrayList)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + astSwitch as = new astSwitch(); + as.setCaseConditions(ecbl); + RESULT = as; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expSwitchBlockList",45, ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 131: // expSwitchBlockList ::= expCaseBlockList expDefault + { + astNode RESULT =null; + int ecblleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).left; + int ecblright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).right; + ArrayList ecbl = (ArrayList)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-1)).value; + int edleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int edright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astStatementList ed = (astStatementList)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + astSwitch as = new astSwitch(); + as.setCaseConditions(ecbl); + as.setDefaultList(ed); + RESULT = as; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expSwitchBlockList",45, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 132: // expCaseBlockList ::= expCaseBlock + { + ArrayList RESULT =null; + int ecbleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int ecbright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode ecb = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + ArrayList list = new ArrayList(); + list.add(ecb); + RESULT = list; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expCaseBlockList",46, ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 133: // expCaseBlockList ::= expCaseBlockList expCaseBlock + { + ArrayList RESULT =null; + int ecblleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).left; + int ecblright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).right; + ArrayList ecbl = (ArrayList)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-1)).value; + int ecbleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int ecbright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode ecb = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + ecbl.add(ecb); + RESULT = ecbl; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expCaseBlockList",46, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 134: // expCaseBlock ::= CASE expression COLON LBRACKET instructionList RBRACKET + { + astNode RESULT =null; + int eleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-4)).left; + int eright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-4)).right; + astNode e = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-4)).value; + int illeft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).left; + int ilright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).right; + astStatementList il = (astStatementList)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-1)).value; + + astConditionBlock acb = new astConditionBlock(); + acb.setParserInfo(this.parser.fileName, eleft, eright); + acb.setExpression(e); + acb.setInstructionList(il); + RESULT = acb; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expCaseBlock",47, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-5)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 135: // expCaseBlock ::= CASE expression COLON LBRACKET RBRACKET + { + astNode RESULT =null; + int eleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-3)).left; + int eright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-3)).right; + astNode e = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-3)).value; + + astConditionBlock acb = new astConditionBlock(); + acb.setParserInfo(this.parser.fileName, eleft, eright); + acb.setExpression(e); + RESULT = acb; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expCaseBlock",47, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-4)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 136: // expDefault ::= DEFAULT COLON LBRACKET instructionList RBRACKET + { + astStatementList RESULT =null; + int illeft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).left; + int ilright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).right; + astStatementList il = (astStatementList)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-1)).value; + + RESULT = il; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expDefault",48, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-4)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 137: // expDefault ::= DEFAULT COLON LBRACKET RBRACKET + { + astStatementList RESULT =null; + + astStatementList list = new astStatementList(); + RESULT = list; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expDefault",48, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-3)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 138: // expWhile ::= WHILE LPAREN expression RPAREN LBRACKET instructionList RBRACKET + { + astNode RESULT =null; + int eleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-4)).left; + int eright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-4)).right; + astNode e = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-4)).value; + int illeft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).left; + int ilright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).right; + astStatementList il = (astStatementList)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-1)).value; + + astWhile aw = new astWhile(); + aw.setParserInfo(this.parser.fileName, eleft, eright); + aw.setExpr(e); + aw.setInstructions(il); + RESULT = aw; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expWhile",49, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-6)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 139: // expWhile ::= WHILE LPAREN expression RPAREN LBRACKET RBRACKET + { + astNode RESULT =null; + int eleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-3)).left; + int eright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-3)).right; + astNode e = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-3)).value; + + astWhile aw = new astWhile(); + aw.setParserInfo(this.parser.fileName, eleft, eright); + aw.setExpr(e); + RESULT = aw; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expWhile",49, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-5)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 140: // expFor ::= FOR LPAREN expForExp SEMI expForExp SEMI expForExp RPAREN LBRACKET instructionList RBRACKET + { + astNode RESULT =null; + int fleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-10)).left; + int fright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-10)).right; + Object f = (Object)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-10)).value; + int einitleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-8)).left; + int einitright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-8)).right; + astNode einit = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-8)).value; + int econdleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-6)).left; + int econdright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-6)).right; + astNode econd = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-6)).value; + int eincrleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-4)).left; + int eincrright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-4)).right; + astNode eincr = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-4)).value; + int illeft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).left; + int ilright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).right; + astStatementList il = (astStatementList)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-1)).value; + + astFor af = new astFor(); + af.setParserInfo(this.parser.fileName, fleft, fright); + af.setExprInit(einit); + af.setExprCond(econd); + af.setExprInc(eincr); + af.setInstructions(il); + RESULT = af; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expFor",51, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-10)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 141: // expFor ::= FOR LPAREN expForExp SEMI expForExp SEMI expForExp RPAREN LBRACKET RBRACKET + { + astNode RESULT =null; + int fleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-9)).left; + int fright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-9)).right; + Object f = (Object)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-9)).value; + int einitleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-7)).left; + int einitright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-7)).right; + astNode einit = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-7)).value; + int econdleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-5)).left; + int econdright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-5)).right; + astNode econd = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-5)).value; + int eincrleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-3)).left; + int eincrright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-3)).right; + astNode eincr = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-3)).value; + + astFor af = new astFor(); + af.setParserInfo(this.parser.fileName, fleft, fright); + af.setExprInit(einit); + af.setExprCond(econd); + af.setExprInc(eincr); + RESULT = af; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expFor",51, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-9)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 142: // expFor ::= FOR LPAREN expVar COLON expression RPAREN LBRACKET instructionList RBRACKET + { + astNode RESULT =null; + int fleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-8)).left; + int fright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-8)).right; + Object f = (Object)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-8)).value; + int evleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-6)).left; + int evright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-6)).right; + astNode ev = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-6)).value; + int erleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-4)).left; + int erright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-4)).right; + astNode er = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-4)).value; + int illeft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).left; + int ilright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).right; + astStatementList il = (astStatementList)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-1)).value; + + astFor af = new astFor(); + af.setParserInfo(this.parser.fileName, fleft, fright); + af.setIsForEach(true); + af.setEachVar(ev); + af.setEachExpr(er); + af.setInstructions(il); + RESULT = af; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expFor",51, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-8)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 143: // expFor ::= FOR LPAREN expVar COLON expression RPAREN LBRACKET RBRACKET + { + astNode RESULT =null; + int fleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-7)).left; + int fright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-7)).right; + Object f = (Object)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-7)).value; + int evleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-5)).left; + int evright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-5)).right; + astNode ev = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-5)).value; + int erleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-3)).left; + int erright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-3)).right; + astNode er = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-3)).value; + + astFor af = new astFor(); + af.setParserInfo(this.parser.fileName, fleft, fright); + af.setIsForEach(true); + af.setEachVar(ev); + af.setEachExpr(er); + RESULT = af; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expFor",51, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-7)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 144: // expForExp ::= + { + astNode RESULT =null; + + RESULT = new astNull(); + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expForExp",52, ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 145: // expForExp ::= expression + { + astNode RESULT =null; + int eleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int eright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode e = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + RESULT = e; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expForExp",52, ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 146: // functCallArgList ::= + { + ArrayList RESULT =null; + + ArrayList al = new ArrayList(); + RESULT = al; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("functCallArgList",26, ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 147: // functCallArgList ::= expression + { + ArrayList RESULT =null; + int eleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int eright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode e = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + ArrayList al = new ArrayList(); + al.add(e); + RESULT = al; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("functCallArgList",26, ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 148: // functCallArgList ::= functCallArgList COMMA expression + { + ArrayList RESULT =null; + int alleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).left; + int alright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).right; + ArrayList al = (ArrayList)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-2)).value; + int eleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int eright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode e = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + al.add(e); + RESULT = al; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("functCallArgList",26, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 149: // AccessType ::= + { + AccessType RESULT =null; + + RESULT = AccessType.aPrivate; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("AccessType",6, ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 150: // AccessType ::= PUBLIC + { + AccessType RESULT =null; + + RESULT = AccessType.aPublic; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("AccessType",6, ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 151: // AccessType ::= PROTECTED + { + AccessType RESULT =null; + + RESULT = AccessType.aProtected; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("AccessType",6, ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 152: // AccessType ::= PRIVATE + { + AccessType RESULT =null; + + RESULT = AccessType.aPrivate; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("AccessType",6, ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 153: // expNull ::= NULL + { + astNode RESULT =null; + int nleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int nright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + Object n = (Object)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + astNull an = new astNull(); + an.setParserInfo(this.parser.fileName, nleft, nright); + RESULT = an; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expNull",27, ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 154: // expBool ::= BOOL + { + astNode RESULT =null; + int bleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int bright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + Boolean b = (Boolean)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + astBool ab = new astBool(b); + ab.setParserInfo(this.parser.fileName, bleft, bright); + RESULT = ab; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expBool",28, ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 155: // expInt ::= INT + { + astNode RESULT =null; + int ileft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int iright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + BigInteger i = (BigInteger)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + BigInteger val = i; + if(val.compareTo(new BigInteger(String.valueOf(Long.MAX_VALUE))) == 1) + { + astNode n = new astNode(); + n.setParserInfo(this.parser.fileName, ileft, iright); + throw new caliException(n, "PARSE_ERROR: Integer out of bounds. Integer max size is " + String.valueOf(Long.MAX_VALUE) + ". <" + val.toString() + ">", ""); + } + + astInt ai = new astInt(i.longValue()); + ai.setParserInfo(this.parser.fileName, ileft, iright); + RESULT = ai; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expInt",29, ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 156: // expInt ::= MI INT + { + astNode RESULT =null; + int ileft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int iright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + BigInteger i = (BigInteger)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + BigInteger val = i.multiply(new BigInteger("-1")); + if(val.compareTo(new BigInteger(String.valueOf(Long.MIN_VALUE))) == -1) + { + astNode n = new astNode(); + n.setParserInfo(this.parser.fileName, ileft, iright); + throw new caliException(n, "PARSE_ERROR: Integer out of bounds. Integer min size is " + String.valueOf(Long.MIN_VALUE) + ". <" + val.toString() + ">", ""); + } + + astInt ai = new astInt(val.longValue()); + ai.setParserInfo(this.parser.fileName, ileft, iright); + RESULT = ai; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expInt",29, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 157: // expDouble ::= DOUBLE + { + astNode RESULT =null; + int dleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int dright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + BigDecimal d = (BigDecimal)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + BigDecimal val = d; + if(val.compareTo(new BigDecimal(Double.MAX_VALUE)) == 1) + { + astNode n = new astNode(); + n.setParserInfo(this.parser.fileName, dleft, dright); + throw new caliException(n, "PARSE_ERROR: Double out of bounds. Double max size is " + String.valueOf(Double.MAX_VALUE) + ". <" + val.toString() + ">", ""); + } + + astDouble ad = new astDouble(d.doubleValue()); + ad.setParserInfo(this.parser.fileName, dleft, dright); + RESULT = ad; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expDouble",30, ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 158: // expDouble ::= MI DOUBLE + { + astNode RESULT =null; + int dleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int dright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + BigDecimal d = (BigDecimal)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + BigDecimal val = d.multiply(new BigDecimal("-1.0")); + if(val.compareTo(new BigDecimal(-Double.MAX_VALUE)) == -1) + { + astNode n = new astNode(); + n.setParserInfo(this.parser.fileName, dleft, dright); + throw new caliException(n, "PARSE_ERROR: Double out of bounds. Double min size is " + String.valueOf(Double.MIN_NORMAL) + ". <" + val.toString() + ">", ""); + } + + astDouble ad = new astDouble(val.doubleValue()); + ad.setParserInfo(this.parser.fileName, dleft, dright); + RESULT = ad; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expDouble",30, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 159: // expString ::= STRING + { + astNode RESULT =null; + int sleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int sright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + String s = (String)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + astString as = new astString(s); + as.setParserInfo(this.parser.fileName, sleft, sright); + RESULT = as; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expString",31, ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 160: // expList ::= LBRACE expListItems RBRACE + { + astNode RESULT =null; + int lleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).left; + int lright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).right; + ArrayList l = (ArrayList)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-1)).value; + + astList al = new astList(l); + al.setParserInfo(this.parser.fileName, lleft, lright); + RESULT = (astNode)al; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expList",32, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 161: // expList ::= LBRACE RBRACE + { + astNode RESULT =null; + int lleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).left; + int lright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).right; + Object l = (Object)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-1)).value; + + astList al = new astList(); + al.setParserInfo(this.parser.fileName, lleft, lright); + RESULT = (astNode)al; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expList",32, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 162: // expListItems ::= expListIndividual + { + ArrayList RESULT =null; + int ileft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int iright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode i = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + ArrayList l = new ArrayList(); + l.add(i); + RESULT = l; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expListItems",33, ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 163: // expListItems ::= expListItems COMMA expListIndividual + { + ArrayList RESULT =null; + int lleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).left; + int lright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).right; + ArrayList l = (ArrayList)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-2)).value; + int ileft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int iright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode i = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + l.add(i); + RESULT = l; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expListItems",33, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 164: // expListIndividual ::= expBool + { + astNode RESULT =null; + int bleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int bright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode b = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + RESULT = b; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expListIndividual",34, ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 165: // expListIndividual ::= expInt + { + astNode RESULT =null; + int ileft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int iright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode i = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + RESULT = i; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expListIndividual",34, ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 166: // expListIndividual ::= expDouble + { + astNode RESULT =null; + int dleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int dright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode d = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + RESULT = d; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expListIndividual",34, ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 167: // expListIndividual ::= expString + { + astNode RESULT =null; + int sleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int sright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode s = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + RESULT = s; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expListIndividual",34, ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 168: // expListIndividual ::= expList + { + astNode RESULT =null; + int lleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int lright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode l = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + RESULT = l; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expListIndividual",34, ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 169: // expListIndividual ::= expMap + { + astNode RESULT =null; + int dleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int dright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode d = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + RESULT = d; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expListIndividual",34, ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 170: // expMap ::= LBRACKET expMapItems RBRACKET + { + astNode RESULT =null; + int dleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).left; + int dright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).right; + Map d = (Map)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-1)).value; + + astMap ad = new astMap(d); + ad.setParserInfo(this.parser.fileName, dleft, dright); + RESULT = (astNode)ad; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expMap",35, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 171: // expMap ::= LBRACKET RBRACKET + { + astNode RESULT =null; + int mleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).left; + int mright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).right; + Object m = (Object)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-1)).value; + + astMap am = new astMap(); + am.setParserInfo(this.parser.fileName, mleft, mright); + RESULT = (astNode)am; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expMap",35, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 172: // expMapItems ::= expString COLON expListIndividual + { + Map RESULT =null; + int sleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).left; + int sright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).right; + astNode s = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-2)).value; + int ileft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int iright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode i = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + Map d = new ConcurrentHashMap(); + d.put(s, i); + RESULT = d; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expMapItems",36, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 173: // expMapItems ::= expVar COLON expListIndividual + { + Map RESULT =null; + int vleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).left; + int vright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).right; + astNode v = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-2)).value; + int ileft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int iright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode i = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + Map d = new ConcurrentHashMap(); + d.put(v, i); + RESULT = d; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expMapItems",36, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 174: // expMapItems ::= expMapItems COMMA expString COLON expListIndividual + { + Map RESULT =null; + int dleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-4)).left; + int dright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-4)).right; + Map d = (Map)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-4)).value; + int sleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).left; + int sright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).right; + astNode s = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-2)).value; + int ileft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int iright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode i = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + d.put(s, i); + RESULT = d; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expMapItems",36, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-4)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 175: // expMapItems ::= expMapItems COMMA expVar COLON expListIndividual + { + Map RESULT =null; + int dleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-4)).left; + int dright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-4)).right; + Map d = (Map)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-4)).value; + int vleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).left; + int vright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).right; + astNode v = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-2)).value; + int ileft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int iright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode i = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + d.put(v, i); + RESULT = d; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expMapItems",36, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-4)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 176: // expVar ::= IDENT + { + astNode RESULT =null; + int sleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int sright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + String s = (String)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + astVar av = new astVar(); + av.setParserInfo(this.parser.fileName, sleft, sright); + av.setName(s); + RESULT = av; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expVar",37, ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 177: // expFunctDef ::= IDENT + { + astNode RESULT =null; + int sleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int sright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + String s = (String)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + astFunctDef afd = new astFunctDef(s); + afd.setParserInfo(this.parser.fileName, sleft, sright); + RESULT = (astNode)afd; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expFunctDef",38, ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 178: // expBreak ::= BREAK + { + astNode RESULT =null; + int bleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int bright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + Object b = (Object)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + astBreak ab = new astBreak(); + ab.setParserInfo(this.parser.fileName, bleft, bright); + RESULT = ab; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expBreak",50, ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 179: // expEtcetera ::= ETCETERA + { + astNode RESULT =null; + int eleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int eright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + Object e = (Object)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + astEtcetera etc = new astEtcetera(); + etc.setParserInfo(this.parser.fileName, eleft, eright); + RESULT = etc; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expEtcetera",53, ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 180: // expCallback ::= CALLBACK IDENT + { + astNode RESULT =null; + int cleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).left; + int cright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).right; + Object c = (Object)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-1)).value; + int sleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int sright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + String s = (String)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + astCallback cb = new astCallback(s); + cb.setParserInfo(this.parser.fileName, cleft, cright); + RESULT = cb; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expCallback",54, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 181: // expNewList ::= LBRACE expNewListItems RBRACE + { + astNode RESULT =null; + int elleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).left; + int elright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).right; + astList el = (astList)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-1)).value; + + RESULT = el; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expNewList",55, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 182: // expNewListItems ::= + { + astList RESULT =null; + + RESULT = new astList(); + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expNewListItems",56, ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 183: // expNewListItems ::= expression + { + astList RESULT =null; + int elleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int elright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode el = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + astList al = new astList(); + al.add(el); + RESULT = al; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expNewListItems",56, ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 184: // expNewListItems ::= expNewListItems COMMA expression + { + astList RESULT =null; + int nlleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).left; + int nlright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).right; + astList nl = (astList)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-2)).value; + int elleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int elright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode el = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + nl.add(el); + RESULT = nl; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expNewListItems",56, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 185: // expNewMap ::= LBRACKET expNewMapItems RBRACKET + { + astNode RESULT =null; + int emleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).left; + int emright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).right; + astMap em = (astMap)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-1)).value; + + RESULT = em; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expNewMap",57, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 186: // expNewMapItems ::= + { + astMap RESULT =null; + + RESULT = new astMap(); + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expNewMapItems",58, ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 187: // expNewMapItems ::= expression COLON expression + { + astMap RESULT =null; + int elleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).left; + int elright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).right; + astNode el = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-2)).value; + int erleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int erright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode er = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + astMap am = new astMap(); + am.setParserInfo(this.parser.fileName, elleft, elright); + am.add(el, er); + RESULT = am; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expNewMapItems",58, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 188: // expNewMapItems ::= expNewMapItems COMMA expression COLON expression + { + astMap RESULT =null; + int amleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-4)).left; + int amright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-4)).right; + astMap am = (astMap)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-4)).value; + int elleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).left; + int elright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-2)).right; + astNode el = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-2)).value; + int erleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int erright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode er = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + am.add(el, er); + RESULT = am; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expNewMapItems",58, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-4)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 189: // expThrow ::= THROW expression + { + astNode RESULT =null; + int tleft = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).left; + int tright = ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)).right; + Object t = (Object)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-1)).value; + int eleft = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).left; + int eright = ((java_cup.runtime.Symbol)CUP$parser$stack.peek()).right; + astNode e = (astNode)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + + astThrow at = new astThrow(); + at.setParserInfo(this.parser.fileName, tleft, tright); + at.setExpression(e); + RESULT = at; + + CUP$parser$result = parser.getSymbolFactory().newSymbol("expThrow",59, ((java_cup.runtime.Symbol)CUP$parser$stack.elementAt(CUP$parser$top-1)), ((java_cup.runtime.Symbol)CUP$parser$stack.peek()), RESULT); + } + return CUP$parser$result; + + /* . . . . . .*/ + default: + throw new Exception( + "Invalid action number "+CUP$parser$act_num+"found in internal parse table"); + + } + } /* end of method */ + + /** Method splitting the generated action code into several parts. */ + public final java_cup.runtime.Symbol CUP$parser$do_action( + int CUP$parser$act_num, + java_cup.runtime.lr_parser CUP$parser$parser, + java.util.Stack CUP$parser$stack, + int CUP$parser$top) + throws java.lang.Exception + { + return CUP$parser$do_action_part00000000( + CUP$parser$act_num, + CUP$parser$parser, + CUP$parser$stack, + CUP$parser$top); + } +} + diff --git a/cali.lang.base/src/com/cali/stdlib/CBuffer.java b/cali.lang.base/src/com/cali/stdlib/CBuffer.java new file mode 100644 index 0000000..106ba62 --- /dev/null +++ b/cali.lang.base/src/com/cali/stdlib/CBuffer.java @@ -0,0 +1,1044 @@ +/* + * Copyright 2017 Austin Lehman + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.cali.stdlib; + +import java.io.UnsupportedEncodingException; +import java.nio.ByteBuffer; +import java.nio.ByteOrder; +import java.nio.charset.Charset; +import java.util.ArrayList; +import java.util.Arrays; + +import com.cali.ast.caliException; +import com.cali.types.CaliType; +import com.cali.types.CaliNull; +import com.cali.types.CaliObject; +import com.cali.types.CaliInt; +import com.cali.types.CaliDouble; +import com.cali.types.CaliString; +import com.cali.types.CaliException; + + +public class CBuffer { + private int writeCursor = 0; + private int readCursor = 0; + + public enum byteOrder { + BIG, + LITTLE + } + + protected byte[] buff = null; + + public CBuffer() { this.buff = new byte[1024]; } + + public void newBuffer(int Size) { this.buff = new byte[Size]; } + + public byte[] getBuffer() { return this.buff; } + public void setBuffer(byte[] Buff) { this.buff = Buff; } + + public CaliType newBuffer(ArrayList args) { + synchronized(this) { + this.buff = new byte[(int)((CaliInt)args.get(0)).getValue()]; + return new CaliNull(); + } + } + + public CaliType size(ArrayList args) { + return new CaliInt(this.buff.length); + } + + public CaliType _clear(ArrayList args) { + synchronized(this) { + byte b = 0; + Arrays.fill(this.buff, b); + this.readCursor = 0; + this.writeCursor = 0; + return new CaliNull(); + } + } + + public CaliType _writeSeek(ArrayList args) { + synchronized(this) { + int index = (int)((CaliInt)args.get(0)).getValue(); + if((index >= 0)&&(index < buff.length)) { + this.writeCursor = index; + } else { + return new CaliException("buffer.writeSeek(): Index out of bounds."); + } + return new CaliNull(); + } + } + + public CaliType _readSeek(ArrayList args) { + synchronized(this) { + int index = (int)((CaliInt)args.get(0)).getValue(); + if((index >= 0)&&(index < buff.length)) { + this.readCursor = index; + } else { + return new CaliException("buffer.readSeek(): Index out of bounds."); + } + return new CaliNull(); + } + } + + public CaliType _addString(ArrayList args) throws caliException { + synchronized(this) { + String str = ((CaliString)args.get(0)).getValueString(); + String cset = ((CaliString)args.get(1)).getValueString(); + this._setStringAt(this.writeCursor, str, cset); + this.writeCursor += str.getBytes().length; + return new CaliNull(); + } + } + + public CaliType _addByte(ArrayList args) throws caliException { + synchronized(this) { + int index = this.writeCursor; + int ival = (int)((CaliInt)args.get(0)).getValue(); + this.setByte(index, ival); this.writeCursor++; + return new CaliNull(); + } + } + + public CaliType _addUByte(ArrayList args) throws caliException { + synchronized(this) { + int index = this.writeCursor; + int ival = (int)((CaliInt)args.get(0)).getValue(); + this.setUByte(index, ival); this.writeCursor++; + return new CaliNull(); + } + } + + public CaliType _addShort(ArrayList args) throws caliException { + synchronized(this) { + int index = this.writeCursor; + short ival = (short)((CaliInt)args.get(0)).getValue(); + byteOrder bo = this.getByteOrder(((CaliString)args.get(1)).getValueString()); + this.setShort(index, ival, bo); this.writeCursor += 2; + return new CaliNull(); + } + } + + public CaliType _addUShort(ArrayList args) throws caliException { + synchronized(this) { + int index = this.writeCursor; + int ival = (short)((CaliInt)args.get(0)).getValue(); + byteOrder bo = this.getByteOrder(((CaliString)args.get(1)).getValueString()); + this.setUShort(index, ival, bo); this.writeCursor += 2; + return new CaliNull(); + } + } + + public CaliType _addInt(ArrayList args) throws caliException { + synchronized(this) { + int index = this.writeCursor; + int ival = (int)((CaliInt)args.get(0)).getValue(); + byteOrder bo = this.getByteOrder(((CaliString)args.get(1)).getValueString()); + this.setInt(index, ival, bo); this.writeCursor += 4; + return new CaliNull(); + } + } + + public CaliType _addUInt(ArrayList args) throws caliException { + synchronized(this) { + int index = this.writeCursor; + long ival = ((CaliInt)args.get(0)).getValue(); + byteOrder bo = this.getByteOrder(((CaliString)args.get(1)).getValueString()); + this.setUInt(index, ival, bo); this.writeCursor += 4; + return new CaliNull(); + } + } + + public CaliType _addLong(ArrayList args) throws caliException { + synchronized(this) { + int index = this.writeCursor; + long ival = ((CaliInt)args.get(0)).getValue(); + byteOrder bo = this.getByteOrder(((CaliString)args.get(1)).getValueString()); + this.setLong(index, ival, bo); this.writeCursor += 8; + return new CaliNull(); + } + } + + public CaliType _addFloat(ArrayList args) throws caliException { + synchronized(this) { + int index = this.writeCursor; + double tval = ((CaliDouble)args.get(0)).getValue(); + byteOrder bo = this.getByteOrder(((CaliString)args.get(1)).getValueString()); + this.setFloat(index, tval, bo); this.writeCursor += 4; + return new CaliNull(); + } + } + + public CaliType _addDouble(ArrayList args) throws caliException { + synchronized(this) { + int index = this.writeCursor; + double tval = ((CaliDouble)args.get(0)).getValue(); + byteOrder bo = this.getByteOrder(((CaliString)args.get(1)).getValueString()); + this.setDouble(index, tval, bo); this.writeCursor += 8; + return new CaliNull(); + } + } + + public CaliType getWriteCursor(ArrayList args) { + return new CaliInt(this.writeCursor); + } + + public CaliType getReadCursor(ArrayList args) { + return new CaliInt(this.readCursor); + } + + public CaliType getString(ArrayList args) throws caliException { + return new CaliString(this._getString(((CaliString)args.get(0)).getValueString())); + } + + public CaliType getStringAt(ArrayList args) throws caliException { + int index = (int) ((CaliInt)args.get(1)).getValue(); + int length = (int) ((CaliInt)args.get(0)).getValue(); + String cset = ((CaliString)args.get(2)).getValueString(); + boolean increment = false; + if(index < 0) { index = this.readCursor; increment = true; } + String val = this._getStringAt(index, length, cset); + if(increment) this.readCursor += length; + return new CaliString(val); + } + + public CaliType getByte(ArrayList args) throws caliException { + int index = (int)((CaliInt)args.get(0)).getValue(); + boolean increment = false; + if(index < 0) { index = this.readCursor; increment = true; } + int val = this._getByte(index); + if(increment) this.readCursor++; + return new CaliInt(val); + } + + public CaliType getUByte(ArrayList args) throws caliException { + int index = (int)((CaliInt)args.get(0)).getValue(); + boolean increment = false; + if(index < 0) { index = this.readCursor; increment = true; } + int val = this._getUByte(index); + if(increment) this.readCursor++; + return new CaliInt(val); + } + + public CaliType getShort(ArrayList args) throws caliException { + int index = (int)((CaliInt)args.get(0)).getValue(); + byteOrder bo = this.getByteOrder(((CaliString)args.get(1)).getValueString()); + boolean increment = false; + if(index < 0) { index = this.readCursor; increment = true; } + int val = this._getShort(index, bo); + if(increment) this.readCursor += 2; + return new CaliInt(val); + } + + public CaliType getUShort(ArrayList args) throws caliException { + int index = (int)((CaliInt)args.get(0)).getValue(); + byteOrder bo = this.getByteOrder(((CaliString)args.get(1)).getValueString()); + boolean increment = false; + if(index < 0) { index = this.readCursor; increment = true; } + int val = this._getUShort(index, bo); + if(increment) this.readCursor += 2; + return new CaliInt(val); + } + + public CaliType getInt(ArrayList args) throws caliException { + int index = (int)((CaliInt)args.get(0)).getValue(); + byteOrder bo = this.getByteOrder(((CaliString)args.get(1)).getValueString()); + boolean increment = false; + if(index < 0) { index = this.readCursor; increment = true; } + int val = this._getInt(index, bo); + if(increment) this.readCursor += 4; + return new CaliInt(val); + } + + public CaliType getUInt(ArrayList args) throws caliException { + int index = (int)((CaliInt)args.get(0)).getValue(); + byteOrder bo = this.getByteOrder(((CaliString)args.get(1)).getValueString()); + boolean increment = false; + if(index < 0) { index = this.readCursor; increment = true; } + long val = this._getUInt(index, bo); + if(increment) this.readCursor += 4; + return new CaliInt(val); + } + + public CaliType getLong(ArrayList args) throws caliException { + int index = (int)((CaliInt)args.get(0)).getValue(); + byteOrder bo = this.getByteOrder(((CaliString)args.get(1)).getValueString()); + boolean increment = false; + if(index < 0) { index = this.readCursor; increment = true; } + long val = this._getLong(index, bo); + if(increment) this.readCursor += 8; + return new CaliInt(val); + } + + public CaliType getFloat(ArrayList args) throws caliException { + int index = (int)((CaliInt)args.get(0)).getValue(); + byteOrder bo = this.getByteOrder(((CaliString)args.get(1)).getValueString()); + boolean increment = false; + if(index < 0) { index = this.readCursor; increment = true; } + double val = this._getFloat(index, bo); + if(increment) this.readCursor += 4; + return new CaliDouble(val); + } + + public CaliType getDouble(ArrayList args) throws caliException { + int index = (int)((CaliInt)args.get(0)).getValue(); + byteOrder bo = this.getByteOrder(((CaliString)args.get(1)).getValueString()); + boolean increment = false; + if(index < 0) { index = this.readCursor; increment = true; } + double val = this._getDouble(index, bo); + if(increment) this.readCursor += 4; + return new CaliDouble(val); + } + + public CaliType setString(ArrayList args) throws caliException { + synchronized(this) { + String str = ((CaliString)args.get(0)).getValueString(); + String cset = ((CaliString)args.get(1)).getValueString(); + return new CaliInt(this._setString(str, cset)); + } + } + + public CaliType setStringAt(ArrayList args) throws caliException { + synchronized(this) { + int index = (int) ((CaliInt)args.get(0)).getValue(); + String str = ((CaliString)args.get(1)).getValueString(); + String cset = ((CaliString)args.get(2)).getValueString(); + return new CaliInt(this._setStringAt(index, str, cset)); + } + } + + public CaliType _setByte(ArrayList args) throws caliException { + synchronized(this) { + int index = (int)((CaliInt)args.get(0)).getValue(); + int ival = (int)((CaliInt)args.get(1)).getValue(); + this.setByte(index, ival); + return new CaliNull(); + } + } + + public CaliType _setUByte(ArrayList args) throws caliException { + synchronized(this) { + int index = (int)((CaliInt)args.get(0)).getValue(); + int ival = (int)((CaliInt)args.get(1)).getValue(); + this.setUByte(index, ival); + return new CaliNull(); + } + } + + public CaliType _setShort(ArrayList args) throws caliException { + synchronized(this) { + int index = (int)((CaliInt)args.get(0)).getValue(); + short ival = (short)((CaliInt)args.get(1)).getValue(); + byteOrder bo = this.getByteOrder(((CaliString)args.get(2)).getValueString()); + this.setShort(index, ival, bo); + return new CaliNull(); + } + } + + public CaliType _setUShort(ArrayList args) throws caliException { + synchronized(this) { + int index = (int)((CaliInt)args.get(0)).getValue(); + int ival = (short)((CaliInt)args.get(1)).getValue(); + byteOrder bo = this.getByteOrder(((CaliString)args.get(2)).getValueString()); + this.setUShort(index, ival, bo); + return new CaliNull(); + } + } + + public CaliType _setInt(ArrayList args) throws caliException { + synchronized(this) { + int index = (int)((CaliInt)args.get(0)).getValue(); + int ival = (int)((CaliInt)args.get(1)).getValue(); + byteOrder bo = this.getByteOrder(((CaliString)args.get(2)).getValueString()); + this.setInt(index, ival, bo); + return new CaliNull(); + } + } + + public CaliType _setUInt(ArrayList args) throws caliException { + synchronized(this) { + int index = (int)((CaliInt)args.get(0)).getValue(); + long ival = ((CaliInt)args.get(1)).getValue(); + byteOrder bo = this.getByteOrder(((CaliString)args.get(2)).getValueString()); + this.setUInt(index, ival, bo); + return new CaliNull(); + } + } + + public CaliType _setLong(ArrayList args) throws caliException { + synchronized(this) { + int index = (int)((CaliInt)args.get(0)).getValue(); + long ival = ((CaliInt)args.get(1)).getValue(); + byteOrder bo = this.getByteOrder(((CaliString)args.get(2)).getValueString()); + this.setLong(index, ival, bo); + return new CaliNull(); + } + } + + public CaliType _setFloat(ArrayList args) throws caliException { + synchronized(this) { + int index = (int)((CaliInt)args.get(0)).getValue(); + double tval = ((CaliDouble)args.get(1)).getValue(); + byteOrder bo = this.getByteOrder(((CaliString)args.get(2)).getValueString()); + this.setFloat(index, tval, bo); + return new CaliNull(); + } + } + + public CaliType _setDouble(ArrayList args) throws caliException { + synchronized(this) { + int index = (int)((CaliInt)args.get(0)).getValue(); + double tval = ((CaliDouble)args.get(1)).getValue(); + byteOrder bo = this.getByteOrder(((CaliString)args.get(2)).getValueString()); + this.setDouble(index, tval, bo); + return new CaliNull(); + } + } + + public CaliType byteToBinary(ArrayList args) { + int index = (int)((CaliInt)args.get(0)).getValue(); + if((index >= 0)&&(index < buff.length)) { + String bin = Integer.toBinaryString((this.buff[index] + 256) % 256); + while(bin.length() < 8) bin = "0" + bin; + return new CaliString(bin); + } else { + return new CaliException("buffer.byteToBinary(): Index out of bounds."); + } + } + + public CaliType shortToBinary(ArrayList args) { + int index = (int)((CaliInt)args.get(0)).getValue(); + byteOrder bo = this.getByteOrder(((CaliString)args.get(1)).getValueString()); + + if((index >= 0)&&(index < buff.length + 1)) { + String bin1 = Integer.toBinaryString((this.buff[index] + 256) % 256); + while(bin1.length() < 8) bin1 = "0" + bin1; + String bin2 = Integer.toBinaryString((this.buff[index + 1] + 256) % 256); + while(bin2.length() < 8) bin2 = "0" + bin2; + + if(bo == byteOrder.BIG) { + return new CaliString(bin1 + bin2); + } else { + return new CaliString(bin2 + bin1); + } + } else { + return new CaliException("buffer.shortToBinary(): Index out of bounds."); + } + } + + public CaliType intToBinary(ArrayList args) { + int index = (int)((CaliInt)args.get(0)).getValue(); + byteOrder bo = this.getByteOrder(((CaliString)args.get(1)).getValueString()); + + if((index >= 0)&&(index < buff.length + 3)) { + String bin1 = Integer.toBinaryString((this.buff[index] + 256) % 256); + while(bin1.length() < 8) bin1 = "0" + bin1; + String bin2 = Integer.toBinaryString((this.buff[index + 1] + 256) % 256); + while(bin2.length() < 8) bin2 = "0" + bin2; + String bin3 = Integer.toBinaryString((this.buff[index + 2] + 256) % 256); + while(bin3.length() < 8) bin3 = "0" + bin3; + String bin4 = Integer.toBinaryString((this.buff[index + 3] + 256) % 256); + while(bin4.length() < 8) bin4 = "0" + bin4; + + if(bo == byteOrder.BIG) { + return new CaliString(bin1 + bin2 + bin3 + bin4); + } else { + return new CaliString(bin4 + bin3 + bin2 + bin1); + } + } else { + return new CaliException("buffer.intToBinary(): Index out of bounds."); + } + } + + public CaliType longToBinary(ArrayList args) { + int index = (int)((CaliInt)args.get(0)).getValue(); + byteOrder bo = this.getByteOrder(((CaliString)args.get(1)).getValueString()); + + if((index >= 0)&&(index < buff.length + 7)) { + String bin1 = Integer.toBinaryString((this.buff[index] + 256) % 256); + while(bin1.length() < 8) { + bin1 = "0" + bin1; + } + String bin2 = Integer.toBinaryString((this.buff[index + 1] + 256) % 256); + while(bin2.length() < 8) { + bin2 = "0" + bin2; + } + String bin3 = Integer.toBinaryString((this.buff[index + 2] + 256) % 256); + while(bin3.length() < 8) { + bin3 = "0" + bin3; + } + String bin4 = Integer.toBinaryString((this.buff[index + 3] + 256) % 256); + while(bin4.length() < 8) { + bin4 = "0" + bin4; + } + String bin5 = Integer.toBinaryString((this.buff[index + 4] + 256) % 256); + while(bin5.length() < 8) { + bin5 = "0" + bin5; + } + String bin6 = Integer.toBinaryString((this.buff[index + 5] + 256) % 256); + while(bin6.length() < 8) { + bin6 = "0" + bin6; + } + String bin7 = Integer.toBinaryString((this.buff[index + 6] + 256) % 256); + while(bin7.length() < 8) { + bin7 = "0" + bin7; + } + String bin8 = Integer.toBinaryString((this.buff[index + 7] + 256) % 256); + while(bin8.length() < 8) { + bin8 = "0" + bin8; + } + + if(bo == byteOrder.BIG) { + return new CaliString(bin1 + bin2 + bin3 + bin4 + bin5 + bin6 + bin7 + bin8); + } else { + return new CaliString(bin8 + bin7 + bin6 + bin5 + bin4 + bin3 + bin2 + bin1); + } + } else { + return new CaliException("buffer.longToBinary(): Index out of bounds."); + } + } + + public CaliType floatToBinary(ArrayList args) { + int index = (int)((CaliInt)args.get(0)).getValue(); + byteOrder bo = this.getByteOrder(((CaliString)args.get(1)).getValueString()); + + if((index >= 0)&&(index < buff.length + 3)) { + String bin1 = Integer.toBinaryString((this.buff[index] + 256) % 256); + while(bin1.length() < 8) { + bin1 = "0" + bin1; + } + String bin2 = Integer.toBinaryString((this.buff[index + 1] + 256) % 256); + while(bin2.length() < 8) { + bin2 = "0" + bin2; + } + String bin3 = Integer.toBinaryString((this.buff[index + 2] + 256) % 256); + while(bin3.length() < 8) { + bin3 = "0" + bin3; + } + String bin4 = Integer.toBinaryString((this.buff[index + 3] + 256) % 256); + while(bin4.length() < 8) { + bin4 = "0" + bin4; + } + + if(bo == byteOrder.BIG) { + return new CaliString(bin1 + bin2 + bin3 + bin4); + } else { + return new CaliString(bin4 + bin3 + bin2 + bin1); + } + } else { + return new CaliException("buffer.intToBinary(): Index out of bounds."); + } + } + + public CaliType doubleToBinary(ArrayList args) { + int index = (int)((CaliInt)args.get(0)).getValue(); + byteOrder bo = this.getByteOrder(((CaliString)args.get(1)).getValueString()); + + if((index >= 0)&&(index < buff.length + 7)) { + String bin1 = Integer.toBinaryString((this.buff[index] + 256) % 256); + while(bin1.length() < 8) { + bin1 = "0" + bin1; + } + String bin2 = Integer.toBinaryString((this.buff[index + 1] + 256) % 256); + while(bin2.length() < 8) { + bin2 = "0" + bin2; + } + String bin3 = Integer.toBinaryString((this.buff[index + 2] + 256) % 256); + while(bin3.length() < 8) { + bin3 = "0" + bin3; + } + String bin4 = Integer.toBinaryString((this.buff[index + 3] + 256) % 256); + while(bin4.length() < 8) { + bin4 = "0" + bin4; + } + String bin5 = Integer.toBinaryString((this.buff[index + 4] + 256) % 256); + while(bin5.length() < 8) { + bin5 = "0" + bin5; + } + String bin6 = Integer.toBinaryString((this.buff[index + 5] + 256) % 256); + while(bin6.length() < 8) { + bin6 = "0" + bin6; + } + String bin7 = Integer.toBinaryString((this.buff[index + 6] + 256) % 256); + while(bin7.length() < 8) { + bin7 = "0" + bin7; + } + String bin8 = Integer.toBinaryString((this.buff[index + 7] + 256) % 256); + while(bin8.length() < 8) { + bin8 = "0" + bin8; + } + + if(bo == byteOrder.BIG) { + return new CaliString(bin1 + bin2 + bin3 + bin4 + bin5 + bin6 + bin7 + bin8); + } else { + return new CaliString(bin8 + bin7 + bin6 + bin5 + bin4 + bin3 + bin2 + bin1); + } + } else { + return new CaliException("buffer.doubleToBinary(): Index out of bounds."); + } + } + + public CaliType _copyFrom(ArrayList args) { + synchronized(this) { + int dindex = (int)((CaliInt)args.get(0)).getValue(); + CaliObject obj = (CaliObject)args.get(1); + int sindex = (int)((CaliInt)args.get(2)).getValue(); + int length = (int)((CaliInt)args.get(3)).getValue(); + byte[] obuff = null; + + if((obj.getExternObject() != null)&&(obj.getExternObject() instanceof CBuffer)) { + obuff = ((CBuffer)obj.getExternObject()).buff; + } else { + return new CaliException("buffer.copyFrom(): External object is null or not of type buffer."); + } + + if((dindex + length) < this.buff.length) { + if((sindex + length) < obuff.length) { + System.arraycopy(obuff, sindex, this.buff, dindex, length); + } else { + return new CaliException("buffer.copyFrom(): Source buffer overflow."); + } + } else { + return new CaliException("buffer.copyFrom(): Destination buffer overflow."); + } + + return new CaliNull(); + } + } + + public CaliType _copyTo(ArrayList args) { + synchronized(this) { + int sindex = (int)((CaliInt)args.get(0)).getValue(); + CaliObject obj = (CaliObject)args.get(1); + int dindex = (int)((CaliInt)args.get(2)).getValue(); + int length = (int)((CaliInt)args.get(3)).getValue(); + byte[] obuff = null; + + if((obj.getExternObject() != null)&&(obj.getExternObject() instanceof CBuffer)) { + obuff = ((CBuffer)obj.getExternObject()).buff; + } else { + return new CaliException("buffer.copyTo(): External object is null or not of type buffer."); + } + + if((dindex + length) < this.buff.length) { + if((sindex + length) < obuff.length) { + System.arraycopy(this.buff, sindex, obuff, dindex, length); + } else { + return new CaliException("buffer.copyTo(): Source buffer overflow."); + } + } else { + return new CaliException("buffer.copyTo(): Destination buffer overflow."); + } + + return new CaliNull(); + } + } + + public byteOrder getByteOrder(String str) { + if(str.equals("big")) { + return byteOrder.BIG; + } else if(str.equals("little")) { + return byteOrder.LITTLE; + } else { + return byteOrder.BIG; + } + } + + public String _getString(String charSet) throws caliException { + String cset = charSet.toUpperCase().replace("_", "-"); + try { + return new String(this.buff, cset); + } catch (UnsupportedEncodingException e) { + throw new caliException("buffer.getString(): Unsopported encoding exception. (" + e.getMessage() + ")"); + } catch(NullPointerException npe) { + throw new caliException("buffer.getString(): Buffer object is null."); + } + } + + public String _getStringAt(int index, int length, String charSet) throws caliException { + String cset = charSet.toUpperCase().replace("_", "-"); + try { + byte[] dest = new byte[length]; + System.arraycopy(this.buff, index, dest, 0, length); + return new String(dest, cset); + } catch (UnsupportedEncodingException e) { + throw new caliException("buffer.getStringAt(): Unsopported encoding exception. (" + e.getMessage() + ")"); + } + } + + public int _getByte(int index) throws caliException { + if((index >= 0)&&(index < buff.length)) { + return (int)this.buff[index]; + } else { + throw new caliException("buffer.getByte(): Index out of bounds."); + } + } + + public int _getUByte(int index) throws caliException { + if((index >= 0)&&(index < buff.length)) { + int val = (int) this.buff[index] & 0xff; + return val; + } else { + throw new caliException("buffer.getUByte(): Index out of bounds."); + } + } + + public int _getShort(int index, byteOrder bo) throws caliException { + if((index >= 0)&&(index < buff.length + 1)) { + int val = 0; + if(bo == byteOrder.BIG) { + val = ( + ((((int)this.buff[index]) << 8) & 0x0000ff00) + + ((int)(this.buff[index + 1] & 0x000000ff)) + ); + } else { + val = ( + ((((int)this.buff[index + 1]) << 8) & 0x0000ff00) + + ((int)(this.buff[index] & 0x000000ff)) + ); + } + return val; + } else { + throw new caliException("buffer.getShort(): Index out of bounds."); + } + } + + public int _getUShort(int index, byteOrder bo) throws caliException { + if((index >= 0)&&(index < buff.length + 1)) { + int val = 0; + + if(bo == byteOrder.BIG) { + val = ( + ((((int)this.buff[index]) << 8) & 0x0000ff00) + + ((int)(this.buff[index + 1] & 0x000000ff)) + ); + } else { + val = ( + ((((int)this.buff[index + 1]) << 8) & 0x0000ff00) + + ((int)(this.buff[index] & 0x000000ff)) + ); + } + return val; + } else { + throw new caliException("buffer.getShort(): Index out of bounds."); + } + } + + public int _getInt(int index, byteOrder bo) throws caliException { + if((index >= 0)&&(index < buff.length + 3)) { + int val = 0; + if(bo == byteOrder.BIG) { + val = ( + ((((int)this.buff[index]) << 24) & 0xff000000) + + ((((int)this.buff[index + 1]) << 16) & 0x00ff0000) + + ((((int)this.buff[index + 2]) << 8) & 0x0000ff00) + + (((int)this.buff[index + 3]) & 0x000000ff) + ); + } else { + val = ( + ((((int)this.buff[index + 3]) << 24) & 0xff000000) + + ((((int)this.buff[index + 2]) << 16) & 0x00ff0000) + + ((((int)this.buff[index + 1]) << 8) & 0x0000ff00) + + (((int)this.buff[index]) & 0x000000ff) + ); + } + return val; + } else { + throw new caliException("buffer.getInt(): Index out of bounds."); + } + } + + public long _getUInt(int index, byteOrder bo) throws caliException { + if((index >= 0)&&(index < buff.length + 3)) { + long val = 0l; + if(bo == byteOrder.BIG) { + val = ( + ((((long)this.buff[index]) << 24) & 0xff000000l) + + ((((long)this.buff[index + 1]) << 16) & 0x00ff0000l) + + ((((long)this.buff[index + 2]) << 8) & 0x0000ff00l) + + (((long)this.buff[index + 3]) & 0x000000ffl) + ); + } else { + val = ( + ((((long)this.buff[index + 3]) << 24) & 0xff000000l) + + ((((long)this.buff[index + 2]) << 16) & 0x00ff0000l) + + ((((long)this.buff[index + 1]) << 8) & 0x0000ff00l) + + (((long)this.buff[index]) & 0x000000ffl) + ); + } + return val; + } else { + throw new caliException("buffer.getUInt(): Index out of bounds."); + } + } + + public long _getLong(int index, byteOrder bo) throws caliException { + if((index >= 0)&&(index < buff.length + 7)) { + long val = 0; + if(bo == byteOrder.BIG) { + val = ( + ((((long)this.buff[index]) << 56) & 0xff00000000000000l) + + ((((long)this.buff[index + 1]) << 48) & 0x00ff000000000000l) + + ((((long)this.buff[index + 2]) << 40) & 0x0000ff0000000000l) + + ((((long)this.buff[index + 3]) << 32) & 0x000000ff00000000l) + + ((((long)this.buff[index + 4]) << 24) & 0x00000000ff000000l) + + ((((long)this.buff[index + 5]) << 16) & 0x0000000000ff0000l) + + ((((long)this.buff[index + 6]) << 8) & 0x000000000000ff00l) + + (((long)this.buff[index + 7]) & 0x00000000000000ffl) + ); + } else { + val = ( + ((((long)this.buff[index + 7]) << 56) & 0xff00000000000000l) + + ((((long)this.buff[index + 6]) << 48) & 0x00ff000000000000l) + + ((((long)this.buff[index + 5]) << 40) & 0x0000ff0000000000l) + + ((((long)this.buff[index + 4]) << 32) & 0x000000ff00000000l) + + ((((long)this.buff[index + 3]) << 24) & 0x00000000ff000000l) + + ((((long)this.buff[index + 2]) << 16) & 0x0000000000ff0000l) + + ((((long)this.buff[index + 1]) << 8) & 0x000000000000ff00l) + + (((long)this.buff[index]) & 0x00000000000000ffl) + ); + } + return val; + } else { + throw new caliException("buffer.getLong(): Index out of bounds."); + } + } + + public float _getFloat(int index, byteOrder bo) throws caliException { + if((index >= 0)&&(index < buff.length + 3)) { + float val = 0; + if(bo == byteOrder.BIG) { + val = ByteBuffer.wrap(this.buff, index, 4).order(ByteOrder.BIG_ENDIAN).getFloat(); + } else { + val = ByteBuffer.wrap(this.buff, index, 4).order(ByteOrder.LITTLE_ENDIAN).getFloat(); + } + return val; + } else { + throw new caliException("buffer.getInt(): Index out of bounds."); + } + } + + public double _getDouble(int index, byteOrder bo) throws caliException { + if((index >= 0)&&(index < buff.length + 7)) { + double val = 0; + if(bo == byteOrder.BIG) { + val = ByteBuffer.wrap(this.buff, index, 8).order(ByteOrder.BIG_ENDIAN).getDouble(); + } else { + val = ByteBuffer.wrap(this.buff, index, 8).order(ByteOrder.LITTLE_ENDIAN).getDouble(); + } + return val; + } else { + throw new caliException("buffer.getDouble(): Index out of bounds."); + } + } + + public int _setString(String str, String charSet) throws caliException { + synchronized(this) { + String cset = charSet.toUpperCase().replace("_", "-"); + try { + this.buff = str.getBytes(cset); + return this.buff.length; + } catch (UnsupportedEncodingException e) { + throw new caliException("buffer._setString(): Unsupported encoding exception. " + e.getMessage()); + } + } + } + + public int _setStringAt(int index, String str, String charSet) throws caliException { + synchronized(this) { + String cset = charSet.toUpperCase().replace("_", "-"); + int len = str.getBytes(Charset.forName(cset)).length; + if((index + len) <= this.buff.length) { + System.arraycopy(str.getBytes(Charset.forName(cset)), 0, this.buff, index, len); + return str.getBytes(Charset.forName(cset)).length; + } else { + throw new caliException("buffer.setStringAt(): Index " + (index + len) + "/" + this.buff.length + " out of bounds."); + } + } + } + + public void setByte(int index, int ival) throws caliException { + synchronized(this) { + if((index >= 0)&&(index < this.buff.length)) { + this.buff[index] = (byte)ival; + } else { + throw new caliException("buffer.setByte(): Index out of bounds."); + } + } + } + + public void setUByte(int index, int ival) throws caliException { + synchronized(this) { + if((index >= 0)&&(index < this.buff.length)) { + this.buff[index] = (byte)(ival & (0xff)); + } else { + throw new caliException("buffer.setUByte(): Index out of bounds."); + } + } + } + + public void setShort(int index, int ival, byteOrder bo) throws caliException { + synchronized(this) { + if((index >= 0)&&(index < this.buff.length + 1)) { + if(bo == byteOrder.BIG) { + this.buff[index + 1] = (byte)(ival & 0xff); + this.buff[index] = (byte)((ival >> 8) & 0xff); + } else { + this.buff[index] = (byte)(ival & 0xff); + this.buff[index + 1] = (byte)((ival >> 8) & 0xff); + } + } else { + throw new caliException("buffer.setShort(): Index out of bounds."); + } + } + } + + public void setUShort(int index, int ival, byteOrder bo) throws caliException { + synchronized(this) { + if((index >= 0)&&(index < this.buff.length + 1)) { + if(bo == byteOrder.BIG) { + this.buff[index + 1] = (byte)(ival & 0xff); + this.buff[index] = (byte)((ival >> 8) & 0xff); + } else { + this.buff[index] = (byte)(ival & 0xff); + this.buff[index + 1] = (byte)((ival >> 8) & 0xff); + } + } else { + throw new caliException("buffer.setUShort(): Index out of bounds."); + } + } + } + + public void setInt(int index, int ival, byteOrder bo) throws caliException { + synchronized(this) { + if((index >= 0)&&(index < this.buff.length + 3)) { + if(bo == byteOrder.BIG) { + this.buff[index + 3] = (byte)(ival & 0xff); + this.buff[index + 2] = (byte)((ival >> 8) & 0xff); + this.buff[index + 1] = (byte)((ival >> 16) & 0xff); + this.buff[index] = (byte)((ival >> 24) & 0xff); + } else { + this.buff[index] = (byte)(ival & 0xff); + this.buff[index + 1] = (byte)((ival >> 8) & 0xff); + this.buff[index + 2] = (byte)((ival >> 16) & 0xff); + this.buff[index + 3] = (byte)((ival >> 24) & 0xff); + } + } else { + throw new caliException("buffer.setInt(): Index out of bounds."); + } + } + } + + public void setUInt(int index, long ival, byteOrder bo) throws caliException { + synchronized(this) { + if((index >= 0)&&(index < this.buff.length + 3)) { + if(bo == byteOrder.BIG) { + this.buff[index + 3] = (byte)(ival & 0xff); + this.buff[index + 2] = (byte)((ival >> 8) & 0xff); + this.buff[index + 1] = (byte)((ival >> 16) & 0xff); + this.buff[index] = (byte)((ival >> 24) & 0xff); + } else { + this.buff[index] = (byte)(ival & 0xff); + this.buff[index + 1] = (byte)((ival >> 8) & 0xff); + this.buff[index + 2] = (byte)((ival >> 16) & 0xff); + this.buff[index + 3] = (byte)((ival >> 24) & 0xff); + } + } else { + throw new caliException("buffer.setUInt(): Index out of bounds."); + } + } + } + + public void setLong(int index, long ival, byteOrder bo) throws caliException { + synchronized(this) { + if((index >= 0)&&(index < this.buff.length + 7)) { + if(bo == byteOrder.BIG) { + this.buff[index + 7] = (byte)(ival & 0xff); + this.buff[index + 6] = (byte)((ival >> 8) & 0xff); + this.buff[index + 5] = (byte)((ival >> 16) & 0xff); + this.buff[index + 4] = (byte)((ival >> 24) & 0xff); + this.buff[index + 3] = (byte)((ival >> 32) & 0xff); + this.buff[index + 2] = (byte)((ival >> 40) & 0xff); + this.buff[index + 1] = (byte)((ival >> 48) & 0xff); + this.buff[index] = (byte)((ival >> 56) & 0xff); + } else { + this.buff[index] = (byte)(ival & 0xff); + this.buff[index + 1] = (byte)((ival >> 8) & 0xff); + this.buff[index + 2] = (byte)((ival >> 16) & 0xff); + this.buff[index + 3] = (byte)((ival >> 24) & 0xff); + this.buff[index + 4] = (byte)((ival >> 32) & 0xff); + this.buff[index + 5] = (byte)((ival >> 40) & 0xff); + this.buff[index + 6] = (byte)((ival >> 48) & 0xff); + this.buff[index + 7] = (byte)((ival >> 56) & 0xff); + } + } else { + throw new caliException("buffer.setLong(): Index out of bounds."); + } + } + } + + public void setFloat(int index, double tval, byteOrder bo) throws caliException { + synchronized(this) { + int ival = Float.floatToIntBits((float) tval); + if((index >= 0)&&(index < this.buff.length + 3)) { + if(bo == byteOrder.BIG) { + this.buff[index + 3] = (byte)(ival & 0xff); + this.buff[index + 2] = (byte)((ival >> 8) & 0xff); + this.buff[index + 1] = (byte)((ival >> 16) & 0xff); + this.buff[index] = (byte)((ival >> 24) & 0xff); + } else { + this.buff[index] = (byte)(ival & 0xff); + this.buff[index + 1] = (byte)((ival >> 8) & 0xff); + this.buff[index + 2] = (byte)((ival >> 16) & 0xff); + this.buff[index + 3] = (byte)((ival >> 24) & 0xff); + } + } else { + throw new caliException("buffer.setFloat(): Index out of bounds."); + } + } + } + + public void setDouble(int index, double tval, byteOrder bo) throws caliException { + synchronized(this) { + long ival = Double.doubleToRawLongBits(tval); + if((index >= 0)&&(index < this.buff.length + 7)) { + if(bo == byteOrder.BIG) { + this.buff[index + 7] = (byte)(ival & 0xff); + this.buff[index + 6] = (byte)((ival >> 8) & 0xff); + this.buff[index + 5] = (byte)((ival >> 16) & 0xff); + this.buff[index + 4] = (byte)((ival >> 24) & 0xff); + this.buff[index + 3] = (byte)((ival >> 32) & 0xff); + this.buff[index + 2] = (byte)((ival >> 40) & 0xff); + this.buff[index + 1] = (byte)((ival >> 48) & 0xff); + this.buff[index] = (byte)((ival >> 56) & 0xff); + } else { + this.buff[index] = (byte)(ival & 0xff); + this.buff[index + 1] = (byte)((ival >> 8) & 0xff); + this.buff[index + 2] = (byte)((ival >> 16) & 0xff); + this.buff[index + 3] = (byte)((ival >> 24) & 0xff); + this.buff[index + 4] = (byte)((ival >> 32) & 0xff); + this.buff[index + 5] = (byte)((ival >> 40) & 0xff); + this.buff[index + 6] = (byte)((ival >> 48) & 0xff); + this.buff[index + 7] = (byte)((ival >> 56) & 0xff); + } + } else { + throw new caliException("buffer.setDouble(): Index out of bounds."); + } + } + } +} diff --git a/cali.lang.base/src/com/cali/stdlib/CClass.java b/cali.lang.base/src/com/cali/stdlib/CClass.java new file mode 100644 index 0000000..bc12f98 --- /dev/null +++ b/cali.lang.base/src/com/cali/stdlib/CClass.java @@ -0,0 +1,111 @@ +/* + * Copyright 2017 Austin Lehman + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.cali.stdlib; + +import java.util.ArrayList; + +import com.cali.Environment; +import com.cali.ast.astClass; +import com.cali.ast.astFunctDef; +import com.cali.ast.astNode; +import com.cali.ast.astNodeType; +import com.cali.ast.caliException; +import com.cali.types.CaliBool; +import com.cali.types.CaliList; +import com.cali.types.CaliMap; +import com.cali.types.CaliString; +import com.cali.types.CaliType; +import com.cali.types.CaliTypeInt; +import com.cali.types.cType; + +public class CClass { + private astClass classDef = null; + + public CClass() { } + + public void setClass(astClass ClassDef) { this.classDef = ClassDef; } + + public CaliType getName(ArrayList args) { + return new CaliString(this.classDef.getName()); + } + + public CaliType isStatic(ArrayList args) { + return new CaliBool(this.classDef.getStatic()); + } + + public CaliType isExtern(ArrayList args) { + return new CaliBool(this.classDef.getExtern()); + } + + public CaliType getExternClassName(ArrayList args) { + return new CaliString(this.classDef.getExternClassName()); + } + + public CaliType getMembers(ArrayList args) { + CaliMap mp = new CaliMap(); + + for(String mname : this.classDef.getMembers().keySet()) { + mp.put(mname, new CaliString(this.classDef.getMembers().get(mname).getType().name())); + } + + return mp; + } + + public CaliType getMethods(Environment env, ArrayList args) throws caliException { + CaliMap map = new CaliMap(); + + for(String mname : this.classDef.getFuncts().keySet()) { + astFunctDef afd = (astFunctDef) this.classDef.getFunct(mname); + CaliMap fm = new CaliMap(); + fm.put("isExtern", new CaliBool(afd.getExtern())); + + CaliList alist = new CaliList(); + for(astNode tn : afd.getArgList().getArgs()) { + CaliMap am = new CaliMap(); + + if(tn.getType() == astNodeType.ETCETERA) { + am.put("name", new CaliString("...")); + } else { + am.put("name", new CaliString(tn.getName())); + + + + String primType = ""; + if(tn.getPrimType() != cType.cUndef) { + primType = tn.getPrimType().name().toLowerCase().substring(1); + } + am.put("requiredType", new CaliString(primType)); + + if (tn.getType() == astNodeType.VAR) { + am.put("hasDefaultValue", new CaliBool(false)); + } else { + am.put("hasDefaultValue", new CaliBool(true)); + CaliType defVal = tn.eval(env); + am.put("defaultValueType", new CaliString(defVal.getType().name().toLowerCase().substring(1))); + am.put("defaultValue", new CaliString(((CaliTypeInt)defVal).str())); + } + } + + alist.add(am); + } + fm.put("arguments", alist); + map.put(mname, fm); + } + + return map; + } +} \ No newline at end of file diff --git a/cali.lang.base/src/com/cali/stdlib/CDate.java b/cali.lang.base/src/com/cali/stdlib/CDate.java new file mode 100644 index 0000000..9c086a2 --- /dev/null +++ b/cali.lang.base/src/com/cali/stdlib/CDate.java @@ -0,0 +1,133 @@ +/* + * Copyright 2017 Austin Lehman + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.cali.stdlib; + +import java.text.ParseException; +import java.text.SimpleDateFormat; +import java.time.LocalDate; +import java.time.ZoneId; +import java.util.ArrayList; +import java.util.Calendar; +import java.util.Date; + +import com.cali.types.CaliNull; +import com.cali.types.CaliString; +import com.cali.types.CaliType; + +import com.cali.types.CaliBool; +import com.cali.types.CaliException; +import com.cali.types.CaliInt; + +public class CDate extends Date { + private static final long serialVersionUID = 1579993228939943395L; + + public CDate() { } + + public static LocalDate dateToLocalDate(Date Dt) { + return Dt.toInstant().atZone(ZoneId.systemDefault()).toLocalDate(); + } + + public static Date localDateToDate(LocalDate Ld) { + return new Date(Ld.toEpochDay()); + } + + public CaliType newDate(ArrayList args) { + if(!args.get(0).isNull()) { + this.setTime(((CaliInt)args.get(0)).getValue()); + } + return new CaliNull(); + } + + @SuppressWarnings("deprecation") + public CaliType getHours(ArrayList args) { + return new CaliInt(this.getHours()); + } + + @SuppressWarnings("deprecation") + public CaliType getMinutes(ArrayList args) { + return new CaliInt(this.getMinutes()); + } + + @SuppressWarnings("deprecation") + public CaliType getSeconds(ArrayList args) { + return new CaliInt(this.getSeconds()); + } + + public CaliType getTime(ArrayList args) { + return new CaliInt(this.getTime()); + } + + @SuppressWarnings("deprecation") + public CaliType _setHours(ArrayList args) { + this.setHours((int)((CaliInt)args.get(0)).getValue()); + return new CaliNull(); + } + + @SuppressWarnings("deprecation") + public CaliType _setMinutes(ArrayList args) { + this.setMinutes((int)((CaliInt)args.get(0)).getValue()); + return new CaliNull(); + } + + @SuppressWarnings("deprecation") + public CaliType _setSeconds(ArrayList args) { + this.setSeconds((int)((CaliInt)args.get(0)).getValue()); + return new CaliNull(); + } + + public CaliType _setTime(ArrayList args) { + this.setTime(((CaliInt)args.get(0)).getValue()); + return new CaliNull(); + } + + public CaliType toString(ArrayList args) { + return new CaliString(this.toString()); + } + + public CaliType parse(ArrayList args) { + SimpleDateFormat sdf = new SimpleDateFormat(((CaliString)args.get(1)).getValueString()); + try { + Date td = sdf.parse(((CaliString)args.get(0)).getValueString()); + this.setTime(td.getTime()); + return new CaliNull(); + } catch (ParseException e) { + return new CaliException("Date.parse(): Parse exception. (" + e.getMessage() + ")"); + } + } + + public CaliType format(ArrayList args) { + SimpleDateFormat sdf = new SimpleDateFormat(((CaliString)args.get(0)).getValueString()); + return new CaliString(sdf.format(this)); + } + + public CaliType isEpoch(ArrayList args) { + if(this.getTime() == 0) { + return new CaliBool(true); + } + return new CaliBool(false); + } + + /* + * Helper functions + */ + public static Date addDays(Date dt, int numDays) { + Calendar c = Calendar.getInstance(); + c.setTime(dt); + c.add(Calendar.DATE, numDays); + return c.getTime(); + } +} \ No newline at end of file diff --git a/cali.lang.base/src/com/cali/stdlib/CLang.java b/cali.lang.base/src/com/cali/stdlib/CLang.java new file mode 100644 index 0000000..ad83180 --- /dev/null +++ b/cali.lang.base/src/com/cali/stdlib/CLang.java @@ -0,0 +1,35 @@ +/* + * Copyright 2017 Austin Lehman + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.cali.stdlib; + +import java.util.ArrayList; + +import com.cali.types.CaliObject; +import com.cali.types.CaliString; +import com.cali.types.CaliType; +import com.cali.types.cType; + +public class CLang { + public static CaliType type(ArrayList args) { + CaliType ct = args.get(0); + if (ct.getType() == cType.cObject) { + return new CaliString(((CaliObject)ct).getClassDef().getName()); + } else { + return new CaliString(args.get(0).getType().name().toLowerCase().substring(1)); + } + } +} diff --git a/cali.lang.base/src/com/cali/stdlib/CMath.java b/cali.lang.base/src/com/cali/stdlib/CMath.java new file mode 100644 index 0000000..0cdfc87 --- /dev/null +++ b/cali.lang.base/src/com/cali/stdlib/CMath.java @@ -0,0 +1,196 @@ +/* + * Copyright 2017 Austin Lehman + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.cali.stdlib; + +import java.util.ArrayList; + +import com.cali.ast.caliException; +import com.cali.types.CaliDouble; +import com.cali.types.CaliException; +import com.cali.types.CaliInt; +import com.cali.types.CaliType; +import com.cali.types.cType; + +public class CMath { + public static CaliType e(ArrayList args) { + return new CaliDouble(Math.E); + } + + public static CaliType pi(ArrayList args) { + return new CaliDouble(Math.PI); + } + + public static CaliType abs(ArrayList args) { + CaliType ret = new CaliInt(0); + CaliType arg = args.get(0); + if(arg.getType() == cType.cBool); + else if(arg.getType() == cType.cInt) ret = new CaliInt(Math.abs((int)((CaliInt)arg).getValue())); + else if(arg.getType() == cType.cDouble) ret = new CaliDouble(Math.abs(((CaliDouble)arg).getValue())); + else ret = new CaliException("math.abs(): Expecting object of type bool, int or double but found " + arg.getType().name() + " instead."); + return ret; + } + + public static CaliType acos(ArrayList args) { + return new CaliDouble(Math.acos(((CaliDouble)args.get(0)).getValue())); + } + + public static CaliType asin(ArrayList args) { + return new CaliDouble(Math.asin(((CaliDouble)args.get(0)).getValue())); + } + + public static CaliType atan(ArrayList args) { + return new CaliDouble(Math.atan(((CaliDouble)args.get(0)).getValue())); + } + + public static CaliType cbrt(ArrayList args) { + return new CaliDouble(Math.cbrt(((CaliDouble)args.get(0)).getValue())); + } + + public static CaliType ceil(ArrayList args) { + return new CaliDouble(Math.ceil(((CaliDouble)args.get(0)).getValue())); + } + + public static CaliType copySign(ArrayList args) { + return new CaliDouble(Math.copySign(((CaliDouble)args.get(0)).getValue(), ((CaliDouble)args.get(1)).getValue())); + } + + public static CaliType cos(ArrayList args) { + return new CaliDouble(Math.cos(((CaliDouble)args.get(0)).getValue())); + } + + public static CaliType cosh(ArrayList args) { + return new CaliDouble(Math.cosh(((CaliDouble)args.get(0)).getValue())); + } + + public static CaliType exp(ArrayList args) { + return new CaliDouble(Math.exp(((CaliDouble)args.get(0)).getValue())); + } + + public static CaliType expm1(ArrayList args) { + return new CaliDouble(Math.expm1(((CaliDouble)args.get(0)).getValue())); + } + + public static CaliType floor(ArrayList args) { + return new CaliDouble(Math.floor(((CaliDouble)args.get(0)).getValue())); + } + + public static CaliType getExponent(ArrayList args) { + return new CaliDouble(Math.getExponent(((CaliDouble)args.get(0)).getValue())); + } + + public static CaliType hypot(ArrayList args) { + return new CaliDouble(Math.hypot(((CaliDouble)args.get(0)).getValue(), ((CaliDouble)args.get(1)).getValue())); + } + + public static CaliType IEEEremainder(ArrayList args) { + return new CaliDouble(Math.IEEEremainder(((CaliDouble)args.get(0)).getValue(), ((CaliDouble)args.get(1)).getValue())); + } + + public static CaliType log(ArrayList args) { + return new CaliDouble(Math.log(((CaliDouble)args.get(0)).getValue())); + } + + public static CaliType log10(ArrayList args) { + return new CaliDouble(Math.log10(((CaliDouble)args.get(0)).getValue())); + } + + public static CaliType log1p(ArrayList args) { + return new CaliDouble(Math.log1p(((CaliDouble)args.get(0)).getValue())); + } + + public static CaliType max(ArrayList args) throws caliException { + CaliType ret = new CaliInt(0); + CaliType arg = args.get(0); + CaliType arg2 = args.get(1); + if(arg.isNumericType() && arg2.isNumericType()) ret = new CaliDouble(Math.max(arg.getNumericDouble(), arg2.getNumericDouble())); + else ret = new CaliException("math.abs(): Expecting object of type bool, int or double but found " + arg.getType().name() + " instead."); + return ret; + } + + public static CaliType min(ArrayList args) throws caliException { + CaliType ret = new CaliInt(0); + CaliType arg = args.get(0); + CaliType arg2 = args.get(1); + if(arg.isNumericType()&&arg2.isNumericType()) ret = new CaliDouble(Math.min(arg.getNumericDouble(), arg2.getNumericDouble())); + else ret = new CaliException("math.abs(): Expecting object of type bool, int or double but found " + arg.getType().name() + " instead."); + return ret; + } + + public static CaliType nextAfter(ArrayList args) { + return new CaliDouble(Math.nextAfter(((CaliDouble)args.get(0)).getValue(), ((CaliDouble)args.get(1)).getValue())); + } + + public static CaliType nextUp(ArrayList args) { + return new CaliDouble(Math.nextUp(((CaliDouble)args.get(0)).getValue())); + } + + public static CaliType pow(ArrayList args) { + return new CaliDouble(Math.pow(((CaliDouble)args.get(0)).getValue(), ((CaliDouble)args.get(1)).getValue())); + } + + public static CaliType rand(ArrayList args) { + return new CaliDouble(Math.random()); + } + + public static CaliType rint(ArrayList args) { + return new CaliDouble(Math.rint(((CaliDouble)args.get(0)).getValue())); + } + + public static CaliType round(ArrayList args) { + return new CaliDouble(Math.round(((CaliDouble)args.get(0)).getValue())); + } + + public static CaliType scalb(ArrayList args) { + return new CaliDouble(Math.scalb(((CaliDouble)args.get(0)).getValue(), (int)((CaliInt)args.get(1)).getValue())); + } + + public static CaliType signum(ArrayList args) { + return new CaliDouble(Math.signum(((CaliDouble)args.get(0)).getValue())); + } + + public static CaliType sin(ArrayList args) { + return new CaliDouble(Math.sin(((CaliDouble)args.get(0)).getValue())); + } + + public static CaliType sinh(ArrayList args) { + return new CaliDouble(Math.sinh(((CaliDouble)args.get(0)).getValue())); + } + + public static CaliType sqrt(ArrayList args) { + return new CaliDouble(Math.sqrt(((CaliDouble)args.get(0)).getValue())); + } + + public static CaliType tan(ArrayList args) { + return new CaliDouble(Math.tan(((CaliDouble)args.get(0)).getValue())); + } + + public static CaliType tanh(ArrayList args) { + return new CaliDouble(Math.tanh(((CaliDouble)args.get(0)).getValue())); + } + + public static CaliType toDeg(ArrayList args) { + return new CaliDouble(Math.toDegrees(((CaliDouble)args.get(0)).getValue())); + } + + public static CaliType toRad(ArrayList args) { + return new CaliDouble(Math.toRadians(((CaliDouble)args.get(0)).getValue())); + } + + public static CaliType ulp(ArrayList args) { + return new CaliDouble(Math.ulp(((CaliDouble)args.get(0)).getValue())); + } +} diff --git a/cali.lang.base/src/com/cali/stdlib/CReflect.java b/cali.lang.base/src/com/cali/stdlib/CReflect.java new file mode 100644 index 0000000..26be5a7 --- /dev/null +++ b/cali.lang.base/src/com/cali/stdlib/CReflect.java @@ -0,0 +1,137 @@ +/* + * Copyright 2017 Austin Lehman + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.cali.stdlib; + +import java.util.ArrayList; + +import com.cali.types.CaliType; +import com.cali.Environment; +import com.cali.ast.astClass; +import com.cali.ast.caliException; +import com.cali.types.CaliBool; +import com.cali.types.CaliException; +import com.cali.types.CaliList; +import com.cali.types.CaliNull; +import com.cali.types.CaliObject; +import com.cali.types.CaliString; + +public class CReflect { + public static CaliType _evalStr(Environment env, ArrayList args) { + String code = ((CaliString)args.get(0)).getValue(); + String name = ((CaliString)args.get(1)).getValue(); + try { + env.getEngine().parseString(name, code); + return new CaliNull(); + } catch (caliException e) { + return new CaliException(e.getMessage()); + } catch (Exception e) { + return new CaliException(e.getMessage()); + } + } + + public static CaliType _evalFile(Environment env, ArrayList args) { + String FileName = ((CaliString)args.get(0)).getValue(); + try { + env.getEngine().parseFile(FileName); + } catch (Exception e) { + return new CaliException(e.getMessage()); + } + return new CaliNull(); + } + + + + public static CaliType _includeModule(Environment env, ArrayList args) { + String incFile = ((CaliString)args.get(0)).getValue().replace(".", System.getProperty("file.separator")) + ".ca"; + try { + env.getEngine().parseFile(incFile); + } catch (Exception e) { + return new CaliException(e.getMessage()); + } + return new CaliNull(); + } + + public static CaliType loadedModules(Environment env, ArrayList args) { + CaliList list = new CaliList(); + for (String mod : env.getEngine().getIncludes()) { + list.add(new CaliString(mod)); + } + return list; + } + + public static CaliType loadedClasses(Environment env, ArrayList args) { + CaliList list = new CaliList(); + for (String cls : env.getEngine().getClasses().keySet()) { + list.add(new CaliString(cls)); + } + return list; + } + + public static CaliType isModuleLoaded(Environment env, ArrayList args) { + String incFile = ((CaliString)args.get(0)).getValue().replace(".", System.getProperty("file.separator")) + ".ca"; + return new CaliBool(env.getEngine().getIncludes().contains(incFile)); + } + + public static CaliType classExists(Environment env, ArrayList args) { + CaliString name = (CaliString)args.get(0); + return new CaliBool(env.getEngine().getClasses().containsKey(name)); + } + + public static CaliType getClassDef(Environment env, ArrayList args) { + String ClassName = ((CaliString)args.get(0)).getValue(); + if(env.getEngine().getClasses().containsKey(ClassName)) { + astClass tc = env.getEngine().getClasses().get(ClassName); + astClass cc = env.getEngine().getClasses().get("rclass"); + try { + CaliObject co = (CaliObject) cc.instantiate(env); + CClass ccobj = (CClass)co.getExternObject(); + ccobj.setClass(tc); + return co; + } catch (caliException e) { + return new CaliException("reflect.getClassDef(): Class '" + ClassName + "'.\n"); + } + } else { + return new CaliException("reflect.getClassDef(): Class '" + ClassName + "' not found."); + } + } + + public static CaliType instantiate(Environment env, ArrayList args) { + String ClassName = ((CaliString)args.get(0)).getValue(); + try { + CaliObject co = env.getEngine().instantiateObject(ClassName); + return co; + } catch (caliException e) { + return new CaliException("reflect.instantiate(): Failed to instantiate class '" + ClassName + "'.\n"); + } + } + + public static CaliType invoke(Environment env, ArrayList args) { + CaliObject obj = (CaliObject)args.get(0); + String fname = ((CaliString)args.get(1)).getValue(); + CaliList alist = (CaliList) args.get(2); + + try { + astClass ac = obj.getClassDef(); + Environment tenv = env.clone(obj); + return ac.call(tenv, false, fname, alist); + } catch (caliException e) { + return new CaliException(e.getCaliMessage()); + } catch (Exception e) { + return new CaliException("reflect.invoke(): Unhandled exception occurred while calling '" + fname + "'. " + e.getMessage()); + } + } +} diff --git a/cali.lang.base/src/com/cali/stdlib/CSys.java b/cali.lang.base/src/com/cali/stdlib/CSys.java new file mode 100644 index 0000000..c552ef8 --- /dev/null +++ b/cali.lang.base/src/com/cali/stdlib/CSys.java @@ -0,0 +1,197 @@ +/* + * Copyright 2017 Austin Lehman + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.cali.stdlib; + +import java.io.File; +import java.net.URLDecoder; +import java.util.ArrayList; + +import com.cali.Universe; +import com.cali.types.CaliInt; +import com.cali.types.CaliNull; +import com.cali.types.CaliString; +import com.cali.types.CaliType; + +public class CSys { + public static String getSysInfo() + { + String ret = ""; + + ArrayList args = new ArrayList(); + ret += "OS Information\n"; + ret += "\tOS Arch: " + ((CaliString)getOsArch(args)).getValueString() + "\n"; + ret += "\tOS Name: " + ((CaliString)getOsName(args)).getValueString() + "\n"; + ret += "\tOS Version: " + ((CaliString)getOsVersion(args)).getValueString() + "\n"; + ret += "\tOS File Separator: " + ((CaliString)getFileSeparator(args)).getValueString() + "\n"; + + ret += "\n"; + ret += "Java Information\n"; + ret += "\tJava Version: " + ((CaliString)getJavaVersion(args)).getValueString() + "\n"; + ret += "\tJava Vendor: " + ((CaliString)getJavaVendor(args)).getValueString() + "\n"; + ret += "\tJava Vendor Url: " + ((CaliString)getJavaVendorUrl(args)).getValueString() + "\n"; + ret += "\tJava Class Path: " + ((CaliString)getJavaClassPath(args)).getValueString() + "\n"; + + ret += "\n"; + ret += "Cali Information\n"; + ret += "\tCali Version: " + ((CaliString)getCaliVersion(args)).getValueString() + "\n"; + ret += "\tCali Assembly: " + ((CaliString)getAssembly(args)).getValueString() + "\n"; + ret += "\tCali Assembly Path: " + ((CaliString)getAssemblyPath(args)).getValueString() + "\n"; + + ret += "\n"; + ret += "User Information\n"; + ret += "\tCurrent Path: " + ((CaliString)getCurrentPath(args)).getValueString() + "\n"; + ret += "\tHome Path: " + ((CaliString)getHomePath(args)).getValueString() + "\n"; + ret += "\tUser Name: " + ((CaliString)getUserName(args)).getValueString() + "\n"; + + ret += "\n"; + + return ret; + } + + /* + * Environment functions + */ + public static CaliType getSysInfo(ArrayList args) + { + String ret = CSys.getSysInfo(); + return new CaliString(ret); + } + + public static String _getAssembly() { + String path = ""; + try { + path = (new File(URLDecoder.decode(Universe.class.getProtectionDomain().getCodeSource().getLocation().getPath())).getAbsolutePath()); + } catch(Exception e) { + /* + if(runtime.getInstance().getOsType() == osType.MOBILE) + { + path = android.getInstance().getAssemblyPath(); + } + */ + e.printStackTrace(); + } + return path; + } + + public static String _getAssemblyPath() + { + String path = ""; + try { + path = (new File(URLDecoder.decode(Universe.class.getProtectionDomain().getCodeSource().getLocation().getPath())).getParent()) + System.getProperty("file.separator"); + } catch(Exception e) { + /* + if(runtime.getInstance().getOsType() == osType.MOBILE) + { + path = android.getInstance().getAssemblyPath(); + } + */ + e.printStackTrace(); + } + return path; + } + + public static CaliType getAssembly(ArrayList args) { + return new CaliString(_getAssembly()); + } + + public static CaliType getAssemblyPath(ArrayList args) { + return new CaliString(_getAssemblyPath()); + } + + public static CaliType getCurrentPath(ArrayList args) { + return new CaliString(System.getProperty("user.dir")); + } + + /* + public static CaliType getMainFilePath(ArrayList args) { + if(runtime.getInstance().getOsType() == osType.MOBILE) + return new CaliString(runtime.getInstance().getMobilePath()); + else + return sys.getCurrentPath(args); + } + */ + + public static CaliType getHomePath(ArrayList args) { + return new CaliString(System.getProperty("user.home")); + } + + public static CaliType getUserName(ArrayList args) { + return new CaliString(System.getProperty("user.name")); + } + + public static CaliType getOsArch(ArrayList args) { + return new CaliString(System.getProperty("os.arch")); + } + + public static CaliType getOsName(ArrayList args) { + return new CaliString(System.getProperty("os.name")); + } + + public static CaliType getOsVersion(ArrayList args) { + return new CaliString(System.getProperty("os.version")); + } + + public static CaliType getJavaVersion(ArrayList args) { + return new CaliString(System.getProperty("java.version")); + } + + public static CaliType getJavaVendor(ArrayList args) { + return new CaliString(System.getProperty("java.vendor")); + } + + public static CaliType getJavaVendorUrl(ArrayList args) { + return new CaliString(System.getProperty("java.vendor.url")); + } + + public static CaliType getFileSeparator(ArrayList args) { + return new CaliString(System.getProperty("file.separator")); + } + + public static CaliType getLineSeparator(ArrayList args) { + return new CaliString(System.getProperty("line.separator")); + } + + public static CaliType getJavaClassPath(ArrayList args) { + return new CaliString(System.getProperty("java.class.path")); + } + + public static CaliType getCaliVersion(ArrayList args) { + return new CaliString(Universe.getCaliVersion()); + } + + public static CaliType getJavaHome(ArrayList args) { + return new CaliString(System.getenv("JAVA_HOME")); + } + + /* + * Time functions + */ + public static CaliType getMills(ArrayList args) { + return new CaliInt(System.currentTimeMillis()); + } + + public static CaliType _sleep(ArrayList args) { + CaliType ret = new CaliNull(); + try { + Thread.sleep(((CaliInt)args.get(0)).getValue()); + } catch (InterruptedException e) { + // TODO Return exception object. + e.printStackTrace(); + } + return ret; + } +} diff --git a/cali.lang.base/src/com/cali/stdlib/Lang.java b/cali.lang.base/src/com/cali/stdlib/Lang.java new file mode 100644 index 0000000..b27bf19 --- /dev/null +++ b/cali.lang.base/src/com/cali/stdlib/Lang.java @@ -0,0 +1,580 @@ +/* + * Copyright 2017 Austin Lehman + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.cali.stdlib; + +import java.util.Collections; +import java.util.Map; +import java.util.concurrent.ConcurrentHashMap; + +public class Lang{ + public static final String langSrc = + "extern class bool : com.cali.types.CaliBool {\n" + + "public extern toInt();\n" + + "public extern toDouble();\n" + + "public extern toString();\n" + + "public extern compare(bool Val);\n" + + "public extern parse(string Val);\n" + + "}\n" + + "\n" + + "static extern class Bool : com.cali.stdlib.SBool {\n" + + "public extern parse(string Val);\n" + + "}\n" + + "\n" + + "extern class int : com.cali.types.CaliInt {\n" + + "public extern toDouble();\n" + + "public extern toBool();\n" + + "public extern toString();\n" + + "public extern compare(int Val);\n" + + "public extern numLeadingZeros();\n" + + "public extern numTrailingZeros();\n" + + "public extern reverse();\n" + + "public extern reverseBytes();\n" + + "public extern rotateLeft(int Distance);\n" + + "public extern rotateRight(int Distance);\n" + + "public extern signum();\n" + + "public extern toBinary();\n" + + "public extern toHex();\n" + + "public extern toOctal();\n" + + "public extern parse(string Str, int Radix = null);\n" + + "}\n" + + "\n" + + "static extern class Int : com.cali.stdlib.SInt {\n" + + "public extern maxVal();\n" + + "public extern minVal();\n" + + "public extern parse(string Str, int Radix = null);\n" + + "}\n" + + "\n" + + "extern class double : com.cali.types.CaliDouble {\n" + + "public extern toInt();\n" + + "public extern toBool();\n" + + "public extern toString();\n" + + "public extern compare(double Val2);\n" + + "public extern isInfinite();\n" + + "public extern isNan();\n" + + "public extern parse(string Val);\n" + + "public extern toHex();\n" + + "}\n" + + "\n" + + "static extern class Double : com.cali.stdlib.SDouble {\n" + + "public extern maxExp();\n" + + "public extern maxVal();\n" + + "public extern minExp();\n" + + "public extern minNormal();\n" + + "public extern minVal();\n" + + "public extern nanVal();\n" + + "public extern negInfinity();\n" + + "public extern posInfinity();\n" + + "public extern size();\n" + + "public extern parse(string Val);\n" + + "}\n" + + "\n" + + "extern class string : com.cali.types.CaliString {\n" + + "public extern charAt(int Index);\n" + + "public extern compare(string Str);\n" + + "public extern compareICase(string Str);\n" + + "public extern concat(string Str);\n" + + "public extern contains(string Needle);\n" + + "public extern endsWith(string Suffix);\n" + + "public extern equals(string Str);\n" + + "public extern equalsICase(string Str);\n" + + "public extern indexOf(string Needle);\n" + + "public extern indexOfStart(string Needle, int StartIndex);\n" + + "public extern isEmpty();\n" + + "public extern lastIndexOf(string Needle);\n" + + "public extern lastIndexOfStart(string Needle, int StartIndex);\n" + + "public extern length();\n" + + "public extern matches(string Regex);\n" + + "public extern replace(string Find, string Replace);\n" + + "public extern replaceFirstRegex(string Regex, string Replace);\n" + + "public extern replaceRegex(string Regex, string Replace);\n" + + "public extern split(string Delim, bool AllowBlanks = false);\n" + + "public extern startsWith(string Prefix);\n" + + "public extern substr(int Index, int EndIndex = null);\n" + + "public extern toLower();\n" + + "public extern toUpper();\n" + + "public extern trim();\n" + + "}\n" + + "\n" + + "extern class list : com.cali.types.CaliList {\n" + + "public extern add(ItemToAdd);\n" + + "public extern addAll(list ListToAdd);\n" + + "public extern addAllAt(list ListToAdd, int Index);\n" + + "public extern clear();\n" + + "public extern clone();\n" + + "public extern contains(Item);\n" + + "public extern containsObjRef(Item);\n" + + "public extern get(int Index);\n" + + "public extern indexOf(Item);\n" + + "public extern isEmpty();\n" + + "public extern remove(Item);\n" + + "public extern removeAt(int Index);\n" + + "public extern removeAll(list ListToRemove);\n" + + "public extern retainAll(list ListToRetain);\n" + + "public extern set(int Index, Item);\n" + + "public extern size();\n" + + "public extern subList(int StartIndex, int EndIndex);\n" + + "public extern sort();\n" + + "public extern sortAsc();\n" + + "public extern join(string Glue);\n" + + "public extern sortCustom(callback OnCompare);\n" + + "}\n" + + "\n" + + "extern class map : com.cali.types.CaliMap {\n" + + "public extern clear();\n" + + "public extern containsKey(string Key);\n" + + "public extern containsVal(Val);\n" + + "public extern get(string Key);\n" + + "public extern isEmpty();\n" + + "public extern keySet();\n" + + "public extern put(string Key, Val);\n" + + "public extern putAll(map ToAdd);\n" + + "public extern putIfAbsent(string Key, Val);\n" + + "public extern remove(string Key);\n" + + "public extern size();\n" + + "public extern values();\n" + + "}\n" + + "\n" + + "extern class callback : com.cali.types.CaliCallback {\n" + + "public call(...) { return this._call(etc); }\n" + + "private extern _call(list args);\n" + + "}\n" + + "\n" + + "extern class cnull : com.cali.types.CaliNull {\n" + + "}\n" + + "\n" + + /* + * exception + */ + + "class exception {\n" + + "// Getters\n" + + "public extern getLineNumber();\n" + + "public extern getExceptionType();\n" + + "public extern getId();\n" + + "public extern getText();\n" + + "public extern getDetails();\n" + + "public extern getStackTrace();\n" + + "\n" + + "public printStackTrace() { c.println(this.getStackTrace()); }\n" + + "\n" + + "public toString() {\n" + + "estr = \"line \" + this.getLineNumber() + \": \" + this.getExceptionType() + \" Exception. [\" + this.getId() + \"] :: \" + this.getDetails();\n" + + "estr += \"\n\" + this.getStackTrace();\n" + + "return estr;\n" + + "}\n" + + "}\n" + + "\n" + /* + * console + */ + + "static extern class c : com.cali.stdlib.console {\n" + + "// Console functions\n" + + "public log(Content) { this._log(Content); return this; }\n" + + "public info(Content) { this._info(Content); return this; }\n" + + "public warn(Content) { this._warn(Content); return this; }\n" + + "public err(Content) { this._err(Content); return this; }\n" + + "public print(Content) { this._print(Content); return this; }\n" + + "public println(Content) { this._println(Content); return this; }\n" + + "\n" + + "// Chained extern functions\n" + + "private extern _log(Content);\n" + + "private extern _info(Content);\n" + + "private extern _warn(Content);\n" + + "private extern _err(Content);\n" + + "private extern _print(Content);\n" + + "private extern _println(Content);\n" + + "}\n" + + "\n" + /* + * date + */ + + "extern class date : com.cali.stdlib.CDate {\n" + + "// Create new date.\n" + + "public date(int Mills = null) {\n" + + "return this.newDate(Mills);\n" + + "}\n" + + "public extern newDate(int Mills = null);\n" + + "\n" + + "public extern getHours();\n" + + "public extern getMinutes();\n" + + "public extern getSeconds();\n" + + "public extern getTime();\n" + + "\n" + + "// Chained\n" + + "public setHours(int Hours) { this._setHours(Hours); return this; }\n" + + "public setMinutes(int Minutes) { this._setMinutes(Minutes); return this; }\n" + + "public setSeconds(int Seconds) { this._setSeconds(Seconds); return this; }\n" + + "public setTime(int TimeMills) { this._setTime(TimeMills); return this; }\n" + + "\n" + + "public extern toString();\n" + + "public extern parse(string DateString, string DateFormat);\n" + + "public extern format(string DateFormat = \"yyyy-MM-dd HH:mm:ss.SSS Z\");\n" + + "public extern isEpoch();\n" + + "\n" + + "// Chained extern functions\n" + + "private extern _setHours(int Hours);\n" + + "private extern _setMinutes(int Minutes);\n" + + "private extern _setSeconds(int Seconds);\n" + + "private extern _setTime(int TimeMills);\n" + + "}\n" + + "\n" + /* + * charset + */ + + "enum charset {\n" + + "us_ascii;\n" + + "iso_8859_1;\n" + + "utf_8;\n" + + "utf_16be;\n" + + "utf_16le;\n" + + "utf_16;\n" + + "}\n" + + "\n" + /* + * byte order + */ + + "enum byteOrder {\n" + + "big;\n" + + "little;\n" + + "}\n" + + "\n" + /* + * buffer + */ + + "extern class buffer : com.cali.stdlib.CBuffer {\n" + + "public buffer(int Size = 1024) {\n" + + "return this.newBuffer(Size);\n" + + "}\n" + + "private extern newBuffer(int Size = 1024);\n" + + "\n" + + "public extern size();\n" + + "public clear() { this._clear(); return this; }\n" + + "\n" + + "// Moves cursor to provided position\n" + + "public writeSeek(int Index) { this._writeSeek(Index); return this; }\n" + + "public readSeek(int Index) { this._readSeek(Index); return this; }\n" + + "\n" + + "// address\n" + + "public addString(string Str, string Charset = \"utf_8\") { this._addString(Str, Charset); return this; }\n" + + "public addByte(int Byte) { this._addByte(Byte); return this; }\n" + + "public addUByte(int Byte) { this._addUByte(Byte); return this; }\n" + + "public addShort(int Short, string ByteOrder = \"big\") { this._addShort(Short, ByteOrder); return this; }\n" + + "public addUShort(int Short, string ByteOrder = \"big\") { this._addUShort(Short, ByteOrder); return this; }\n" + + "public addInt(int Int, string ByteOrder = \"big\") { this._addInt(Int, ByteOrder); return this; }\n" + + "public addUInt(int Int, string ByteOrder = \"big\") { this._addUInt(Int, ByteOrder); return this; }\n" + + "public addLong(int Long, string ByteOrder = \"big\") { this._addLong(Long, ByteOrder); return this; }\n" + + "public addFloat(double Float, string ByteOrder = \"big\") { this._addFloat(Float, ByteOrder); return this; }\n" + + "public addDouble(double Double, string ByteOrder = \"big\") { this._addDouble(Double, ByteOrder); return this; }\n" + + "\n" + + "public extern getWriteCursor();\n" + + "public extern getReadCursor();\n" + + "public extern getString(string Charset = \"utf_8\");\n" + + "public extern getStringAt(int Length, int Index = -1, string Charset = \"utf_8\");\n" + + "public extern getByte(int Index = -1);\n" + + "public extern getUByte(int Index = -1);\n" + + "public extern getShort(int Index = -1, string ByteOrder = \"big\");\n" + + "public extern getUShort(int Inex = -1, string ByteOrder = \"big\");\n" + + "public extern getInt(int Index = -1, string ByteOrder = \"big\");\n" + + "public extern getUInt(int Index = -1, string ByteOrder = \"big\");\n" + + "public extern getLong(int Index = -1, string ByteOrder = \"big\");\n" + + "public extern getFloat(int Index = -1, string ByteOrder = \"big\");\n" + + "public extern getDouble(int Index = -1, string ByteOrder = \"big\");\n" + + "\n" + + "public extern setString(string Str, string Charset = \"utf_8\");\n" + + "public extern setStringAt(int Index, string Str, string Charset = \"utf_8\");\n" + + "\n" + + "// chained\n" + + "public setByte(int Index, int Byte, string ByteOrder = \"big\") { this._setByte(Index, Byte, ByteOrder); return this; }\n" + + "public setUByte(int Index, int Byte, string ByteOrder = \"big\") { this._setUByte(Index, Byte, ByteOrder); return this; }\n" + + "public setShort(int Index, int Short, string ByteOrder = \"big\") { this._setShort(Index, Short, ByteOrder); return this; }\n" + + "public setUShort(int Index, int Short, string ByteOrder = \"big\") { this._setUShort(Index, Short, ByteOrder); return this; }\n" + + "public setInt(int Index, int Int, string ByteOrder = \"big\") { this._setInt(Index, Int, ByteOrder); return this; }\n" + + "public setUInt(int Index, int Int, string ByteOrder = \"big\") { this._setUInt(Index, Int, ByteOrder); return this; }\n" + + "public setLong(int Index, int Long, string ByteOrder = \"big\") { this._setLong(Index, Long, ByteOrder); return this; }\n" + + "public setFloat(int Index, double Float, string ByteOrder = \"big\") { this._setFloat(Index, Float, ByteOrder); return this; }\n" + + "public setDouble(int Index, double Float, string ByteOrder = \"big\") { this._setDouble(Index, Float, ByteOrder); return this; }\n" + + "\n" + + "public copyFrom(int DestIndex, object Buffer, int SrcIndex = -1, int Length = -1) { this._copyFrom(DestIndex, Buffer, SrcIndex, Length); return this; }\n" + + "public copyTo(int SrcIndex, object Buffer, int DestIndex = -1, int Length = -1) { this._copyTo(SrcIndex, Buffer, DestIndex, Length); return this; }\n" + + "\n" + + "// Binary display functions\n" + + "public extern byteToBinary(int Index);\n" + + "public extern shortToBinary(int Index, string ByteOrder = \"big\");\n" + + "public extern intToBinary(int Index, string ByteOrder = \"big\");\n" + + "public extern longToBinary(int Index, string ByteOrder = \"big\");\n" + + "public extern floatToBinary(int Index, string ByteOrder = \"big\");\n" + + "public extern doubleToBinary(int Index, string ByteOrder = \"big\");\n" + + "\n" + + "private extern _clear();\n" + + "private extern _writeSeek(int Index);\n" + + "private extern _readSeek(int Index);\n" + + "\n" + + "private extern _addString(string Str, string Charset = \"utf_8\");\n" + + "private extern _addByte(int Byte);\n" + + "private extern _addUByte(int Byte);\n" + + "private extern _addShort(int Short, string ByteOrder = \"big\");\n" + + "private extern _addUShort(int Short, string ByteOrder = \"big\");\n" + + "private extern _addInt(int Int, string ByteOrder = \"big\");\n" + + "private extern _addUInt(int Int, string ByteOrder = \"big\");\n" + + "private extern _addLong(int Long, string ByteOrder = \"big\");\n" + + "private extern _addFloat(double Float, string ByteOrder = \"big\");\n" + + "private extern _addDouble(double Double, string ByteOrder = \"big\");\n" + + "\n" + + "private extern _setByte(int Index, int Byte, string ByteOrder = \"big\");\n" + + "private extern _setUByte(int Index, int Byte, string ByteOrder = \"big\");\n" + + "private extern _setShort(int Index, int Short, string ByteOrder = \"big\");\n" + + "private extern _setUShort(int Index, int Short, string ByteOrder = \"big\");\n" + + "private extern _setInt(int Index, int Int, string ByteOrder = \"big\");\n" + + "private extern _setUInt(int Index, int Int, string ByteOrder = \"big\");\n" + + "private extern _setLong(int Index, int Long, string ByteOrder = \"big\");\n" + + "private extern _setFloat(int Index, double Float, string ByteOrder = \"big\");\n" + + "private extern _setDouble(int Index, double Float, string ByteOrder = \"big\");\n" + + "\n" + + "private extern _copyFrom(int DestIndex, object Buffer, int SrcIndex = -1, int Length = -1);\n" + + "private extern _copyTo(int SrcIndex, object Buffer, int DestIndex = -1, int Length = -1);\n" + + "}\n" + + "\n" + /* + * lang + */ + + "static extern class lang : com.cali.stdlib.CLang {\n" + + "public extern type(DataType);\n" + + "}\n" + + "\n" + ; + + public static final Map langIncludes; + static { + Map iMap = new ConcurrentHashMap(); + iMap.put("sys.ca", + "// sys\n" + + "static extern class sys : com.cali.stdlib.CSys {\n" + + "public extern getSysInfo();\n" + + "public extern getAssembly();\n" + + "public extern getAssemblyPath();\n" + + "public extern getCurrentPath();\n" + + "//public extern getMainFilePath();\n" + + "public extern getHomePath();\n" + + "public extern getUserName();\n" + + "public extern getOsArch();\n" + + "public extern getOsName();\n" + + "public extern getOsVersion();\n" + + "public extern getJavaVersion();\n" + + "public extern getJavaVendor();\n" + + "public extern getJavaVendorUrl();\n" + + "public extern getJavaClassPath();\n" + + "public extern getFileSeparator();\n" + + "public extern getLineSeparator();\n" + + "public extern getCaliVersion();\n" + + "public extern getJavaHome();\n" + + "public extern getMills();\n" + + "public sleep(int mills) { this._sleep(mills); return this; }\n" + + "private extern _sleep(int mills);\n" + + "}\n" + + "\n" + ); + iMap.put("reflect.ca", + "// reflect\n" + + "static extern class reflect : com.cali.stdlib.CReflect {\n" + + "// Reflection functions.\n" + + "public evalStr(string CodeStr, string Name = \"evalStr\") { this._evalStr(CodeStr, Name); return this; }\n" + + "public evalFile(string FileName) { this._evalFile(FileName); return this; }\n" + + "public includeModule(string ModuleName) { this._includeModule(ModuleName); return this; }\n" + + "\n" + + "// Not Chained\n" + + "public extern loadedModules();\n" + + "public extern loadedClasses();\n" + + "public extern isModuleLoaded(string ModuleName);\n" + + "public extern classExists(string ClassName);\n" + + "public extern getClassDef(string ClassName);\n" + + "public extern instantiate(string ClassName);\n" + + "public extern invoke(object Object, string MethodName, ...);\n" + + "\n" + + "// Chained extern functions\n" + + "private extern _evalStr(string CodeStr, string Name = \"evalStr\");\n" + + "private extern _evalFile(string FileName);\n" + + "private extern _includeModule(string ModuleName);\n" + + "}\n" + + "\n" + + "extern class rclass : com.cali.stdlib.CClass {\n" + + "// Class object provided by reflection.\n" + + "public extern getName();\n" + + "public extern isStatic();\n" + + "public extern isExtern();\n" + + "public extern getExternClassName();\n" + + "public extern getMembers();\n" + + "public extern getMethods();\n" + + "}\n" + + "\n" + ); + iMap.put("cunit.ca", + "include reflect;\n" + + "\n" + + "class test {\n" + + "private tests = [];\n" + + "private passed = 0;\n" + + "private failed = 0;\n" + + "\n" + + "public test() { }\n" + + "\n" + + "private name = \"\";\n" + + "private silent = false;\n" + + "\n" + + "public setName(string Name = \"\") { this.name = Name; return this; }\n" + + "public setSilent(bool Silent) { this.silent = Silent; return this; }\n" + + "\n" + + "public getName() { return this.name; }\n" + + "public getSlient() { return this.silent; }\n" + + "\n" + + "public add(string TestName, callback ToCall, bool DieOnFail = false) {\n" + + "t = {};\n" + + "t.name = TestName;\n" + + "t.cb = ToCall;\n" + + "t.dieOnFail = DieOnFail;\n" + + "this.tests @= t;\n" + + "return this;\n" + + "}\n" + + "\n" + + "public run() {\n" + + "if(!this.silent) {\n" + + "c.print(\"Running Test [\")\n" + + ".print(\" \" + this.name + \" \")\n" + + ".println(\"]:\")\n" + + ";\n" + + "}\n" + + "\n" + + "for(t : this.tests) {\n" + + "if(!this.silent) {\n" + + "c.print(\" ***\")\n" + + ".print(\" \" + t['name'] + \" \")\n" + + ".print(\"... \")\n" + + ";\n" + + "}\n" + + "try {\n" + + "res = t.cb.call();\n" + + "if(res == true) {\n" + + "this.passed++;\n" + + "if(!this.silent) { c.println(\"PASSED\"); }\n" + + "} else {\n" + + "this.failed++;\n" + + "if(!this.silent) { c.println(\"FAILED\"); }\n" + + "if(t['dieOnFail']) { break; }\n" + + "}\n" + + "} catch(e) {\n" + + "this.failed++;\n" + + "if(!this.silent) {\n" + + "c.println(\"FAILED\")\n" + + ".err(e.getMessage() + \"\n\" + e.getTrace())\n" + + ";\n" + + "if(t['dieOnFail']) { break; }\n" + + "}\n" + + "}\n" + + "}\n" + + "if(!this.silent) { this.printResult(); }\n" + + "return this;\n" + + "}\n" + + "\n" + + "private printResult() {\n" + + "c.println(\"\")\n" + + ".print(\"TOTAL:\")\n" + + ".print(\" \" + (#this.tests) + \" \")\n" + + ".print(\"RAN:\")\n" + + ".print(\" \" + (this.passed + this.failed) + \" \")\n" + + ".print(\"PASSED:\")\n" + + ".print(\" \" + this.passed + \" \")\n" + + ";\n" + + "if(this.failed > 0) {\n" + + "c.print(\"FAILED:\")\n" + + ".print(\" \" + this.failed + \" \")\n" + + ";\n" + + "}\n" + + "c.println(\"\n\");\n" + + "return this;\n" + + "}\n" + + "\n" + + "public getResults() {\n" + + "res = {};\n" + + "res['name'] = this.name;\n" + + "res['total'] = #this.tests;\n" + + "res['ran'] = this.passed + this.failed;\n" + + "res['passed'] = this.passed;\n" + + "res['failed'] = this.failed;\n" + + "return res;\n" + + "}\n" + + "\n" + + "public expect(Item, ToBe) { if(Item == ToBe) { return true; } return false; }\n" + + "public expectNotNull(Item) { if(Item == null) { return false; } return true; }\n" + + "public expectNull(Item) { if(Item == null) { return true; } return false; }\n" + + "public expectString(Item) { if(lang.type(Item) == \"string\") { return true; } return false; }\n" + + "public expectBool(Item) { if(lang.type(Item) == \"bool\") { return true; } return false; }\n" + + "public expectInt(Item) { if(lang.type(Item) == \"int\") { return true; } return false; }\n" + + "public expectDouble(Item) { if(lang.type(Item) == \"double\") { return true; } return false; }\n" + + "public expectNumber(Item) { if((lang.type(Item) == \"int\")||(lang.type(Item) == \"double\")) { return true; } return false; }\n" + + "public expectList(Item) { if(lang.type(Item) == \"list\") { return true; } return false; }\n" + + "public expectMap(Item) { if(lang.type(Item) == \"map\") { return true; } return false; }\n" + + "public expectObject(Item, string ClassName) { if(lang.type(Item) == ClassName) { return true; } return false; }\n" + + "public expectCallback(Item) { if(lang.type(Item) == \"callback\") { return true; } return false; }\n" + + "}\n" + + "\n" + ); + iMap.put("math.ca", + "// math\n" + + "static extern class math : com.cali.stdlib.CMath {\n" + + "public extern e();\n" + + "public extern pi();\n" + + "public extern abs(Val);\n" + + "public extern acos(double AngleRad);\n" + + "public extern asin(double AngleRad);\n" + + "public extern atan(double AngleRad);\n" + + "public extern cbrt(double Val);\n" + + "public extern ceil(double Val);\n" + + "public extern copySign(double Magnitude, double Sign);\n" + + "public extern cos(double AngleRad);\n" + + "public extern cosh(double AngleRad);\n" + + "public extern exp(double Val);\n" + + "public extern expm1(double Val);\n" + + "public extern floor(double Val);\n" + + "public extern getExponent(double Val);\n" + + "public extern hypot(double X, double Y);\n" + + "public extern IEEEremainder(double Double1, double Double2);\n" + + "public extern log(double Val);\n" + + "public extern log10(double Val);\n" + + "public extern log1p(double Val);\n" + + "public extern max(Val1, Val2);\n" + + "public extern min(Val1, Val2);\n" + + "public extern nextAfter(double Double1, double Double2);\n" + + "public extern nextUp(double Val);\n" + + "public extern pow(double Double1, double Double2);\n" + + "public extern rand();\n" + + "public extern rint(double Val);\n" + + "public extern round(double Val);\n" + + "public extern scalb(double DoubleVal, int IntVal);\n" + + "public extern signum(double Val);\n" + + "public extern sin(double Val);\n" + + "public extern sinh(double Val);\n" + + "public extern sqrt(double Val);\n" + + "public extern tan(double Val);\n" + + "public extern tanh(double Val);\n" + + "public extern toDeg(double Val);\n" + + "public extern toRad(double Val);\n" + + "public extern ulp(double Val);\n" + + "}\n" + + "\n" + ); + langIncludes = Collections.unmodifiableMap(iMap); + } +} diff --git a/cali.lang.base/src/com/cali/stdlib/SBool.java b/cali.lang.base/src/com/cali/stdlib/SBool.java new file mode 100644 index 0000000..7c7e475 --- /dev/null +++ b/cali.lang.base/src/com/cali/stdlib/SBool.java @@ -0,0 +1,29 @@ +/* + * Copyright 2017 Austin Lehman + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.cali.stdlib; + +import java.util.ArrayList; + +import com.cali.types.CaliBool; +import com.cali.types.CaliString; +import com.cali.types.CaliType; + +public class SBool { + public static CaliType parse(ArrayList args) { + return new CaliBool(Boolean.parseBoolean(((CaliString)args.get(0)).getValue())); + } +} diff --git a/cali.lang.base/src/com/cali/stdlib/SDouble.java b/cali.lang.base/src/com/cali/stdlib/SDouble.java new file mode 100644 index 0000000..141aa83 --- /dev/null +++ b/cali.lang.base/src/com/cali/stdlib/SDouble.java @@ -0,0 +1,71 @@ +/* + * Copyright 2017 Austin Lehman + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.cali.stdlib; + +import java.util.ArrayList; + +import com.cali.types.CaliDouble; +import com.cali.types.CaliException; +import com.cali.types.CaliInt; +import com.cali.types.CaliString; +import com.cali.types.CaliType; + +public class SDouble { + public static CaliType maxExp(ArrayList args) { + return new CaliInt(Double.MAX_EXPONENT); + } + + public static CaliType maxVal(ArrayList args) { + return new CaliDouble(Double.MAX_VALUE); + } + + public static CaliType minExp(ArrayList args) { + return new CaliInt(Double.MIN_EXPONENT); + } + + public static CaliType minNormal(ArrayList args) { + return new CaliDouble(Double.MIN_NORMAL); + } + + public static CaliType minVal(ArrayList args) { + return new CaliDouble(Double.MIN_VALUE); + } + + public static CaliType nanVal(ArrayList args) { + return new CaliDouble(Double.NaN); + } + + public static CaliType negInfinity(ArrayList args) { + return new CaliDouble(Double.NEGATIVE_INFINITY); + } + + public static CaliType posInfinity(ArrayList args) { + return new CaliDouble(Double.POSITIVE_INFINITY); + } + + public static CaliType size(ArrayList args) { + return new CaliInt(Double.SIZE); + } + + public static CaliType parse(ArrayList args) { + try { + return new CaliDouble(Double.parseDouble(((CaliString)args.get(0)).getValue())); + } catch(Exception e) { + return new CaliException("Double.parse(): Double parse exception."); + } + } +} diff --git a/cali.lang.base/src/com/cali/stdlib/SInt.java b/cali.lang.base/src/com/cali/stdlib/SInt.java new file mode 100644 index 0000000..dbcbcef --- /dev/null +++ b/cali.lang.base/src/com/cali/stdlib/SInt.java @@ -0,0 +1,46 @@ +/* + * Copyright 2017 Austin Lehman + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.cali.stdlib; + +import java.util.ArrayList; + +import com.cali.types.CaliException; +import com.cali.types.CaliInt; +import com.cali.types.CaliString; +import com.cali.types.CaliType; + +public class SInt { + public static CaliType parse(ArrayList args) { + try { + if(args.get(1).isNull()) { + return new CaliInt(Long.parseLong(((CaliString)args.get(0)).getValue())); + } else { + return new CaliInt(Long.parseLong(((CaliString)args.get(0)).getValue(), (int)((CaliInt)args.get(1)).getValue())); + } + } catch(Exception e) { + return new CaliException("Int.parse(): Integer parse exception."); + } + } + + public static CaliType maxVal(ArrayList args) { + return new CaliInt(Long.MAX_VALUE); + } + + public static CaliType minVal(ArrayList args) { + return new CaliInt(Long.MIN_VALUE); + } +} diff --git a/cali.lang.base/src/com/cali/stdlib/console.java b/cali.lang.base/src/com/cali/stdlib/console.java new file mode 100644 index 0000000..ef53e95 --- /dev/null +++ b/cali.lang.base/src/com/cali/stdlib/console.java @@ -0,0 +1,84 @@ +/* + * Copyright 2017 Austin Lehman + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.cali.stdlib; + +import java.util.ArrayList; + +import com.cali.types.CaliNull; +import com.cali.types.CaliType; +import com.cali.types.CaliTypeInt; + +public class console { + static console instance = null; + + public console() { + this.init(); + } + + public void init() { + // Do any initialization here! + } + + public static console get() { + if(instance == null) instance = new console(); + return instance; + } + + public console log(String Str) { return this.println(Str); } + public console info(String Str) { return this.println("[info] " + Str); } + public console warn(String Str) { return this.println("[warn] " + Str); } + public console err(String Str) { return this.println("[error] " + Str); } + + public synchronized console print(String Text) { + System.out.print(Text); + System.out.flush(); + return this; + } + + public console println(String Text) { this.print(Text + "\n"); return this; } + + public CaliType _log(ArrayList args) { + this.log(((CaliTypeInt)args.get(0)).str()); + return new CaliNull(); + } + + public CaliType _info(ArrayList args) { + this.info(((CaliTypeInt)args.get(0)).str()); + return new CaliNull(); + } + + public CaliType _warn(ArrayList args) { + this.warn(((CaliTypeInt)args.get(0)).str()); + return new CaliNull(); + } + + public CaliType _err(ArrayList args) { + this.err(((CaliTypeInt)args.get(0)).str()); + return new CaliNull(); + } + + public CaliType _print(ArrayList args) { + this.print(((CaliTypeInt)args.get(0)).str()); + return new CaliNull(); + } + + public CaliType _println(ArrayList args) { + CaliType ret = this._print(args); + System.out.println(); + return ret; + } +} diff --git a/cali.lang.base/src/com/cali/sym.java b/cali.lang.base/src/com/cali/sym.java new file mode 100644 index 0000000..7d730af --- /dev/null +++ b/cali.lang.base/src/com/cali/sym.java @@ -0,0 +1,80 @@ + +//---------------------------------------------------- +// The following code was generated by CUP v0.11b 20140703 (SVN rev 36) +// Wed Mar 29 21:03:29 PDT 2017 +//---------------------------------------------------- + +package com.cali; + +/** CUP generated class containing symbol constants. */ +public class sym { + /* terminals */ + public static final int DI = 50; + public static final int GTEQ = 58; + public static final int LBRACKET = 30; + public static final int PL = 47; + public static final int DIEQ = 43; + public static final int LTEQ = 57; + public static final int MI = 48; + public static final int UMINUS = 52; + public static final int PLPL = 45; + public static final int MODULUSEQ = 44; + public static final int CASE = 19; + public static final int DOUBLE = 36; + public static final int LPAREN = 28; + public static final int PRIVATE = 7; + public static final int SEMI = 25; + public static final int CLASSDEF = 2; + public static final int INT = 35; + public static final int FOR = 23; + public static final int MIMI = 46; + public static final int INSTANCEOF = 24; + public static final int STATIC = 8; + public static final int RPAREN = 29; + public static final int AND = 60; + public static final int NOT = 59; + public static final int LT = 55; + public static final int ETCETERA = 63; + public static final int OR = 61; + public static final int BOOL = 34; + public static final int COMMA = 27; + public static final int THROW = 13; + public static final int MUEQ = 42; + public static final int EXTERN = 9; + public static final int IF = 16; + public static final int DOT = 66; + public static final int EOF = 0; + public static final int RETURN = 10; + public static final int RBRACKET = 31; + public static final int NEW = 14; + public static final int error = 1; + public static final int INCLUDE = 4; + public static final int EQEQ = 53; + public static final int NULL = 15; + public static final int TRY = 11; + public static final int IDENT = 38; + public static final int BREAK = 22; + public static final int EQ = 39; + public static final int SWITCH = 18; + public static final int PLEQ = 40; + public static final int COLON = 26; + public static final int LBRACE = 32; + public static final int ELSE = 17; + public static final int PROTECTED = 6; + public static final int CALLBACK = 64; + public static final int ENUM = 3; + public static final int WHILE = 21; + public static final int INSERT = 65; + public static final int MIEQ = 41; + public static final int DEFAULT = 20; + public static final int PUBLIC = 5; + public static final int RBRACE = 33; + public static final int MODULUS = 51; + public static final int STRING = 37; + public static final int COUNT = 62; + public static final int GT = 56; + public static final int MU = 49; + public static final int NOTEQ = 54; + public static final int CATCH = 12; +} + diff --git a/cali.lang.base/src/com/cali/types/CaliBool.java b/cali.lang.base/src/com/cali/types/CaliBool.java new file mode 100644 index 0000000..8872136 --- /dev/null +++ b/cali.lang.base/src/com/cali/types/CaliBool.java @@ -0,0 +1,99 @@ +/* + * Copyright 2017 Austin Lehman + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.cali.types; + +import java.util.ArrayList; + +import com.cali.Universe; +import com.cali.ast.caliException; + +public class CaliBool extends CaliObject implements CaliTypeInt { + private boolean value = false; + + public CaliBool() { + this.setType(cType.cBool); + + // Setup linkage for string object. + this.setExternObject(this); + try { + this.setClassDef(Universe.get().getClassDef("bool")); + } catch (caliException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + } + + public CaliBool(boolean Value) { + this(); + this.setValue(Value); + } + + public boolean getValue() { + return this.value; + } + + public void setValue(boolean value) { + this.value = value; + } + + @Override + public String toString(int Level) { + String rstr = ""; + rstr += CaliType.getTabs(Level) + "{\n"; + rstr += CaliType.getTabs(Level + 1) + "\"type\": \"" + this.getType().name() + "\",\n"; + rstr += CaliType.getTabs(Level + 1) + "\"value\": "; + if (this.value) rstr += "true"; + else rstr += "false"; + rstr += "\n"; + rstr += CaliType.getTabs(Level) + "}"; + return rstr; + } + + @Override + public String str() { + if (this.value) return new String("true"); + return new String("false"); + } + + public String str(int Level) { + return this.str(); + } + + public CaliType toInt(ArrayList args) { + if (this.value) return new CaliInt(1); + return new CaliInt(0); + } + + public CaliType toDouble(ArrayList args) { + if (this.value) return new CaliDouble(1.0); + return new CaliDouble(0.0); + } + + public CaliType toString(ArrayList args) { + if (this.value) return new CaliString("true"); + return new CaliString("false"); + } + + public CaliType compare(ArrayList args) { + return new CaliInt(Boolean.compare(this.value, ((CaliBool)args.get(0)).getValue())); + } + + public CaliType parse(ArrayList args) { + this.value = Boolean.parseBoolean(((CaliString)args.get(0)).getValue()); + return this; + } +} diff --git a/cali.lang.base/src/com/cali/types/CaliBreak.java b/cali.lang.base/src/com/cali/types/CaliBreak.java new file mode 100644 index 0000000..7d788c2 --- /dev/null +++ b/cali.lang.base/src/com/cali/types/CaliBreak.java @@ -0,0 +1,37 @@ +/* + * Copyright 2017 Austin Lehman + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.cali.types; + +public class CaliBreak extends CaliType implements CaliTypeInt { + public CaliBreak() { + this.setType(cType.cBreak); + } + + @Override + public String toString(int Level) { + String rstr = ""; + rstr += CaliType.getTabs(Level) + "{\n"; + rstr += CaliType.getTabs(Level + 1) + "\"type\": \"" + this.getType().name() + "\"\n"; + rstr += CaliType.getTabs(Level) + "}"; + return rstr; + } + + @Override + public String str() { + return "break"; + } +} diff --git a/cali.lang.base/src/com/cali/types/CaliCallback.java b/cali.lang.base/src/com/cali/types/CaliCallback.java new file mode 100644 index 0000000..5e33c26 --- /dev/null +++ b/cali.lang.base/src/com/cali/types/CaliCallback.java @@ -0,0 +1,113 @@ +/* + * Copyright 2017 Austin Lehman + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.cali.types; + +import java.util.ArrayList; + +import com.cali.Environment; +import com.cali.Universe; +import com.cali.ast.astClass; +import com.cali.ast.caliException; +import com.cali.stdlib.console; + +public class CaliCallback extends CaliObject implements CaliTypeInt { + private String functName = ""; + private CaliObject obj = null; + private Environment tenv = null; + + public CaliCallback() { + this.setType(cType.cCallback); + + // Setup linkage for string object. + this.setExternObject(this); + try { + this.setClassDef(Universe.get().getClassDef("callback")); + } catch (caliException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + } + + public CaliCallback(Environment Env, CaliObject Obj, String FunctName) { + this(); + this.tenv = Env; + this.obj = Obj; + this.functName = FunctName; + } + + public CaliType call(CaliList args) { + return this.call(this.tenv, args); + } + + public CaliType call(Environment env, CaliList args) { + CaliType ret = new CaliNull(); + + try { + ret = this.callWithException(env, args); + } catch(caliException e) { + console.get().err("\n" + e.getCaliStackTrace()); + return new CaliException(e.getMessage()); + } + + return ret; + } + + public CaliType callWithException(Environment env, CaliList args) throws caliException { + CaliType ret = new CaliNull(); + + CaliObject tobj = (CaliObject) env.getCurObj(); + env.setCurObj(this.getObj()); + try { + astClass ac = this.obj.getClassDef(); + ret = ac.call(env, false, this.getFunctName(), args); + } catch(caliException e) { + env.setCurObj(tobj); + throw e; + } + env.setCurObj(tobj); + + return ret; + } + + public String getFunctName() { + return functName; + } + + public void setFunctName(String functName) { + this.functName = functName; + } + + public CaliObject getObj() { + return obj; + } + + public void setObj(CaliObject obj) { + this.obj = obj; + } + + public Environment getEnv() { + return tenv; + } + + public void setEnv(Environment env) { + this.tenv = env; + } + + public CaliType _call(ArrayList args) { + return this.call((CaliList)args.get(0)); + } +} diff --git a/cali.lang.base/src/com/cali/types/CaliDouble.java b/cali.lang.base/src/com/cali/types/CaliDouble.java new file mode 100644 index 0000000..1740966 --- /dev/null +++ b/cali.lang.base/src/com/cali/types/CaliDouble.java @@ -0,0 +1,110 @@ +/* + * Copyright 2017 Austin Lehman + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.cali.types; + +import java.util.ArrayList; + +import com.cali.Universe; +import com.cali.ast.caliException; + +public class CaliDouble extends CaliObject implements CaliTypeInt { + private double value = 0.0; + + public CaliDouble() { + this.setType(cType.cDouble); + + // Setup linkage for string object. + this.setExternObject(this); + try { + this.setClassDef(Universe.get().getClassDef("double")); + } catch (caliException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + } + + public CaliDouble(double Value) { + this(); + this.value = Value; + } + + public void setValue(double Value) { + this.value = Value; + } + + public double getValue() { + return this.value; + } + + @Override + public String toString(int Level) { + String rstr = ""; + rstr += CaliType.getTabs(Level) + "{\n"; + rstr += CaliType.getTabs(Level + 1) + "\"type\": \"" + this.getType().name() + "\",\n"; + rstr += CaliType.getTabs(Level + 1) + "\"value\": " + this.value + "\n"; + rstr += CaliType.getTabs(Level) + "}"; + return rstr; + } + + @Override + public String str() { + return "" + this.value; + } + + public String str(int Level) { + return this.str(); + } + + public CaliType toInt(ArrayList args) { + return new CaliInt((int)this.value); + } + + public CaliType toBool(ArrayList args) { + if (this.value == 0.0) { + return new CaliBool(false); + } + return new CaliBool(true); + } + + public CaliType toString(ArrayList args) { + return new CaliString("" + this.value); + } + + public CaliType compare(ArrayList args) { + return new CaliInt(Double.compare(this.value, ((CaliDouble)args.get(0)).getValue())); + } + + public CaliType isInfinite(ArrayList args) { + return new CaliBool(Double.isInfinite(this.value)); + } + + public CaliType isNan(ArrayList args) { + return new CaliBool(Double.isNaN(this.value)); + } + + public CaliType parse(ArrayList args) { + try { + return new CaliDouble(Double.parseDouble(((CaliString)args.get(0)).getValue())); + } catch(Exception e) { + return new CaliException("double.parse(): Double parse exception."); + } + } + + public CaliType toHex(ArrayList args) { + return new CaliString(Double.toHexString(this.value)); + } +} diff --git a/cali.lang.base/src/com/cali/types/CaliException.java b/cali.lang.base/src/com/cali/types/CaliException.java new file mode 100644 index 0000000..24bce21 --- /dev/null +++ b/cali.lang.base/src/com/cali/types/CaliException.java @@ -0,0 +1,201 @@ +/* + * Copyright 2017 Austin Lehman + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.cali.types; + +import java.util.ArrayList; + +import com.cali.Universe; +import com.cali.ast.caliException; + +public class CaliException extends CaliObject implements CaliTypeInt { + public enum exType { + exUndef, + exInternal, + exRuntime + }; + + private exType et = exType.exUndef; + private int lineNumber = -1; + private String id = ""; + private String text = ""; + private String details = ""; + private String stackTrace = ""; + + public CaliException() { + this.setType(cType.cException); + + // Setup linkage for string object. + this.setExternObject(this); + try { + this.setClassDef(Universe.get().getClassDef("exception")); + } catch (caliException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + } + + public CaliException(exType ExType) { + this(); + this.et = ExType; + } + + public CaliException(String Text) { + this(exType.exRuntime); + this.text = Text; + this.details = Text; + } + + public void setException(int LineNum, String Id, String Text, String Details, String StackTrace) { + this.lineNumber = LineNum; + this.id = Id; + this.text = Text; + this.details = Details; + this.stackTrace = StackTrace; + } + + public void setException(int LineNum, String Id, String Text, String StackTrace) { + this.lineNumber = LineNum; + this.id = Id; + this.text = Text; + this.details = Text; + this.stackTrace = StackTrace; + } + + public exType getEt() { + return et; + } + + public void setEt(exType et) { + this.et = et; + } + + public String getId() { + return id; + } + + public void setId(String id) { + this.id = id; + } + + public String getText() { + return text; + } + + public void setText(String text) { + this.text = text; + } + + public String getDetails() { + return details; + } + + public void setDetails(String details) { + this.details = details; + } + + public String getStackTrace() { + return stackTrace; + } + + public void setStackTrace(String stackTrace) { + this.stackTrace = stackTrace; + } + + public int getLineNumber() { + return lineNumber; + } + + public void setLineNumber(int lineNumber) { + this.lineNumber = lineNumber; + } + + public String getExceptionTypeString() { + return this.et.name(); + } + + public String stackTraceToString() { + String rstr = "line "; + rstr += this.lineNumber; + rstr += ": "; + rstr += this.et.name(); + rstr += " Exception. [" + this.id + "] :: " + text + "\n"; + rstr += this.stackTrace; + return rstr; + } + + @Override + public String toString(int Level) { + String rstr = ""; + + rstr += CaliType.getTabs(Level); + rstr += "line "; + rstr += this.lineNumber; + rstr += ": "; + rstr += "["; + rstr += this.getType().name(); + rstr += "] "; + rstr += this.et.name(); + rstr += " Exception\n"; + + rstr += CaliType.getTabs(Level + 1); + rstr += "id: " + this.id + "\n"; + + rstr += CaliType.getTabs(Level + 1); + rstr += "text: " + this.text + "\n"; + + rstr += CaliType.getTabs(Level + 1); + rstr += "details: " + this.details + "\n"; + + rstr += CaliType.getTabs(Level + 1); + rstr += "stackTrace: " + this.stackTrace + "\n"; + + return rstr; + } + + @Override + public String str() { + return this.stackTraceToString(); + } + + public String str(int Level) { + return this.str(); + } + + public CaliType getLineNumber(ArrayList args) { + return new CaliInt(this.lineNumber); + } + + public CaliType getExceptionType(ArrayList args) { + return new CaliString(this.et.name()); + } + + public CaliType getId(ArrayList args) { + return new CaliString(this.id); + } + + public CaliType getText(ArrayList args) { + return new CaliString(this.text); + } + + public CaliType getDetails(ArrayList args) { + return new CaliString(this.details); + } + + public CaliType getStackTrace(ArrayList args) { + return new CaliString(this.stackTrace); + } +} diff --git a/cali.lang.base/src/com/cali/types/CaliInt.java b/cali.lang.base/src/com/cali/types/CaliInt.java new file mode 100644 index 0000000..0bd397b --- /dev/null +++ b/cali.lang.base/src/com/cali/types/CaliInt.java @@ -0,0 +1,142 @@ +/* + * Copyright 2017 Austin Lehman + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.cali.types; + +import java.util.ArrayList; + +import com.cali.Universe; +import com.cali.ast.caliException; + +public class CaliInt extends CaliObject implements CaliTypeInt { + private long value = 0L; + + public CaliInt() { + this.setType(cType.cInt); + + // Setup linkage for string object. + this.setExternObject(this); + try { + this.setClassDef(Universe.get().getClassDef("int")); + } catch (caliException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + } + + public CaliInt(long Value) { + this(); + this.value = Value; + } + + public void setValue(long Value) { + this.value = Value; + } + + public long getValue() { + return this.value; + } + + @Override + public String toString(int Level) { + String rstr = ""; + rstr += CaliType.getTabs(Level) + "{\n"; + rstr += CaliType.getTabs(Level + 1) + "\"type\": \"" + this.getType().name() + "\",\n"; + rstr += CaliType.getTabs(Level + 1) + "\"value\": " + this.value + "\n"; + rstr += CaliType.getTabs(Level) + "}"; + return rstr; + } + + @Override + public String str() { + return "" + this.value; + } + + public String str(int Level) { + return this.str(); + } + + public CaliType toDouble(ArrayList args) { + return new CaliDouble((double)this.value); + } + + public CaliType toBool(ArrayList args) { + if (this.value == 0) { + return new CaliBool(false); + } + return new CaliBool(true); + } + + public CaliType toString(ArrayList args) { + return new CaliString("" + this.value); + } + + public CaliType compare(ArrayList args) { + return new CaliInt(Long.compare(this.value, ((CaliInt)args.get(0)).getValue())); + } + + public CaliType numLeadingZeros(ArrayList args) { + return new CaliInt(Long.numberOfLeadingZeros(this.value)); + } + + public CaliType numTrailingZeros(ArrayList args) { + return new CaliInt(Long.numberOfTrailingZeros(this.value)); + } + + public CaliType reverse(ArrayList args) { + return new CaliInt(Long.reverse(this.value)); + } + + public CaliType reverseBytes(ArrayList args) { + return new CaliInt(Long.reverseBytes(this.value)); + } + + public CaliType rotateLeft(ArrayList args) { + return new CaliInt(Long.rotateLeft(this.value, (int)((CaliInt)args.get(0)).getValue())); + } + + public CaliType rotateRight(ArrayList args) { + return new CaliInt(Long.rotateRight(this.value, (int)((CaliInt)args.get(0)).getValue())); + } + + public CaliType signum(ArrayList args) { + return new CaliInt(Long.signum(this.value)); + } + + public CaliType toBinary(ArrayList args) { + return new CaliString(Long.toBinaryString(this.value)); + } + + public CaliType toHex(ArrayList args) { + return new CaliString(Long.toHexString(this.value)); + } + + public CaliType toOctal(ArrayList args) { + return new CaliString(Long.toOctalString(this.value)); + } + + public CaliType parse(ArrayList args) { + try { + if(args.get(1).isNull()) { + return new CaliInt(Long.parseLong(((CaliString)args.get(0)).getValue())); + } else { + return new CaliInt(Long.parseLong(((CaliString)args.get(0)).getValue(), (int)((CaliInt)args.get(1)).getValue())); + } + } catch(Exception e) { + return new CaliException("int.parse(): Integer parse exception."); + } + } +} diff --git a/cali.lang.base/src/com/cali/types/CaliList.java b/cali.lang.base/src/com/cali/types/CaliList.java new file mode 100644 index 0000000..5baa336 --- /dev/null +++ b/cali.lang.base/src/com/cali/types/CaliList.java @@ -0,0 +1,281 @@ +/* + * Copyright 2017 Austin Lehman + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.cali.types; + +import java.util.ArrayList; +import java.util.Collections; + +import com.cali.Universe; +import com.cali.Util; +import com.cali.ast.caliException; +import com.cali.types.CaliListComparator.SortOrder; + +public class CaliList extends CaliObject implements CaliTypeInt { + private ArrayList value = new ArrayList(); + + public CaliList() { + this(true); + } + + public CaliList(boolean LinkClass) { + this.setType(cType.cList); + + if (LinkClass) { + // Setup linkage for string object. + this.setExternObject(this); + try { + this.setClassDef(Universe.get().getClassDef("list")); + } catch (caliException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + } + } + + public CaliList(ArrayList Value) { + this(); + this.value = Value; + } + + public void add(CaliType Val) { + this.value.add(Val); + } + + public int size() { + return this.value.size(); + } + + public ArrayList getValue() { + return value; + } + + public void setValue(ArrayList value) { + this.value = value; + } + + @Override + public String toString(int Level) { + String rstr = ""; + + rstr += CaliType.getTabs(Level) + "{\n"; + rstr += CaliType.getTabs(Level + 1) + "\"type\": \"" + this.getType().name() + "\",\n"; + rstr += CaliType.getTabs(Level + 1) + "\"length\": " + this.value.size() + ",\n"; + rstr += CaliType.getTabs(Level + 1) + "\"values\": [\n"; + for (int i = 0; i < this.value.size(); i++) { + rstr += ((CaliTypeInt)this.value.get(i)).toString(Level + 2) + ",\n"; + } + rstr += CaliType.getTabs(Level + 1) + "]\n"; + rstr += CaliType.getTabs(Level) + "}"; + + return rstr; + } + + @Override + public String str() { + return this.str(0); + } + + public String str(int Level) { + if (this.value.size() > 0) { + String rstr = "[\n"; + int count = 0; + for (CaliType child : this.value) { + rstr += getTabs(Level + 1) + ((CaliObject)child).str(Level + 1); + count++; + if (count < this.value.size()) { + rstr += ","; + } + rstr += "\n"; + } + rstr += getTabs(Level) + "]"; + return rstr; + } else { + return "[]"; + } + } + + public CaliType add(ArrayList args) { + this.value.add(args.get(0)); + return this; + } + + public CaliType addAll(ArrayList args) { + this.value.addAll(((CaliList)args.get(0)).getValue()); + return this; + } + + public CaliType addAllAt(ArrayList args) { + this.value.addAll((int)((CaliInt)args.get(1)).getValue(), ((CaliList)args.get(0)).getValue()); + return this; + } + + public CaliType clear(ArrayList args) { + this.value.clear(); + return this; + } + + @SuppressWarnings("unchecked") + public CaliType clone(ArrayList args) { + CaliList nl = new CaliList(); + nl.setValue((ArrayList) this.value.clone()); + return nl; + } + + public CaliType contains(ArrayList args) { + CaliType mn = args.get(0); + + for(CaliType n : this.value) { + if(mn.isNull()) { + if(n.isNull()) { + return new CaliBool(true); + } + } else if(mn instanceof CaliBool) { + if((n instanceof CaliBool)&&(((CaliBool)n).getValue() == ((CaliBool)mn).getValue())) { + return new CaliBool(true); + } + } else if(mn instanceof CaliInt) { + if((n instanceof CaliInt)&&((CaliInt)n).getValue() == ((CaliInt)mn).getValue()) { + return new CaliBool(true); + } + } else if(mn instanceof CaliDouble) { + if((n instanceof CaliDouble)&&(((CaliDouble)n).getValue() == ((CaliDouble)mn).getValue())) { + return new CaliBool(true); + } + } else if(mn instanceof CaliString) { + if((n instanceof CaliString)&&(((CaliString)n).getValue().equals(((CaliString)mn).getValue()))) { + return new CaliBool(true); + } + } else if(mn instanceof CaliCallback) { + if((n instanceof CaliCallback)&&(((CaliCallback)n).getFunctName().equals(((CaliCallback)mn).getFunctName()))) { + return new CaliBool(true); + } + } + } + + return new CaliBool(false); + } + + public CaliType containsObjRef(ArrayList args) { + return new CaliBool(this.value.contains(args.get(0))); + } + + public CaliType get(ArrayList args) { + int index = (int) ((CaliInt)args.get(0)).getValue(); + if(index >= 0 && index < this.value.size()) { + return this.value.get(index); + } else { + return new CaliException("list.get(): Index out of bounds."); + } + } + + public CaliType indexOf(ArrayList args) { + return new CaliInt(this.value.indexOf(args.get(0))); + } + + public CaliType isEmpty(ArrayList args) { + return new CaliBool(this.value.isEmpty()); + } + + public CaliType remove(ArrayList args) { + this.value.remove(args.get(0)); + return this; + } + + public CaliType removeAt(ArrayList args) { + int index = (int) ((CaliInt)args.get(0)).getValue(); + if(index >= 0 && index < this.value.size()) { + return (CaliType)this.value.remove(index); + } else { + return new CaliException("list.removeAt(): Index out of bounds."); + } + } + + public CaliType removeAll(ArrayList args) { + return new CaliBool(this.value.removeAll(((CaliList)args.get(0)).getValue())); + } + + public CaliType retainAll(ArrayList args) { + return new CaliBool(this.value.retainAll(((CaliList)args.get(0)).getValue())); + } + + public CaliType set(ArrayList args) { + int index = (int) ((CaliInt)args.get(0)).getValue(); + if(index >= 0 && index < this.value.size()) { + return this.value.set(index, args.get(1)); + } else { + return new CaliException("list.set(): Index out of bounds."); + } + } + + public CaliType size(ArrayList args) { + return new CaliInt(this.value.size()); + } + + public CaliType subList(ArrayList args) { + int bindex = (int)((CaliInt)args.get(0)).getValue(); + int eindex = (int)((CaliInt)args.get(1)).getValue(); + if(eindex >= bindex && bindex >= 0 && eindex <= this.value.size()) { + CaliList ret = new CaliList(); + ret.setValue(new ArrayList(this.value.subList(bindex, eindex))); + return ret; + } else { + return new CaliException("list.subList(): Index out of bounds."); + } + } + + @SuppressWarnings("unchecked") + public CaliType sort(ArrayList args) { + CaliListComparator lc = new CaliListComparator(); + Collections.sort(this.value, lc); + return this; + } + + @SuppressWarnings("unchecked") + public CaliType sortAsc(ArrayList args) { + CaliListComparator lc = new CaliListComparator(); + lc.setSortOrder(SortOrder.ASCENDING); + Collections.sort(this.value, lc); + return this; + } + + public CaliType join(ArrayList args) { + String glue = ((CaliString)args.get(0)).getValue(); + ArrayList parts = new ArrayList(); + + for (CaliType itm : this.value) { + parts.add(((CaliTypeInt)itm).str()); + } + return new CaliString(Util.join(parts, glue)); + } + + @SuppressWarnings("unchecked") + public CaliType sortCustom(ArrayList args) { + CaliCallback onCompare = (CaliCallback)args.get(0); + + CaliListComparator lc = new CaliListComparator(); + lc.setSortOrder(SortOrder.CUSTOM); + lc.setCallback(onCompare); + + try { + Collections.sort(this.value, lc); + } catch(Exception e) { + return new CaliException(e.getMessage()); + } + + return this; + } +} diff --git a/cali.lang.base/src/com/cali/types/CaliListComparator.java b/cali.lang.base/src/com/cali/types/CaliListComparator.java new file mode 100644 index 0000000..bbef581 --- /dev/null +++ b/cali.lang.base/src/com/cali/types/CaliListComparator.java @@ -0,0 +1,120 @@ +/* + * Copyright 2017 Austin Lehman + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.cali.types; + +import java.util.Comparator; + +import com.cali.ast.caliException; + +@SuppressWarnings("rawtypes") +public class CaliListComparator implements Comparator { + public enum SortOrder { ASCENDING, DESCENDING, CUSTOM } + + private SortOrder order = SortOrder.DESCENDING; + public void setSortOrder(SortOrder Order) { this.order = Order; } + + private CaliCallback onCompare = null; + public void setCallback(CaliCallback OnCompare) { this.onCompare = OnCompare; } + + @Override + public int compare(Object o1, Object o2) { + Integer res = 0; + CaliType one = (CaliType)o1; + CaliType two = (CaliType)o2; + + if(this.order == SortOrder.CUSTOM) { + try { + return this.customCompare(one, two); + } catch (caliException e) { + throw new RuntimeException(e.getMessage()); + } + } else { + // Comparing same types + if(one.getType() == two.getType()) { + if(one instanceof CaliString) { + String vone = ((CaliString)one).getValue(); + String vtwo = ((CaliString)two).getValue(); + res = vone.compareTo(vtwo); + } else if(one instanceof CaliBool) { + Boolean vone = ((CaliBool)one).getValue(); + Boolean vtwo = ((CaliBool)two).getValue(); + res = vone.compareTo(vtwo); + } else if(one instanceof CaliInt) { + Long vone = ((CaliInt)one).getValue(); + Long vtwo = ((CaliInt)two).getValue(); + res = vone.compareTo(vtwo); + } else if(one instanceof CaliDouble) { + Double vone = ((CaliDouble)one).getValue(); + Double vtwo = ((CaliDouble)two).getValue(); + res = vone.compareTo(vtwo); + } else if( + one instanceof CaliList + || one instanceof CaliMap + || one.getType() == cType.cCallback + ) { + String vone = ((CaliTypeInt)one).str(); + String vtwo = ((CaliTypeInt)two).str(); + res = vone.compareTo(vtwo); + } else if(one.getType() == cType.cObject) { + String vone = ((CaliObject)one).getClassDef().getName(); + String vtwo = ((CaliObject)two).getClassDef().getName(); + res = vone.compareTo(vtwo); + } else if(one.isNull()) { + res = 0; + } + } else if(one instanceof CaliInt && two instanceof CaliDouble) { + Double vone = (double)((CaliInt)one).getValue(); + Double vtwo = ((CaliDouble)two).getValue(); + res = vone.compareTo(vtwo); + } else if(one instanceof CaliDouble && two instanceof CaliInt) { + Double vone = ((CaliDouble)one).getValue(); + Double vtwo = (double)((CaliInt)two).getValue(); + res = vone.compareTo(vtwo); + } else if(one.isNull()) { + res = -1; + } else if(two.isNull()) { + res = 1; + } else { + String vone = ((CaliTypeInt)one).str(); + String vtwo = ((CaliTypeInt)two).str(); + res = vone.compareTo(vtwo); + } + + if(this.order == SortOrder.DESCENDING) return res; + else return res * -1; + } + } + + private int customCompare(CaliType one, CaliType two) throws caliException + { + int ret = 0; + if(this.onCompare != null) { + CaliList args = new CaliList(); + args.add(one); + args.add(two); + CaliType retInt = this.onCompare.call(args); + if(retInt instanceof CaliInt) + ret = (int) ((CaliInt)retInt).getValue(); + else + throw new caliException("CaliListComparator.compareCustom(): Result from callback expects type of int, but found " + retInt.getType().name() + " instead."); + } + else + throw new caliException("CaliListComparator.compareCustom(): Callback OnCompare is null."); + + return ret; + } +} diff --git a/cali.lang.base/src/com/cali/types/CaliMap.java b/cali.lang.base/src/com/cali/types/CaliMap.java new file mode 100644 index 0000000..0c9d1b5 --- /dev/null +++ b/cali.lang.base/src/com/cali/types/CaliMap.java @@ -0,0 +1,181 @@ +/* + * Copyright 2017 Austin Lehman + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.cali.types; + +import java.util.ArrayList; +import java.util.concurrent.ConcurrentHashMap; + +import com.cali.Universe; +import com.cali.ast.caliException; + +public class CaliMap extends CaliObject implements CaliTypeInt { + private ConcurrentHashMap value = new ConcurrentHashMap(); + + public CaliMap() { + this(true); + } + + public CaliMap(boolean LinkClass) { + this.setType(cType.cMap); + + if (LinkClass) { + // Setup linkage for string object. + this.setExternObject(this); + try { + this.setClassDef(Universe.get().getClassDef("map")); + } catch (caliException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + } + } + + public CaliMap(ConcurrentHashMap Value) { + this(true); + this.value = Value; + } + + public ConcurrentHashMap getValue() { + return value; + } + + public void setValue(ConcurrentHashMap value) { + this.value = value; + } + + public int size() { + return this.value.size(); + } + + public boolean contains(String Key) { + return this.value.containsKey(Key); + } + + public void put(String Key, CaliType Val) { + this.value.put(Key, Val); + } + + @Override + public String toString(int Level) { + String rstr = ""; + + rstr += CaliType.getTabs(Level) + "{\n"; + rstr += CaliType.getTabs(Level + 1) + "\"type\": \"" + this.getType().name() + "\",\n"; + rstr += CaliType.getTabs(Level + 1) + "\"values\": {\n"; + for (String Key : this.value.keySet()) { + CaliType Val = this.value.get(Key); + rstr += CaliType.getTabs(Level + 2) + Key + ":\n"; + rstr += ((CaliTypeInt)Val).toString(Level + 2) + ",\n"; + } + rstr += CaliType.getTabs(Level + 1) + "}\n"; + rstr += CaliType.getTabs(Level) + "}"; + + return rstr; + } + + @Override + public String str() { + return this.str(0); + } + + public String str(int Level) { + if (this.value.size() > 0) { + String rstr = "{\n"; + int count = 0; + for (String name : this.value.keySet()) { + rstr += getTabs(Level + 1) + "\"" + name + "\": "; + CaliType child = this.value.get(name); + rstr += ((CaliObject)child).str(Level + 1); + count++; + if (count < this.value.size()) { + rstr += ","; + } + rstr += "\n"; + } + rstr += getTabs(Level) + "}"; + return rstr; + } else { + return "{}"; + } + } + + public CaliType clear(ArrayList args) { + this.value.clear(); + return this; + } + + public CaliType containsKey(ArrayList args) { + return new CaliBool(this.value.containsKey(((CaliString)args.get(0)).getValue())); + } + + public CaliType containsVal(ArrayList args) { + return new CaliBool(this.value.containsValue(args.get(0))); + } + + public CaliType get(ArrayList args) { + return this.value.get(((CaliString)args.get(0)).getValue()); + } + + public CaliType isEmpty(ArrayList args) { + return new CaliBool(this.value.isEmpty()); + } + + public CaliType keySet(ArrayList args) { + CaliList lst = new CaliList(); + for (String str : this.value.keySet()) { + lst.add(new CaliString(str)); + } + return lst; + } + + public CaliType put(ArrayList args) { + this.value.put(((CaliString)args.get(0)).getValue(), args.get(1)); + return this; + } + + public CaliType putAll(ArrayList args) { + CaliMap mp = (CaliMap)args.get(0); + this.value.putAll(mp.getValue()); + return this; + } + + public CaliType putIfAbsent(ArrayList args) { + this.value.putIfAbsent(((CaliString)args.get(0)).getValue(), args.get(1)); + return this; + } + + public CaliType remove(ArrayList args) { + Object ret = this.value.remove(((CaliString)args.get(0)).getValue()); + if (ret == null) { + return new CaliNull(); + } else { + return (CaliType) ret; + } + } + + public CaliType size(ArrayList args) { + return new CaliInt(this.value.size()); + } + + public CaliType values(ArrayList args) { + CaliList lst = new CaliList(); + for (String str : this.value.keySet()) { + lst.add(this.value.get(str)); + } + return lst; + } +} diff --git a/cali.lang.base/src/com/cali/types/CaliNull.java b/cali.lang.base/src/com/cali/types/CaliNull.java new file mode 100644 index 0000000..392be3d --- /dev/null +++ b/cali.lang.base/src/com/cali/types/CaliNull.java @@ -0,0 +1,54 @@ +/* + * Copyright 2017 Austin Lehman + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.cali.types; + +import com.cali.Universe; +import com.cali.ast.caliException; + +public class CaliNull extends CaliObject implements CaliTypeInt { + public CaliNull() { + this.setType(cType.cNull); + + // Setup linkage for string object. + this.setExternObject(this); + try { + this.setClassDef(Universe.get().getClassDef("cnull")); + } catch (caliException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + } + + @Override + public String toString(int Level) { + String rstr = ""; + rstr += CaliType.getTabs(Level) + "{\n"; + rstr += CaliType.getTabs(Level + 1) + "\"type\": \"" + this.getType().name() + "\",\n"; + rstr += CaliType.getTabs(Level + 1) + "\"value\": null\n"; + rstr += CaliType.getTabs(Level) + "}"; + return rstr; + } + + @Override + public String str() { + return "null"; + } + + public String str(int Level) { + return this.str(); + } +} diff --git a/cali.lang.base/src/com/cali/types/CaliObject.java b/cali.lang.base/src/com/cali/types/CaliObject.java new file mode 100644 index 0000000..fffec24 --- /dev/null +++ b/cali.lang.base/src/com/cali/types/CaliObject.java @@ -0,0 +1,122 @@ +/* + * Copyright 2017 Austin Lehman + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.cali.types; + +import com.cali.Environment; +import com.cali.ast.astClass; +import com.cali.ast.caliException; + +public class CaliObject extends CaliType implements CaliTypeInt { + private astClass classDef; + private Members members = new Members(); + + private Object externObject = null; + + public CaliObject() { + this.setType(cType.cObject); + } + + public astClass getClassDef() { + return classDef; + } + + public void setClassDef(astClass classDef) { + this.classDef = classDef; + } + + public Object getExternObject() { + return externObject; + } + + public void setExternObject(Object externObject) { + this.externObject = externObject; + } + + public void addMember(String Key, CaliType Value) { + this.members.add(Key, Value); + } + + public Members getMembers() { + return this.members; + } + + @Override + public String toString(int Level) { + String rstr = ""; + + rstr += getTabs(Level); + rstr += "line "; + rstr += this.getClassDef().getLineNum(); + rstr += ": "; + rstr += "["; + rstr += this.getType().name(); + rstr += "] classDef='"; + if(this.classDef != null) + rstr += this.getClassDef().getName(); + else + rstr += "undef"; + rstr += "'"; + if(this.getClassDef().getName() != "") + rstr += " name='" + this.getClassDef().getName() + "'"; + rstr += "\n"; + + if(this.members != null) + rstr += this.members.toString(Level); + + return rstr; + } + + @Override + public String str() { + return this.str(0); + } + + public String str(int Level) { + if (this.members.getMap().size() > 0) { + String rstr = "{\n"; + int count = 0; + for (String name : this.members.getMap().keySet()) { + rstr += getTabs(Level + 1) + "'" + name + "': "; + CaliType child = this.members.get(name); + rstr += ((CaliObject)child).str(Level + 1); + count++; + if (count < this.members.getMap().size()) { + rstr += ","; + } + rstr += "\n"; + } + rstr += getTabs(Level) + "}"; + return rstr; + } else { + return "{}"; + } + } + + public String str(Environment env) throws caliException { + if (this.getClassDef().containsFunction("toString")) { + astClass ac = this.getClassDef(); + Environment tenv = env.clone(this); + CaliType ret = ac.call(tenv, false, "toString", new CaliList()); + if (ret.getType() == cType.cString) { + return ((CaliString)ret).getValue(); + } else if (ret.isEx()) { + System.out.println(((CaliException)ret).stackTraceToString()); + } + } + return "cObject@" + Integer.toHexString(System.identityHashCode(this)); + } +} diff --git a/cali.lang.base/src/com/cali/types/CaliRef.java b/cali.lang.base/src/com/cali/types/CaliRef.java new file mode 100644 index 0000000..0864af1 --- /dev/null +++ b/cali.lang.base/src/com/cali/types/CaliRef.java @@ -0,0 +1,122 @@ +/* + * Copyright 2017 Austin Lehman + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.cali.types; + +import java.util.ArrayList; +import java.util.concurrent.ConcurrentHashMap; + +public class CaliRef extends CaliType implements CaliTypeInt { + private boolean isMap; + private int lkey = -1; + private String mkey = ""; + private ArrayList lobj; + private ConcurrentHashMap mobj; + + public CaliRef() { + this.setType(cType.cRef); + this.isMap = true; + this.lkey = -1; + this.mkey = ""; + this.mobj = new ConcurrentHashMap(); + } + + public void setList(int Key, ArrayList Lobj) { + this.isMap = false; + this.lkey = Key; + this.lobj = Lobj; + this.mkey = ""; + this.mobj = null; + } + + public ArrayList getList() { + return this.lobj; + } + + public void setMap(String Key, ConcurrentHashMap Mobj) { + this.isMap = true; + this.mkey = Key; + this.mobj = Mobj; + this.lkey = -1; + this.lobj = null; + } + + public ConcurrentHashMap getMap() { + return this.mobj; + } + + public CaliType getValue() throws Exception { + if (this.isMap) { + if (this.mobj.containsKey(this.mkey)) { + return this.mobj.get(this.mkey); + } else { + throw new Exception("Reference can't find item for '" + this.mkey + "'."); + } + } else { + if (this.lkey >= 0 && this.lkey < (long)this.lobj.size()) { + return this.lobj.get((int) this.lkey); + } else { + throw new Exception("Reference index " + this.lkey + " out of bounds."); + } + } + } + + public void assign(CaliType Value) { + if (this.isMap) { + this.mobj.put(this.mkey, Value); + } else { + this.lobj.set(this.lkey, Value); + } + } + + @Override + public String toString(int Level) { + String rstr = ""; + rstr += CaliType.getTabs(Level) + "{\n"; + rstr += CaliType.getTabs(Level + 1) + "\"type\": \"" + this.getType().name() + "\",\n"; + if (!this.isMap && this.lkey != -1) { + rstr += CaliType.getTabs(Level + 1) + "\"objType\": \"list\",\n"; + rstr += CaliType.getTabs(Level + 1) + "\"lkey\": " + this.lkey + ",\n"; + rstr += CaliType.getTabs(Level + 1) + "\"lobj\": [\n"; + for (int i = 0; i < this.lobj.size(); i++) { + rstr += ((CaliTypeInt)this.lobj.get(i)).toString(Level + 2) + ",\n"; + } + rstr += CaliType.getTabs(Level + 1) + "],\n"; + } else if (this.isMap && this.mkey != "") { + rstr += CaliType.getTabs(Level + 1) + "\"objType\": \"map\",\n"; + rstr += CaliType.getTabs(Level + 1) + "\"mkey\": \"" + this.mkey + "\",\n"; + rstr += CaliType.getTabs(Level + 1) + "\"mobj\": {\n"; + for(String key : this.mobj.keySet()) { + CaliType val = this.mobj.get(key); + rstr += CaliType.getTabs(Level + 2) + key + ":\n"; + rstr += ((CaliTypeInt)val).toString(Level + 2) + ",\n"; + } + rstr += CaliType.getTabs(Level + 1) + "},\n"; + } + rstr += CaliType.getTabs(Level) + "}"; + return rstr; + } + + @Override + public String str() { + if (this.isMap) { + return "cMap@" + Integer.toHexString(System.identityHashCode(this)); + } else { + return "cList@" + Integer.toHexString(System.identityHashCode(this)); + } + } + +} diff --git a/cali.lang.base/src/com/cali/types/CaliReturn.java b/cali.lang.base/src/com/cali/types/CaliReturn.java new file mode 100644 index 0000000..79376dd --- /dev/null +++ b/cali.lang.base/src/com/cali/types/CaliReturn.java @@ -0,0 +1,54 @@ +/* + * Copyright 2017 Austin Lehman + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.cali.types; + +public class CaliReturn extends CaliType implements CaliTypeInt { + private CaliType value = null; + + public CaliReturn() { + this.setType(cType.cReturn); + } + + public CaliReturn(CaliType Value) { + this(); + this.value = Value; + } + + public CaliType getValue() { + return value; + } + + public void setValue(CaliType value) { + this.value = value; + } + + @Override + public String toString(int Level) { + String rstr = ""; + rstr += getTabs(Level) + "{\n"; + rstr += getTabs(Level + 1) + "\"type\": \"" + this.getType().name() + "\",\n"; + rstr += getTabs(Level + 1) + "\"value\": "; + rstr += ((CaliTypeInt)this.value).toString(Level + 2); + rstr += getTabs(Level) + "}"; + return rstr; + } + + @Override + public String str() { + return "return"; + } +} diff --git a/cali.lang.base/src/com/cali/types/CaliString.java b/cali.lang.base/src/com/cali/types/CaliString.java new file mode 100644 index 0000000..884647f --- /dev/null +++ b/cali.lang.base/src/com/cali/types/CaliString.java @@ -0,0 +1,189 @@ +/* + * Copyright 2017 Austin Lehman + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.cali.types; + +import java.util.ArrayList; + +import com.cali.Universe; +import com.cali.ast.caliException; + +public class CaliString extends CaliObject implements CaliTypeInt { + private String value = ""; + + public CaliString() { + this.setType(cType.cString); + + // Setup linkage for string object. + this.setExternObject(this); + try { + this.setClassDef(Universe.get().getClassDef("string")); + } catch (caliException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + } + + public CaliString(String Value) { + this(); + this.value = Value; + } + + public String getValue() { + return value; + } + + public void setValue(String value) { + this.value = value; + } + + @Override + public String toString(int Level) { + String rstr = ""; + rstr += CaliType.getTabs(Level) + "{\n"; + rstr += CaliType.getTabs(Level + 1) + "\"type\": \"" + this.getType().name() + "\",\n"; + rstr += CaliType.getTabs(Level + 1) + "\"value\": \"" + this.value + "\"\n"; + rstr += CaliType.getTabs(Level) + "}"; + return rstr; + } + + @Override + public String str() { + return this.value; + } + + public String str(int Level) { + return "\"" + this.str() + "\""; + } + + public CaliType charAt(ArrayList args) throws caliException { + int index = (int) ((CaliInt)args.get(0)).getValue(); + if (index >= 0 && index < this.value.length()) { + return new CaliString("" + this.value.charAt(index)); + } else { + throw new caliException("Index " + index + " out of bounds." ); + } + } + + public CaliType compare(ArrayList args) { + return new CaliInt(this.value.compareTo(((CaliString)args.get(0)).getValue())); + } + + public CaliType compareICase(ArrayList args) { + return new CaliInt(this.value.compareToIgnoreCase(((CaliString)args.get(0)).getValue())); + } + + public CaliType concat(ArrayList args) { + this.value += ((CaliString)args.get(0)).getValue(); + return this; + } + + public CaliType contains(ArrayList args) { + return new CaliBool(this.value.contains(((CaliString)args.get(0)).getValue())); + } + + public CaliType endsWith(ArrayList args) { + return new CaliBool(this.value.endsWith(((CaliString)args.get(0)).getValue())); + } + + public CaliType equals(ArrayList args) { + return new CaliBool(this.value.equals(((CaliString)args.get(0)).getValue())); + } + + public CaliType equalsICase(ArrayList args) { + return new CaliBool(this.value.equalsIgnoreCase(((CaliString)args.get(0)).getValue())); + } + + public CaliType indexOf(ArrayList args) { + return new CaliInt(this.value.indexOf(((CaliString)args.get(0)).getValue())); + } + + public CaliType indexOfStart(ArrayList args) { + return new CaliInt(this.value.indexOf(((CaliString)args.get(0)).getValue(), (int)((CaliInt)args.get(1)).getValue())); + } + + public CaliType isEmpty(ArrayList args) { + return new CaliBool(this.value.isEmpty()); + } + + public CaliType lastIndexOf(ArrayList args) { + return new CaliInt(this.value.lastIndexOf(((CaliString)args.get(0)).getValue())); + } + + public CaliType lastIndexOfStart(ArrayList args) { + return new CaliInt(this.value.lastIndexOf(((CaliString)args.get(0)).getValue(), (int)((CaliInt)args.get(1)).getValue())); + } + + public CaliType length(ArrayList args) { + return new CaliInt(this.value.length()); + } + + public CaliType matches(ArrayList args) { + return new CaliBool(this.value.matches(((CaliString)args.get(0)).getValue())); + } + + public CaliType replace(ArrayList args) { + return new CaliString(this.value.replace(((CaliString)args.get(0)).getValue(), ((CaliString)args.get(1)).getValue())); + } + + public CaliType replaceFirstRegex(ArrayList args) { + return new CaliString(this.value.replaceFirst(((CaliString)args.get(0)).getValue(), ((CaliString)args.get(1)).getValue())); + } + + public CaliType replaceRegex(ArrayList args) { + return new CaliString(this.value.replaceAll(((CaliString)args.get(0)).getValue(), ((CaliString)args.get(1)).getValue())); + } + + public CaliType split(ArrayList args) { + CaliList ret = new CaliList(); + boolean allowBlanks = ((CaliBool)args.get(1)).getValue(); + String parts[] = this.value.split(((CaliString)args.get(0)).getValue()); + for (String part : parts) { + if (allowBlanks || !part.trim().equals("")) { + ret.add(new CaliString(part)); + } + } + return ret; + } + + public CaliType startsWith(ArrayList args) { + if (args.size() > 1) { + return new CaliBool(this.value.startsWith(((CaliString)args.get(0)).getValue(), (int)((CaliInt)args.get(1)).getValue())); + } else { + return new CaliBool(this.value.startsWith(((CaliString)args.get(0)).getValue())); + } + } + + public CaliType substr(ArrayList args) { + if (args.get(1).isNull()) { + return new CaliString(this.value.substring((int)((CaliInt)args.get(0)).getValue())); + } else { + return new CaliString(this.value.substring((int)((CaliInt)args.get(0)).getValue(), (int)((CaliInt)args.get(1)).getValue())); + } + } + + public CaliType toLower(ArrayList args) { + return new CaliString(this.value.toLowerCase()); + } + + public CaliType toUpper(ArrayList args) { + return new CaliString(this.value.toUpperCase()); + } + + public CaliType trim(ArrayList args) { + return new CaliString(this.value.trim()); + } +} diff --git a/cali.lang.base/src/com/cali/types/CaliType.java b/cali.lang.base/src/com/cali/types/CaliType.java new file mode 100644 index 0000000..036d564 --- /dev/null +++ b/cali.lang.base/src/com/cali/types/CaliType.java @@ -0,0 +1,263 @@ +/* + * Copyright 2017 Austin Lehman + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.cali.types; + +import com.cali.Environment; +import com.cali.ast.caliException; + +public class CaliType { + + private cType type = cType.cUndef; + + public CaliType() { } + + public cType getType() { + return type; + } + + public void setType(cType type) { + this.type = type; + } + + public boolean isEx() { + if (this.type == cType.cException) { return true; } + return false; + } + + public boolean isNull() { + if (this.type == cType.cNull) { return true; } + return false; + } + + public boolean isReturn() { + if (this.type == cType.cReturn) { return true; } + return false; + } + + public boolean isBreak() { + if (this.type == cType.cBreak) { return true; } + return false; + } + + @Override + public String toString() { + return ((CaliTypeInt)this).toString(0); + } + + public static String getTabs(int Level) { + String rstr = ""; + for (int i = 0; i < Level; i++) { rstr += "\t"; } + return rstr; + } + + public boolean isNumericType() { + if(this.type == cType.cInt) + return true; + else if(this.type == cType.cDouble) + return true; + else if(this.type == cType.cBool) + return true; + return false; + } + + public boolean getNumericBool() throws caliException { + if(this.type == cType.cBool) + return ((CaliBool)this).getValue(); + else if(this.type == cType.cInt) { + if(((CaliInt)this).getValue() != 0) + return true; + return false; + } + else if(this.type == cType.cDouble) { + if(((CaliDouble)this).getValue() != 0.0) + return true; + return false; + } else { + throw new caliException("INTERNAL [CaliType.getNumericBool] Not expecting type '" + this.type.name() + "'."); + } + } + + public long getNumericInt() throws caliException { + if(this.type == cType.cInt) + return ((CaliInt)this).getValue(); + else if(this.type == cType.cBool) { + if(((CaliBool)this).getValue() == true) + return 1; + return 0; + } else if(this.type == cType.cDouble) { + return (int)((CaliDouble)this).getValue(); + } else { + throw new caliException("INTERNAL [CaliType.getNumericInt] Not expecting type '" + this.type.name() + "'."); + } + } + + public double getNumericDouble() throws caliException { + if(this.type == cType.cDouble) + return ((CaliDouble)this).getValue(); + else if(this.type == cType.cInt) { + return (double)((CaliInt)this).getValue(); + } else if(this.type == cType.cBool) { + if(((CaliBool)this).getValue() == true) + return 1.0; + return 0.0; + } else { + throw new caliException("INTERNAL [CaliType.getNumericDouble] Not expecting type '" + this.type.name() + "'."); + } + } + + public String getValueString() { + return ((CaliTypeInt)this).str(); + } + + public CaliBool compareEqual(Environment env, CaliType To) throws caliException { + CaliBool ret = new CaliBool(false); + + if((this.type == cType.cNull)||(To.getType() == cType.cNull)) { + if((this.type == cType.cNull)&&(To.getType() == cType.cNull)) + ret = new CaliBool(true); + else + ret = new CaliBool(false); + } else { + switch(this.type){ + case cBool: + if(To.isNumericType()) { + if(this.getNumericDouble() == To.getNumericDouble()) + ret = new CaliBool(true); + else + ret = new CaliBool(false); + } + else { + throw new caliException("Attempting to compare objects of type '" + this.getType() + "' and '" + To.getType() + "'."); + } + break; + case cInt: + if(To.isNumericType()) { + if(this.getNumericDouble() == To.getNumericDouble()) + ret = new CaliBool(true); + else + ret = new CaliBool(false); + } else { + throw new caliException("Attempting to compare objects of type '" + this.getType() + "' and '" + To.getType() + "'."); + } + break; + case cDouble: + if(To.isNumericType()) { + if(this.getNumericDouble() == To.getNumericDouble()) + ret = new CaliBool(true); + else + ret = new CaliBool(false); + } else { + throw new caliException("Attempting to compare objects of type '" + this.getType() + "' and '" + To.getType() + "'."); + } + break; + case cString: + if(To.getType() == cType.cString) { + if(((CaliString)this).getValueString().equals(((CaliString)To).getValueString())) + ret = new CaliBool(true); + else + ret = new CaliBool(false); + } else { + throw new caliException("Attempting to compare objects of type '" + this.getType() + "' and '" + To.getType() + "'."); + } + break; + case cObject: + if(To.getType() == cType.cObject) { + if(this == To) + ret = new CaliBool(true); + else + ret = new CaliBool(false); + } else { + throw new caliException("Attempting to compare objects of type '" + this.getType() + "' and '" + To.getType() + "'."); + } + break; + case cList: + if(To.getType() == cType.cList) { + if(this == To) + ret = new CaliBool(true); + else + ret = new CaliBool(false); + } else { + throw new caliException("Attempting to compare objects of type '" + this.getType() + "' and '" + To.getType() + "'."); + } + break; + case cMap: + if(To.getType() == cType.cMap) { + if(this == To) + ret = new CaliBool(true); + else + ret = new CaliBool(false); + } else { + throw new caliException("Attempting to compare objects of type '" + this.getType() + "' and '" + To.getType() + "'."); + } + break; + default: + throw new caliException("Attempting to compare objects of type '" + this.getType() + "' and '" + To.getType() + "'."); + } + } + + return ret; + } + + public CaliBool evalExpressionBool() throws caliException { + CaliBool ret = new CaliBool(); + + switch(this.type) { + case cBool: + ret = (CaliBool) this; + break; + case cInt: + if(((CaliInt)this).getValue() != 0) + ret = new CaliBool(true); + else + ret = new CaliBool(false); + break; + case cDouble: + if(((CaliDouble)this).getValue() != 0.0) + ret = new CaliBool(true); + else + ret = new CaliBool(false); + break; + case cString: + if(!((CaliString)this).getValue().equals("")) + ret = new CaliBool(true); + else + ret = new CaliBool(false); + break; + case cList: + if(((CaliList)this).size() != 0) + ret = new CaliBool(true); + else + ret = new CaliBool(false); + break; + case cMap: + if(((CaliMap)this).size() != 0) + ret = new CaliBool(true); + else + ret = new CaliBool(false); + break; + case cObject: + ret = new CaliBool(true); + break; + case cNull: + ret = new CaliBool(false); + break; + default: + throw new caliException("Unexpected result from condition of type '" + this.type.name() + "'."); + } + return ret; + } +} diff --git a/cali.lang.base/src/com/cali/types/CaliTypeInt.java b/cali.lang.base/src/com/cali/types/CaliTypeInt.java new file mode 100644 index 0000000..9c1b762 --- /dev/null +++ b/cali.lang.base/src/com/cali/types/CaliTypeInt.java @@ -0,0 +1,24 @@ +/* + * Copyright 2017 Austin Lehman + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.cali.types; + +public interface CaliTypeInt { + public String toString(); + public String toString(int Level); + public String str(); +} + diff --git a/cali.lang.base/src/com/cali/types/Members.java b/cali.lang.base/src/com/cali/types/Members.java new file mode 100644 index 0000000..394a729 --- /dev/null +++ b/cali.lang.base/src/com/cali/types/Members.java @@ -0,0 +1,58 @@ +/* + * Copyright 2017 Austin Lehman + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.cali.types; + +import java.util.concurrent.ConcurrentHashMap; + +public class Members { + private ConcurrentHashMap impa = new ConcurrentHashMap(); + + public void add(String Key, CaliType Value) { + this.impa.put(Key, Value); + } + + public boolean contains(String Key) { + return this.impa.containsKey(Key); + } + + public CaliType get(String Key) { + return this.impa.get(Key); + } + + public ConcurrentHashMap getMap() { + return this.impa; + } + + public String toString() { + return this.toString(0); + } + + public String toString(int Level) { + String rstr = ""; + + rstr += CaliType.getTabs(Level) + "{\n"; + + for (String key : this.impa.keySet()) { + rstr += CaliType.getTabs(Level + 1) + "\"" + key + "\":\n"; + rstr += ((CaliTypeInt)this.impa.get(key)).toString(Level + 1); + rstr += CaliType.getTabs(Level + 1) + ",\n"; + } + rstr += CaliType.getTabs(Level) + "}\n"; + + return rstr; + } +} diff --git a/cali.lang.base/src/com/cali/types/cType.java b/cali.lang.base/src/com/cali/types/cType.java new file mode 100644 index 0000000..8eee7cf --- /dev/null +++ b/cali.lang.base/src/com/cali/types/cType.java @@ -0,0 +1,34 @@ +/* + * Copyright 2017 Austin Lehman + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.cali.types; + +public enum cType { + cUndef, + cNull, + cBool, + cInt, + cDouble, + cString, + cObject, + cCallback, + cMap, + cList, + cException, + cRef, + cBreak, + cReturn +} \ No newline at end of file diff --git a/cali.lang.base/tests/interpreter.ca b/cali.lang.base/tests/interpreter.ca new file mode 100644 index 0000000..fe5d6c0 --- /dev/null +++ b/cali.lang.base/tests/interpreter.ca @@ -0,0 +1,944 @@ +/* + * Copyright 2017 Austin Lehman + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +include cunit; +include math; +include sys; + +enum numName { + one; + two; + three; +} + +class email { + public address = ""; + + public setAddress(string Address) { this.address = Address; } + public getAddress() { return this.address; } +} + +class user { + public firstName = ""; + public lastName = ""; + public emailAddress = null; + + public user() { this.emailAddress = new email(); } + + public setName(string First, string Last) { this.firstName = First; this.lastName = Last; return this; } + public getName() { return this.firstName + " " + this.lastName; } +} + +class atest { + public pub = 'Pub'; + pri = 'Pri'; + + private priMeth() { return true; } + public pubMeth() { return true; } +} + +class cont { + public c = null; + public cont() { this.c = new atest(); } +} + +class dog { + public breed = "undef"; + public dog(string Breed) { this.breed = Breed; } +} + +class interpreterTests : test { + // public member used for testing + public member = null; + + // access tests + obj = null; + + // Members used for definition testing. + public mem; + public memNull = null; + public memBool = false; + public memInt = 10; + public memDouble = 123.456; + public memString = "hi"; + public memList = ['one', 'two', 'three']; + public memMap = { 'one' : 1, 'two' : 2, 'three' : 3 }; + public memNestedList = [ 0, 1, { 'one' : 1, 'two' : 2 } ]; + public memNestedMap = { 'one' : 1, 'two' : 2, 'three' : [ 0, 1, 2 ] }; + public memObj = null; + public en = null; + + // Lang members. + private tlist = null; + private tmap = null; + private dt = null; + private buff = null; + private cb = null; + + public main(args) { + // Start time mills. + start = sys.getMills(); + + // Instantiate our test and then run it. + tt = new interpreterTests(); + tt.run(); + + end = sys.getMills(); + c.log("Elapsed: " + ((end - start)/1000) + "s"); + } + + /* + * Test constructor. We set the test name here and do + * any initialization we need for the test here. + */ + public interpreterTests() { + this.setName("Cali-Lang Interpreter"); + + // Local variable assignment tests + this + .add("(local assignment) Assign variable null.", ::assignLocalNull) + .add("(local assignment) Assign variable bool.", ::assignLocalBool) + .add("(local assignment) Assign variable int.", ::assignLocalInt) + .add("(local assignment) Assign variable double.", ::assignLocalDouble) + .add("(local assignment) Assign variable string.", ::assignLocalString) + .add("(local assignment) Assign variable list.", ::assignLocalList) + .add("(local assignment) Assign variable map.", ::assignLocalMap) + ; + + // Member variable assignment tests + this + .add("(member assignment) Assign variable null.", ::assignMemberNull) + .add("(member assignment) Assign variable bool.", ::assignMemberBool) + .add("(member assignment) Assign variable int.", ::assignMemberInt) + .add("(member assignment) Assign variable double.", ::assignMemberDouble) + .add("(member assignment) Assign variable string.", ::assignMemberString) + .add("(member assignment) Assign variable list.", ::assignMemberList) + .add("(member assignment) Assign variable map.", ::assignMemberMap) + ; + + // Member variable definition tests + this + .add("(member definition) Defined member blank.", ::defineMemberBlank) + .add("(member definition) Defined member null.", ::defineMemberNull) + .add("(member definition) Defined member bool.", ::defineMemberBool) + .add("(member definition) Defined member int.", ::defineMemberInt) + .add("(member definition) Defined member double.", ::defineMemberDouble) + .add("(member definition) Defined member string.", ::defineMemberString) + .add("(member definition) Defined member list.", ::defineMemberList) + .add("(member definition) Defined member map.", ::defineMemberMap) + .add("(member definition) Defined member nested list.", ::defineMemberListNested) + .add("(member definition) Defined member nested map.", ::defineMemberMapNested) + ; + + // Basic operator tests. + this + // + oper + .add("(+ operator) Bool plus bool.", ::operBoolPlusBool) + .add("(+ operator) Bool plus int.", ::operBoolPlusInt) + .add("(+ operator) Bool plus double.", ::operBoolPlusDouble) + .add("(+ operator) Int plus bool.", ::operIntPlusBool) + .add("(+ operator) Int plus int.", ::operIntPlusInt) + .add("(+ operator) Int plus double.", ::operIntPlusDouble) + .add("(+ operator) Double plus bool.", ::operDoublePlusBool) + .add("(+ operator) Double plus int.", ::operDoublePlusInt) + .add("(+ operator) Double plus double.", ::operDoublePlusDouble) + .add("(+ operator) String plus null.", ::operStringPlusNull) + .add("(+ operator) String plus bool.", ::operStringPlusBool) + .add("(+ operator) String plus int.", ::operStringPlusInt) + .add("(+ operator) String plus double.", ::operStringPlusDouble) + .add("(+ operator) String plus string.", ::operStringPlusString) + .add("(+ operator) Null plus string.", ::operNullPlusString) + .add("(+ operator) Bool plus string.", ::operBoolPlusString) + .add("(+ operator) Int plus string.", ::operIntPlusString) + .add("(+ operator) Double plus string.", ::operDoublePlusString) + // - oper + .add("(- operator) Bool minus bool.", ::operBoolMinusBool) + .add("(- operator) Bool minus int.", ::operBoolMinusInt) + .add("(- operator) Bool minus double.", ::operBoolMinusDouble) + .add("(- operator) Int minus bool.", ::operIntMinusBool) + .add("(- operator) Int minus int.", ::operIntMinusInt) + .add("(- operator) Int minus double.", ::operIntMinusDouble) + .add("(- operator) Double minus bool.", ::operDoubleMinusBool) + .add("(- operator) Double minus int.", ::operDoubleMinusInt) + .add("(- operator) Double minus double.", ::operDoubleMinusDouble) + // * oper + .add("(* operator) Bool times bool.", ::operBoolTimesBool) + .add("(* operator) Bool times int.", ::operBoolTimesInt) + .add("(* operator) Bool times double.", ::operBoolTimesDouble) + .add("(* operator) Int times bool.", ::operIntTimesBool) + .add("(* operator) Int times int.", ::operIntTimesInt) + .add("(* operator) Int times double.", ::operIntTimesDouble) + .add("(* operator) Double times bool.", ::operDoubleTimesBool) + .add("(* operator) Double times int.", ::operDoubleTimesInt) + .add("(* operator) Double times double.", ::operDoubleTimesDouble) + // / oper + .add("(/ operator) Bool divide bool.", ::operBoolDivideBool) + .add("(/ operator) Bool divide int.", ::operBoolDivideInt) + .add("(/ operator) Bool divide double.", ::operBoolDivideDouble) + .add("(/ operator) Int divide bool.", ::operIntDivideBool) + .add("(/ operator) Int divide int.", ::operIntDivideInt) + .add("(/ operator) Int divide double.", ::operIntDivideDouble) + .add("(/ operator) Double divide bool.", ::operDoubleDivideBool) + .add("(/ operator) Double divide int.", ::operDoubleDivideInt) + .add("(/ operator) Double divide double.", ::operDoubleDivideDouble) + // % oper + .add("(% operator) Bool modulus bool.", ::operBoolModulusBool) + .add("(% operator) Bool modulus int.", ::operBoolModulusInt) + .add("(% operator) Bool modulus double.", ::operBoolModulusDouble) + .add("(% operator) Int modulus bool.", ::operIntModulusBool) + .add("(% operator) Int modulus int.", ::operIntModulusInt) + .add("(% operator) Int modulus double.", ::operIntModulusDouble) + .add("(% operator) Double modulus bool.", ::operDoubleModulusBool) + .add("(% operator) Double modulus int.", ::operDoubleModulusInt) + .add("(% operator) Double modulus double.", ::operDoubleModulusDouble) + // # oper + .add("(# operator) Local list count.", ::operLocalListCount) + .add("(# operator) Local map count.", ::operLocalMapCount) + .add("(# operator) Member list count.", ::operMemberListCount) + .add("(# operator) Member map count.", ::operMemberMapCount) + ; + + // List operations + this + .add("(list operations) List local append null.", ::listLocalAppendNull) + .add("(list operations) List local append bool.", ::listLocalAppendBool) + .add("(list operations) List local append int.", ::listLocalAppendInt) + .add("(list operations) List local append double.", ::listLocalAppendDouble) + .add("(list operations) List local append string.", ::listLocalAppendString) + .add("(list operations) List local append local list.", ::listLocalAppendLocalList) + .add("(list operations) List local append local map.", ::listLocalAppendLocalMap) + .add("(list operations) List member append null.", ::listMemberAppendNull) + .add("(list operations) List member append bool.", ::listMemberAppendBool) + .add("(list operations) List member append int.", ::listMemberAppendInt) + .add("(list operations) List member append double.", ::listMemberAppendDouble) + .add("(list operations) List member append string.", ::listMemberAppendString) + .add("(list operations) List member append local deref with var.", ::listMemberAppendLocalVarRef) + .add("(list operations) List local new list.", ::listLocalNewList) + .add("(list operations) List local get by local var.", ::listLocalGetLocalVar) + ; + + // Map operations + this + .add("(map operations) Map member assign string.", ::mapMemberSetString) + .add("(map operations) Map member assign local var.", ::mapMemberSetLocalVar) + .add("(map operations) Map local set string and assign bool.", ::mapLocalSetStringAssignBool) + .add("(map operations) Map local set string and assign int.", ::mapLocalSetStringAssignInt) + .add("(map operations) Map local set string and assign double.", ::mapLocalSetStringAssignDouble) + .add("(map operations) Map local set string and assign string.", ::mapLocalSetStringAssignString) + .add("(map operations) Map local set string and assign list.", ::mapLocalSetStringAssignList) + .add("(map operations) Map local set string and assign var list.", ::mapLocalSetStringAssignVarList) + .add("(map operations) Map local set string and re-assign var list.", ::mapLocalSetStringReAssignVarList) + .add("(map operations) Map local set string and assign map.", ::mapLocalSetStringAssignMap) + .add("(map operations) Map local set string and re-assign var list.", ::mapLocalSetStringReAssignVarMap) + .add("(map operations) Map local set object ref and assign string.", ::mapLocalObjRefAssignString) + .add("(map operations) Map local new map.", ::mapLocalNewMap) + .add("(map operations) Map local set/get by local var.", ::mapLocalSetGetLocalVar) + ; + + // Instance ofoperator + this + .add("(instanceof operations) Instance of null.", ::instanceOfNull) + .add("(instanceof operations) Instance of bool.", ::instanceOfBool) + .add("(instanceof operations) Instance of int.", ::instanceOfInt) + .add("(instanceof operations) Instance of double.", ::instanceOfDouble) + .add("(instanceof operations) Instance of string.", ::instanceOfString) + .add("(instanceof operations) Instance of list.", ::instanceOfList) + .add("(instanceof operations) Instance of map.", ::instanceOfMap) + .add("(instanceof operations) Instance of callback.", ::instanceOfCallback) + .add("(instanceof operations) Object of type user should be of type user.", ::instanceOfObjectUser) + ; + + // Object operations + this + .add("(object operations) Instantiate local object.", ::objectInstantiateLocal) + .add("(object operations) Instantiate member object.", ::objectInstantiateMember) + .add("(object operations) Local object set member.", ::objectLocalSetMember) + .add("(object operations) Member object set member.", ::objectMemberSetMember) + .add("(object operations) Local object set sub member.", ::objectLocalSetSubMember) + .add("(object operations) Member object set sub member.", ::objectMemberSetSubMember) + .add("(object operations) Local object call sub member.", ::objectLocalCallSubMember) + .add("(object operations) Member object call sub member.", ::objectMemberCallSubMember) + // access pub/pri + .add("(object access) Member access for local variable public.", ::objectAccessLocVarPub) + .add("(object access) Member access for local variable private.", ::objectAccessLocVarPri) + .add("(object access) Method access for local variable public.", ::objectMethAccessLocVarPub) + .add("(object access) Method access for local variable private.", ::objectMethAccessLocVarPri) + .add("(object access) Member access for member variable public.", ::objectAccessMemVarPub) + .add("(object access) Member access for member variable private.", ::objectAccessMemVarPri) + .add("(object access) Method access for member variable public.", ::objectMethAccessMemVarPub) + .add("(object access) Method access for member variable private.", ::objectMethAccessMemVarPri) + .add("(object access) Member access for local variable cont public.", ::objectAccessLocVarContPub) + .add("(object access) Member access for local variable cont private.", ::objectAccessLocVarContPri) + .add("(object access) Method access for local variable cont public.", ::objectMethAccessLocVarContPub) + .add("(object access) Method access for local variable cont private.", ::objectMethAccessLocVarContPri) + .add("(object access) Member access for member variable cont public.", ::objectAccessMemVarContPub) + .add("(object access) Member access for member variable cont private.", ::objectAccessMemVarContPri) + .add("(object access) Method access for member variable cont public.", ::objectMethAccessMemVarContPub) + .add("(object access) Method access for member variable cont private.", ::objectMethAccessMemVarContPri) + ; + + // Enum operations + this + .add("(enum operations) Reference enum value.", ::enumReference) + .add("(enum operations) Assign local variable enum reference.", ::enumAssignLocalReference) + .add("(enum operations) Assign member variable enum reference.", ::enumAssignMemberReference) + ; + + // If/Else + this + .add("(if/else) If/Else statement return true.", ::ifElseIfReturnTrue) + .add("(if/else) If/Else statement else return false.", ::ifElseElseReturnFalse) + .add("(if/else) If/Else statement else if true.", ::ifElseElseIfTrue) + ; + + // lang tests + this + // type() + .add("(lang lang) Lang type of null.", ::langLangTypeNull) + .add("(lang lang) Lang type of bool.", ::langLangTypeBool) + .add("(lang lang) Lang type of int.", ::langLangTypeInt) + .add("(lang lang) Lang type of double.", ::langLangTypeDouble) + .add("(lang lang) Lang type of string.", ::langLangTypeString) + // call() - callbacks + .add("(lang lang) Lang create callback.", ::langLangCreateCallback) + .add("(lang lang) Lang call callback.", ::langLangCallCallback) + .add("(lang lang) Lang create callback with args.", ::langLangCreateCallbackArgs) + .add("(lang lang) Lang call callback with args.", ::langLangCallCallbackArgs) + .add("(lang lang) Lang create callback with etc.", ::langLangCreateCallbackEtc) + .add("(lang lang) Lang call callback with etc.", ::langLangCallCallbackEtc) + .add("(lang lang) Lang create callback with etc count.", ::langLangCreateCallbackEtcCnt) + .add("(lang lang) Lang call callback with etc count.", ::langLangCallCallbackEtcCnt) + .add("(lang lang) Lang callback member access.", ::langLangCallbackMemberAcc) + ; + + // int tests + this + .add("(lang int) Int max val.", ::intMaxVal) + .add("(lang int) Int min val.", ::intMinVal) + .add("(lang int) Int to double.", ::intToDouble) + .add("(lang int) Int to bool.", ::intToBool) + .add("(lang int) Int to string.", ::intToString) + .add("(lang int) Int compare.", ::intCompare) + .add("(lang int) Int number leading zeros.", ::intNumLeadingZeros) + .add("(lang int) Int number trailing zeros.", ::intNumTrailingZeros) + .add("(lang int) Int parse.", ::intParse) + .add("(lang int) Int reverse.", ::intReverse) + .add("(lang int) Int rotate left.", ::intRotateLeft) + .add("(lang int) Int rotate right.", ::intRotateRight) + .add("(lang int) Int signum.", ::intSignum) + .add("(lang int) Int to binary.", ::intToBinary) + .add("(lang int) Int to hex.", ::intToHex) + .add("(lang int) Int to octal.", ::intToOctal) + ; + + // bool tests + this + .add("(lang bool) Bool to int.", ::boolToInt) + .add("(lang bool) Bool to double.", ::boolToDouble) + .add("(lang bool) Bool to string.", ::boolToString) + .add("(lang bool) Bool compare.", ::boolCompare) + .add("(lang bool) Bool parse.", ::boolParse) + ; + + // double tests + this + .add("(lang double) Double max exponent.", ::doubleMaxExponent) + .add("(lang double) Double min exponent.", ::doubleMinExponent) + .add("(lang double) Double max value.", ::doubleMaxValue) + .add("(lang double) Double min value.", ::doubleMinValue) + .add("(lang double) Double min normal value.", ::doubleMinNormalValue) + .add("(lang double) Double NaN value.", ::doubleNaNValue) + .add("(lang double) Double negative infinity value.", ::doubleNegInfinity) + .add("(lang double) Double positive infinity value.", ::doublePosInfinity) + .add("(lang double) Double size value.", ::doubleSize) + .add("(lang double) Double to int.", ::doubleToInt) + .add("(lang double) Double to bool.", ::doubleToBool) + .add("(lang double) Double to string.", ::doubleToString) + .add("(lang double) Double compare.", ::doubleCompare) + .add("(lang double) Double is infinite.", ::doubleIsInfinite) + .add("(lang double) Double is NaN.", ::doubleIsNaN) + .add("(lang double) Double parse.", ::doubleParse) + .add("(lang double) Double to hex.", ::doubleToHex) + ; + + // string tests + this + .add("(lang string) String char at.", ::stringCharAt) + .add("(lang string) String compare.", ::stringCompare) + .add("(lang string) String compare ignore case.", ::stringCompareICase) + .add("(lang string) String concat.", ::stringConcat) + .add("(lang string) String contains.", ::stringContains) + .add("(lang string) String ends with.", ::stringEndsWith) + .add("(lang string) String equals.", ::stringEquals) + .add("(lang string) String equals ignore case.", ::stringEqualsICase) + .add("(lang string) String index of.", ::stringIndexOf) + .add("(lang string) String index of start.", ::stringIndexOfStart) + .add("(lang string) String is empty.", ::stringIsEmpty) + .add("(lang string) String last index of.", ::stringLastIndexOf) + .add("(lang string) String last index of start.", ::stringLastIndexOfStart) + .add("(lang string) String matches.", ::stringMatches) + .add("(lang string) String replace.", ::stringReplace) + .add("(lang string) String replace first regex.", ::stringReplaceFirstRegex) + .add("(lang string) String replace regex.", ::stringReplaceRegex) + .add("(lang string) String split.", ::stringSplit) + .add("(lang string) String starts with.", ::stringStartsWith) + .add("(lang string) String sub string.", ::stringSubstr) + .add("(lang string) String sub string end.", ::stringSubstrEnd) + .add("(lang string) String to lower case.", ::stringToLower) + .add("(lang string) String to upper case.", ::stringToUpper) + .add("(lang string) String trim.", ::stringTrim) + ; + + // list tests + this + .add("(lang list) List create.", ::listCreate) + .add("(lang list) List add.", ::listAdd) + .add("(lang list) List add all.", ::listAddAll) + .add("(lang list) List add all at.", ::listAddAllAt) + .add("(lang list) List clone.", ::listClone) + .add("(lang list) List contains object reference.", ::listContainsObjRef) + .add("(lang list) List contains.", ::listContains) + .add("(lang list) List get.", ::listGet) + .add("(lang list) List index of.", ::listIndexOf) + .add("(lang list) List is empty.", ::listIsEmpty) + .add("(lang list) List remove.", ::listRemove) + .add("(lang list) List remove at.", ::listRemoveAt) + .add("(lang list) List remove all.", ::listRemoveAll) + .add("(lang list) List retain all.", ::listRetainAll) + .add("(lang list) List set.", ::listSet) + .add("(lang list) List size.", ::listSize) + .add("(lang list) List sub list.", ::listSubList) + .add("(lang list) List sort.", ::listSort) + .add("(lang list) List sort ascending.", ::listSortAsc) + .add("(lang list) List sort custom.", ::listSortCustom) + .add("(lang list) List clear.", ::listClear) + ; + + // map tests + this + .add("(lang map) Map create.", ::mapCreate) + .add("(lang map) Map contains key.", ::mapContainsKey) + .add("(lang map) Map contains value.", ::mapContainsValue) + .add("(lang map) Map get.", ::mapGet) + .add("(lang map) Map is empty.", ::mapIsEmpty) + .add("(lang map) Map key set.", ::mapKeySet) + .add("(lang map) Map put.", ::mapPut) + .add("(lang map) Map put all.", ::mapPutAll) + .add("(lang map) Map put if absent.", ::mapPutIfAbsent) + .add("(lang map) Map remove.", ::mapRemove) + .add("(lang map) Map size.", ::mapSize) + .add("(lang map) Map values.", ::mapValues) + .add("(lang map) Map clear.", ::mapClear) + ; + + // buffer tests + this + .add("(lang buffer) Buffer instantiate.", ::bufferInstantiate) + .add("(lang buffer) Buffer size.", ::bufferSize) + .add("(lang buffer) Buffer add string.", ::bufferAddString) + .add("(lang buffer) Buffer add byte.", ::bufferAddByte) + .add("(lang buffer) Buffer add unsigned byte.", ::bufferAddUByte) + .add("(lang buffer) Buffer add short.", ::bufferAddShort) + .add("(lang buffer) Buffer add unsigned short.", ::bufferAddUShort) + .add("(lang buffer) Buffer add int.", ::bufferAddInt) + .add("(lang buffer) Buffer add unsigned int.", ::bufferAddUInt) + .add("(lang buffer) Buffer add long.", ::bufferAddLong) + .add("(lang buffer) Buffer add float.", ::bufferAddFloat) + .add("(lang buffer) Buffer add double.", ::bufferAddDouble) + .add("(lang buffer) Buffer get write cursor.", ::bufferGetWriteCursor) + .add("(lang buffer) Buffer get read cursor.", ::bufferGetReadCursor) + .add("(lang buffer) Buffer set string.", ::bufferSetString) + .add("(lang buffer) Buffer set byte.", ::bufferSetByte) + .add("(lang buffer) Buffer set unsigned byte.", ::bufferSetUByte) + .add("(lang buffer) Buffer set short.", ::bufferSetShort) + .add("(lang buffer) Buffer set unsigned short.", ::bufferSetUShort) + .add("(lang buffer) Buffer set int.", ::bufferSetInt) + .add("(lang buffer) Buffer set unsigned int.", ::bufferSetUInt) + .add("(lang buffer) Buffer set long.", ::bufferSetLong) + .add("(lang buffer) Buffer set float.", ::bufferSetFloat) + .add("(lang buffer) Buffer set double.", ::bufferSetDouble) + .add("(lang buffer) Buffer copy from.", ::bufferCopyFrom) + .add("(lang buffer) Buffer copy to.", ::bufferCopyTo) + .add("(lang buffer) Buffer byte to binary.", ::bufferByteToBinary) + .add("(lang buffer) Buffer short to binary.", ::bufferShortToBinary) + .add("(lang buffer) Buffer int to binary.", ::bufferIntToBinary) + .add("(lang buffer) Buffer long to binary.", ::bufferLongToBinary) + .add("(lang buffer) Buffer float to binary.", ::bufferFloatToBinary) + .add("(lang buffer) Buffer double to binary.", ::bufferDoubleToBinary) + .add("(lang buffer) Buffer clearn.", ::bufferClear) + ; + + // date tests + this + .add("(lang date) Date instantiate.", ::dateInstantiate) + .add("(lang date) Date set hours.", ::dateSetHours) + .add("(lang date) Date set minutes.", ::dateSetMinutes) + .add("(lang date) Date set seconds.", ::dateSetSeconds) + .add("(lang date) Date set time.", ::dateSetTime) + .add("(lang date) Date to string.", ::dateToString) + .add("(lang date) Date parse.", ::dateParse) + .add("(lang date) Date format.", ::dateFormat) + .add("(lang date) Date is epoch.", ::dateIsEpoch) + ; + } + + /********************************************************************** + * Local variable assignments. + *********************************************************************/ + public assignLocalNull() { var = null; return this.expectNull(var); } + public assignLocalBool() { var = true; return this.expect(var, true); } + public assignLocalInt() { var = 1; return this.expect(var, 1); } + public assignLocalDouble() { var = 12345.6789; return this.expect(var, 12345.6789); } + public assignLocalString() { var = "hello world"; return this.expect(var, "hello world"); } + public assignLocalList() { var = []; return this.expectList(var); } + public assignLocalMap() { var = {}; return this.expectMap(var); } + + /********************************************************************** + * Member variable assignments. + *********************************************************************/ + public assignMemberNull() { this.member = null; return this.expectNull(this.member); } + public assignMemberBool() { this.member = true; return this.expect(this.member, true); } + public assignMemberInt() { this.member = 1; return this.expect(this.member, 1); } + public assignMemberDouble() { this.member = 12345.6789; return this.expect(this.member, 12345.6789); } + public assignMemberString() { this.member = "hello world"; return this.expect(this.member, "hello world"); } + public assignMemberList() { this.member = []; return this.expectList(this.member); } + public assignMemberMap() { this.member = {}; return this.expectMap(this.member); } + + /********************************************************************** + * Member variable definitions. + *********************************************************************/ + public defineMemberBlank() { return this.expectNull(this.mem); } + public defineMemberNull() { return this.expectNull(this.memNull); } + public defineMemberBool() { return this.expect(this.memBool, false); } + public defineMemberInt() { return this.expect(this.memInt, 10); } + public defineMemberDouble() { return this.expect(this.memDouble, 123.456); } + public defineMemberString() { return this.expect(this.memString, "hi"); } + public defineMemberList() { return this.expect(this.memList[2], "three"); } + public defineMemberMap() { return this.expect(this.memMap['three'], 3); } + public defineMemberListNested() { return this.expect(this.memNestedList[2]['two'], 2); } + public defineMemberMapNested() { return this.expect(this.memNestedMap['three'][2], 2); } + + /********************************************************************** + * Basic operator tests + *********************************************************************/ + // Numeric + + public operBoolPlusBool() { var = true + true; return this.expect(var, 2); } + public operBoolPlusInt() { var = true + 5; return this.expect(var, 6); } + public operBoolPlusDouble() { var = true + 5.0; return this.expect(var, 6.0); } + public operIntPlusBool() { var = 5 + true; return this.expect(var, 6); } + public operIntPlusInt() { var = 5 + 10; return this.expect(var, 15); } + public operIntPlusDouble() { var = 5 + 10.0; return this.expect(var, 15.0); } + public operDoublePlusBool() { var = 5.0 + true; return this.expect(var, 6.0); } + public operDoublePlusInt() { var = 5.0 + 10; return this.expect(var, 15.0); } + public operDoublePlusDouble() { var = 5.0 + 10.0; return this.expect(var, 15.0); } + // String + + public operStringPlusNull() { var = "is " + null; return this.expect(var, "is null"); } + public operStringPlusBool() { var = "is " + true; return this.expect(var, "is true"); } + public operStringPlusInt() { var = "is " + 1; return this.expect(var, "is 1"); } + public operStringPlusDouble() { var = "is " + 123.456; return this.expect(var, "is 123.456"); } + public operStringPlusString() { var = "is " + "string"; return this.expect(var, "is string"); } + public operNullPlusString() { var = null + " is"; return this.expect(var, "null is"); } + public operBoolPlusString() { var = true + " is"; return this.expect(var, "true is"); } + public operIntPlusString() { var = 1 + " is"; return this.expect(var, "1 is"); } + public operDoublePlusString() { var = 123.456 + " is"; return this.expect(var, "123.456 is"); } + // Numeric - + public operBoolMinusBool() { var = true - true; return this.expect(var, 0); } + public operBoolMinusInt() { var = true - 2; return this.expect(var, -1); } + public operBoolMinusDouble() { var = true - 2.0; return this.expect(var, -1.0); } + public operIntMinusBool() { var = 2 - true; return this.expect(var, 1); } + public operIntMinusInt() { var = 2 - 1; return this.expect(var, 1); } + public operIntMinusDouble() { var = 2 - 1.0; return this.expect(var, 1.0); } + public operDoubleMinusBool() { var = 2.0 - true; return this.expect(var, 1.0); } + public operDoubleMinusInt() { var = 2.0 - 1; return this.expect(var, 1.0); } + public operDoubleMinusDouble() { var = 2.0 - 1.0; return this.expect(var, 1.0); } + // Numeric * + public operBoolTimesBool() { var = true * true; return this.expect(var, 1); } + public operBoolTimesInt() { var = true * 10; return this.expect(var, 10); } + public operBoolTimesDouble() { var = true * 10.0; return this.expect(var, 10.0); } + public operIntTimesBool() { var = 10 * true; return this.expect(var, 10); } + public operIntTimesInt() { var = 10 * 2; return this.expect(var, 20); } + public operIntTimesDouble() { var = 10 * 2.0; return this.expect(var, 20.0); } + public operDoubleTimesBool() { var = 2.0 * true; return this.expect(var, 2.0); } + public operDoubleTimesInt() { var = 2.0 * 2; return this.expect(var, 4.0); } + public operDoubleTimesDouble() { var = 2.0 * 2.0; return this.expect(var, 4.0); } + // Numeric / + public operBoolDivideBool() { var = true / true; return this.expect(var, 1); } + public operBoolDivideInt() { var = true / 1; return this.expect(var, 1); } + public operBoolDivideDouble() { var = true / 1.0; return this.expect(var, 1.0); } + public operIntDivideBool() { var = 10 / true; return this.expect(var, 10); } + public operIntDivideInt() { var = 10 / 2; return this.expect(var, 5); } + public operIntDivideDouble() { var = 10 / 2.0; return this.expect(var, 5.0); } + public operDoubleDivideBool() { var = 2.0 / true; return this.expect(var, 2.0); } + public operDoubleDivideInt() { var = 2.0 / 2; return this.expect(var, 1.0); } + public operDoubleDivideDouble() { var = 2.0 / 2.0; return this.expect(var, 1.0); } + // Numeric % + public operBoolModulusBool() { var = true % true; return this.expect(var, 0.0); } + public operBoolModulusInt() { var = true % 1; return this.expect(var, 0.0); } + public operBoolModulusDouble() { var = true % 1.0; return this.expect(var, 0.0); } + public operIntModulusBool() { var = 10 % true; return this.expect(var, 0.0); } + public operIntModulusInt() { var = 10 % 4; return this.expect(var, 2); } + public operIntModulusDouble() { var = 10 % 4.0; return this.expect(var, 2.0); } + public operDoubleModulusBool() { var = 2.0 % true; return this.expect(var, 0.0); } + public operDoubleModulusInt() { var = 2.0 % 2; return this.expect(var, 0.0); } + public operDoubleModulusDouble() { var = 2.0 % 2.0; return this.expect(var, 0.0); } + // Count # + public operLocalListCount() { var = []; var @= "Tyler"; return this.expect(#var - 1, 0); } + public operLocalMapCount() { var = {}; var['char'] = "Tyler"; return this.expect(#var, 1); } + public operMemberListCount() { return this.expect(#this.memList, 3); } + public operMemberMapCount() { return this.expect(#this.memMap, 3); } + + /********************************************************************** + * List operations. + *********************************************************************/ + public listLocalAppendNull() { tmp = []; tmp @= null; return this.expectNull(tmp[0]); } + public listLocalAppendBool() { tmp = []; tmp @= true; return this.expect(tmp[0], true); } + public listLocalAppendInt() { tmp = []; tmp @= 32; return this.expect(tmp[0], 32); } + public listLocalAppendDouble() { tmp = []; tmp @= 3.1514; return this.expect(tmp[0], 3.1514); } + public listLocalAppendString() { tmp = []; tmp @= "Tyler"; return this.expect(tmp[0], "Tyler"); } + public listLocalAppendLocalList() { tmp = []; lst = []; lst @= "Tyler"; tmp @= lst; return this.expect(tmp[0][0], "Tyler"); } + public listLocalAppendLocalMap() { tmp = []; mp = {}; mp['char'] = "Tyler"; tmp @= mp; return this.expect(tmp[0]['char'], "Tyler"); } + public listMemberAppendNull() { this.memList @= null; return this.expect(this.memList[3], null); } + public listMemberAppendBool() { this.memList @= true; return this.expect(this.memList[4], true); } + public listMemberAppendInt() { this.memList @= 32; return this.expect(this.memList[5], 32); } + public listMemberAppendDouble() { this.memList @= 3.1415; return this.expect(this.memList[6], 3.1415); } + public listMemberAppendString() { this.memList @= "Tyler"; return this.expect(this.memList[7], "Tyler"); } + public listMemberAppendLocalVarRef() { var = 8; this.memList @= "Durden"; return this.expect(this.memList[var], "Durden"); } + public listLocalNewList() { + lst = [1, 2, 3, 'four', [1, 2, 3]]; + return this.expect(lst[0] == 1 && lst[1] == 2 && lst[2] == 3 && lst[3] == 'four' && lst[4] instanceof 'list', true); + } + public listLocalGetLocalVar() { + lst = ['one', 'two', 'three']; + ind = 1; + return this.expect(lst[ind], 'two'); + } + + /********************************************************************** + * Map operations. + *********************************************************************/ + public mapMemberSetString() { this.memMap['name'] = "Tyler"; return this.expect(this.memMap['name'], "Tyler"); } + public mapMemberSetLocalVar() { + var = 'lname'; + this.memMap[var] = "Durden"; + return this.expect(this.memMap[var], "Durden"); + } + public mapLocalSetStringAssignBool() { tmp = {}; tmp['val'] = true; return this.expect(tmp['val'], true); } + public mapLocalSetStringReAssignBool() { tmp = {}; tmp['val'] = true; tmp['val'] = false; return this.expect(tmp['val'], false); } + public mapLocalSetStringAssignInt() { tmp = {}; tmp['val'] = 10; return this.expect(tmp['val'], 10); } + public mapLocalSetStringAssignDouble() { tmp = {}; tmp['val'] = 123.456; return this.expect(tmp['val'], 123.456); } + public mapLocalSetStringAssignString() { tmp = {}; tmp['val'] = "test"; return this.expect(tmp['val'], "test"); } + public mapLocalSetStringAssignList() { tmp = {}; tmp['val'] = []; return this.expectList(tmp['val']); } + public mapLocalSetStringAssignVarList() { tmp = {}; lst = []; tmp['val'] = lst; return this.expectList(tmp['val']); } + public mapLocalSetStringReAssignVarList() { tmp = {}; lst = []; tmp['val'] = lst; tmp['val'] = lst; return this.expectList(tmp['val']); } + public mapLocalSetStringAssignMap() { tmp = {}; tmp['val'] = {}; return this.expectMap(tmp['val']); } + public mapLocalSetStringReAssignVarMap() { tmp = {}; tmp['val'] = {}; tmp['val'] = {}; return this.expectMap(tmp['val']); } + public mapLocalObjRefAssignString() { + tobj = new email(); + tobj.address = 'name'; + tmap = {}; + tmap[tobj.address] = 'Tyler'; + return this.expect(tmap[tobj.address], 'Tyler'); + } + public mapLocalNewMap() { + mp = { 'one': 1, 'two': 2, 'three': 3, 'four': 'something' }; + return this.expect(mp['one'] == 1 && mp['two'] == 2 && mp['three'] == 3 && mp['four'] == 'something', true); + } + public mapLocalSetGetLocalVar() { + mp = {}; + key = 'name'; + mp[key] = 'Tyler'; + return this.expect(mp[key], 'Tyler'); + } + + + /********************************************************************** + * instanceof operator tests + *********************************************************************/ + public instanceOfNull() { tmp = null; return this.expect(tmp instanceof 'null', true); } + public instanceOfBool() { tmp = true; return this.expect(tmp instanceof 'bool', true); } + public instanceOfInt() { tmp = 32; return this.expect(tmp instanceof 'int', true); } + public instanceOfDouble() { tmp = 3.1415; return this.expect(tmp instanceof 'double', true); } + public instanceOfString() { tmp = "Tyler"; return this.expect(tmp instanceof 'string', true); } + public instanceOfList() { tmp = []; return this.expect(tmp instanceof 'list', true); } + public instanceOfMap() { tmp = {}; return this.expect(tmp instanceof 'map', true); } + public instanceOfCallback() { tmp = ::instanceOfCallback; return this.expect(tmp instanceof 'callback', true); } + public instanceOfObjectUser() { usr = new user(); usr.firstName = "Tyler"; usr.lastName = "Durden"; return this.expect(usr instanceof 'user', true); } + + /********************************************************************** + * object operations tests + *********************************************************************/ + public objectInstantiateLocal() { me = new user(); me.setName("Tyler", "Durden"); return this.expect(me.getName(), "Tyler Durden"); } + public objectInstantiateMember() { this.memObj = new user(); this.memObj.setName("Tyler", "Durden"); return this.expect(this.memObj.getName(), "Tyler Durden"); } + public objectLocalSetMember() { me = new user(); me.firstName = "Tyler"; return this.expect(me.getName(), "Tyler "); } + public objectMemberSetMember() { this.memObj.firstName = "Austin"; return this.expect(this.memObj.getName(), "Austin Durden"); } + public objectLocalSetSubMember() { me = new user(); me.emailAddress.address = "one@two.com"; return this.expect(me.emailAddress.address, "one@two.com"); } + public objectMemberSetSubMember() { this.memObj.emailAddress.address = "one@two.com"; return this.expect(this.memObj.emailAddress.address, "one@two.com"); } + public objectLocalCallSubMember() { me = new user(); me.emailAddress.setAddress("one@two.com"); return this.expect(me.emailAddress.getAddress(), "one@two.com"); } + public objectMemberCallSubMember() { this.memObj.emailAddress.setAddress("one@two.com"); return this.expect(this.memObj.emailAddress.getAddress(), "one@two.com"); } + // access public/private + public objectAccessLocVarPub() { l = new atest(); ex = false; try { t = l.pub; } catch(e) { ex = true; } return this.expect(ex, false); } + public objectAccessLocVarPri() { l = new atest(); ex = false; try { t = l.pri; } catch(e) { ex = true; } return this.expect(ex, true); } + public objectMethAccessLocVarPub() { l = new atest(); ex = false; try { t = l.pubMeth(); } catch(e) { ex = true; } return this.expect(ex, false); } + public objectMethAccessLocVarPri() { l = new atest(); ex = false; try { t = l.priMeth(); } catch(e) { ex = true; } return this.expect(ex, true); } + public objectAccessMemVarPub() { this.obj = new atest(); ex = false; try { t = this.obj.pub; } catch(e) { ex = true; } return this.expect(ex, false); } + public objectAccessMemVarPri() { ex = false; try { t = this.obj.pri; } catch(e) { ex = true; } return this.expect(ex, true); } + public objectMethAccessMemVarPub() { ex = false; try { t = this.obj.pubMeth(); } catch(e) { ex = true; } return this.expect(ex, false); } + public objectMethAccessMemVarPri() { ex = false; try { t = this.obj.priMeth(); } catch(e) { ex = true; } return this.expect(ex, true); } + public objectAccessLocVarContPub() { l = new cont(); ex = false; try { t = l.c.pub; } catch(e) { ex = true; } return this.expect(ex, false); } + public objectAccessLocVarContPri() { l = new cont(); ex = false; try { t = l.c.pri; } catch(e) { ex = true; } return this.expect(ex, true); } + public objectMethAccessLocVarContPub() { l = new cont(); ex = false; try { t = l.c.pubMeth(); } catch(e) { ex = true; } return this.expect(ex, false); } + public objectMethAccessLocVarContPri() { l = new cont(); ex = false; try { t = l.c.priMeth(); } catch(e) { ex = true; } return this.expect(ex, true); } + public objectAccessMemVarContPub() { this.obj = new cont(); ex = false; try { t = this.obj.c.pub; } catch(e) { ex = true; } return this.expect(ex, false); } + public objectAccessMemVarContPri() { ex = false; try { t = this.obj.c.pri; } catch(e) { ex = true; } return this.expect(ex, true); } + public objectMethAccessMemVarContPub() { ex = false; try { t = this.obj.c.pubMeth(); } catch(e) { ex = true; } return this.expect(ex, false); } + public objectMethAccessMemVarContPri() { ex = false; try { t = this.obj.c.priMeth(); } catch(e) { ex = true; } return this.expect(ex, true); } + + /********************************************************************** + * enum tests + *********************************************************************/ + public enumReference() { return this.expect(numName.one, 'one'); } + public enumAssignLocalReference() { tmp = numName.two; return this.expect(tmp, 'two'); } + public enumAssignMemberReference() { this.en = numName.three; return this.expect(this.en, 'three'); } + + /********************************************************************** + * if/else tests + *********************************************************************/ + public ifElseIfReturnTrue() { return this.expect(this.ifElseReturnTrue(), true); } + public ifElseElseReturnFalse() { return this.expect(this.ifElseReturnFalse(), false); } + public ifElseReturnTrue() { + if(true) { return true; } + else { return false; } + } + public ifElseReturnFalse() { + if(false) { return true; } + else { return false; } + } + public ifElseElseIfTrue() { + res = null; + if(false) { res = false; } + else if(true) { res = true; } + else { res = false; } + return this.expect(res, true); + } + + /********************************************************************** + * lang tests + *********************************************************************/ + public langLangTypeNull() { return this.expect(lang.type(null), 'null'); } + public langLangTypeBool() { return this.expect(lang.type(true), 'bool'); } + public langLangTypeInt() { return this.expect(lang.type(32), 'int'); } + public langLangTypeDouble() { return this.expect(lang.type(3.1415), 'double'); } + public langLangTypeString() { return this.expect(lang.type("Austin"), 'string'); } + public langLangCreateCallback() { this.cb = ::toCall; return this.expectCallback(this.cb); } + public langLangCallCallback() { ret = this.cb.call(); return this.expect(ret, true); } + public langLangCreateCallbackArgs() { this.cb = ::toCallWithArgs; return this.expectCallback(this.cb); } + public langLangCallCallbackArgs() { ret = this.cb.call('hi', 'there'); return this.expect(ret, 'there'); } + public langLangCreateCallbackEtc() { this.cb = ::toCallWithEtc; return this.expectCallback(this.cb); } + public langLangCallCallbackEtc() { ret = this.cb.call('hi', 'there'); return this.expect(ret, 'hi'); } + public langLangCreateCallbackEtcCnt() { this.cb = ::toCallWithEtcCnt; return this.expectCallback(this.cb); } + public langLangCallCallbackEtcCnt() { ret = this.cb.call('hi', 'there', 1, 2, 3); return this.expect(ret, 4); } + public langLangCallbackMemberAcc() { + this.cb = ::toCallCheckMemb; + ret = this.cb.call(); + return this.expect(ret, 'callback'); + } + + // callback methods + public toCall() { return true; } + public toCallWithArgs(string one, string two) { return two; } + public toCallWithEtc(string one, ...) { return one; } + public toCallWithEtcCnt(string one, ...) { return #etc; } + public toCallCheckMemb() { return lang.type(this.cb); } + + /********************************************************************** + * int tests + *********************************************************************/ + public intMaxVal() { return this.expect(Int.maxVal(), 9223372036854775807); } + public intMinVal() { return this.expect(Int.minVal(), -9223372036854775808); } + public intToDouble() { return this.expect((32).toDouble(), 32.0); } + public intToBool() { return this.expect((1).toBool(), true); } + public intToString() { return this.expect((32).toString(), "32"); } + public intCompare() { return this.expect((32).compare(32), 0); } + public intNumLeadingZeros() { return this.expect((10).numLeadingZeros(), 60); } + public intNumTrailingZeros() { return this.expect((10).numTrailingZeros(), 1); } + public intParse() { return this.expect(Int.parse("32"), 32); } + public intReverse() { return this.expect((100).reverse(), 2738188573441261568); } + public intRotateLeft() { return this.expect((100).rotateLeft(2), 400); } + public intRotateRight() { return this.expect((100).rotateRight(2), 25); } + public intSignum() { return this.expect((-125).signum(), -1); } + public intToBinary() { return this.expect((32).toBinary(), '100000'); } + public intToHex() { return this.expect((32).toHex(), '20'); } + public intToOctal() { return this.expect((32).toOctal(), '40'); } + + /********************************************************************** + * bool tests + *********************************************************************/ + public boolToInt() { return this.expect((true).toInt(), 1); } + public boolToDouble() { return this.expect((true).toDouble(), 1.0); } + public boolToString() { return this.expect((true).toString(), 'true'); } + public boolCompare() { return this.expect((true).compare(false), 1); } + public boolParse() { return this.expect(Bool.parse('true'), true); } + + /********************************************************************** + * double tests + *********************************************************************/ + public doubleMaxExponent() { return this.expect(Double.maxExp(), 1023.0); } + public doubleMinExponent() { return this.expect(Double.minExp(), -1022.0); } + public doubleMaxValue() { return this.expectDouble(Double.maxVal()); } + public doubleMinValue() { return this.expectDouble(Double.minVal()); } + public doubleMinNormalValue() { return this.expectDouble(Double.minNormal()); } + public doubleNaNValue() { return this.expectDouble(Double.nanVal()); } + public doubleNegInfinity() { return this.expect(Double.negInfinity() + '', '-Infinity'); } + public doublePosInfinity() { return this.expect(Double.posInfinity() + '', 'Infinity'); } + public doubleSize() { return this.expect(Double.size(), 64.0); } + public doubleToInt() { return this.expect((3.1415).toInt(), 3); } + public doubleToBool() { return this.expect((1.0).toBool(), true); } + public doubleToString() { return this.expect((3.1415).toString(), '3.1415'); } + public doubleCompare() { return this.expect((32.0).compare(24.0), 1); } + public doubleIsInfinite() { return this.expect(Double.posInfinity().isInfinite(), true); } + public doubleIsNaN() { return this.expect(Double.nanVal().isNan(), true); } + public doubleParse() { return this.expect(Double.parse('3.1415'), 3.1415); } + public doubleToHex() { return this.expect((3.1415).toHex(), '0x1.921cac083126fp1'); } + + /********************************************************************** + * string tests + *********************************************************************/ + public stringCharAt() { return this.expect("Tyler".charAt(1), 'y'); } + public stringCompare() { return this.expect("Ty".compare("Tyler"), -3); } + public stringCompareICase() { return this.expect("Tyler".compareICase("tyler"), 0); } + public stringConcat() { return this.expect("Ty".concat("ler"), "Tyler"); } + public stringContains() { return this.expect("Tyler".contains("yl"), true); } + public stringEndsWith() { return this.expect("Tyler".endsWith("er"), true); } + public stringEquals() { return this.expect("Tyler".equals("Tyler"), true); } + public stringEqualsICase() { return this.expect("Tyler".equalsICase("tyler"), true); } + public stringIndexOf() { return this.expect("Tyler".indexOf("ler"), 2); } + public stringIndexOfStart() { return this.expect("Tyler Durden".indexOfStart("e", 5), 10); } + public stringIsEmpty() { return this.expect("Tyler".isEmpty(), false); } + public stringLastIndexOf() { return this.expect("Tyler Durden".lastIndexOf("e"), 10); } + public stringLastIndexOfStart() { return this.expect("Tyler Durden".lastIndexOfStart("e", 5), 3); } + public stringMatches() { return this.expect("Tyler".matches("^Ty.*"), true); } + public stringReplace() { return this.expect("Tyler Durdon".replace("on", "en"), "Tyler Durden"); } + public stringReplaceFirstRegex() { return this.expect("Tyler".replaceFirstRegex("T.", "Ty"), "Tyler"); } + public stringReplaceRegex() { return this.expect("Tyler Durden".replaceRegex("e.", "on"), "Tylon Durdon"); } + public stringSplit() { return this.expect("one,two,three".split(",")[1], "two"); } + public stringStartsWith() { return this.expect("Tyler Durden".startsWith("Tyler "), true); } + public stringSubstr() { return this.expect("Tyler".substr(2), "ler"); } + public stringSubstrEnd() { return this.expect("Tyler".substr(2, 4), "le"); } + public stringToLower() { return this.expect("Tyler".toLower(), "tyler"); } + public stringToUpper() { return this.expect("Tyler".toUpper(), "TYLER"); } + public stringTrim() { return this.expect(" Tyler ".trim(), "Tyler"); } + + /********************************************************************** + * list tests + *********************************************************************/ + public listCreate() { this.tlist = new list(); return this.expectList(this.tlist); } + public listAdd() { this.tlist.add("one"); return this.expect(#this.tlist, 1); } + public listAddAll() { tmp = []; tmp @= "two"; tmp @= "three"; this.tlist.addAll(tmp); return this.expect(#this.tlist, 3); } + public listAddAllAt() { tmp = []; tmp @= "two"; tmp @= "three"; this.tlist.addAllAt(tmp, 1); return this.expect(this.tlist[2], 'three'); } + public listClone() { tmp = this.tlist.clone(); return this.expect(#tmp, 5); } + public listContainsObjRef() { tmp = "hi"; this.tlist @= tmp; return this.expect(this.tlist.containsObjRef(tmp), true); } + public listContains() { return this.expect(this.tlist.contains('hi'), true); } + public listGet() { return this.expect(this.tlist.get(#this.tlist - 1), "hi"); } + public listIndexOf() { tmp = "howdy"; this.tlist @= tmp; return this.expect(this.tlist.indexOf(tmp), 6); } + public listIsEmpty() { return this.expect(this.tlist.isEmpty(), false); } + public listRemove() { tmp = "howdy"; this.tlist @= tmp; this.tlist.remove(tmp); return this.expect(#this.tlist, 7); } + public listRemoveAt() { this.tlist.removeAt(6); return this.expect(#this.tlist, 6); } + public listRemoveAll() { tmp = []; tmp @= "one"; tmp @= "two"; this.tlist @= tmp[0]; this.tlist @= tmp[1]; this.tlist.removeAll(tmp); return this.expect(#this.tlist, 6); } + public listRetainAll() { tmp = []; tmp @= "one"; tmp @= "two"; this.tlist @= tmp[0]; this.tlist @= tmp[1]; this.tlist.retainAll(tmp); return this.expect(#this.tlist, 2); } + public listSet() { this.tlist @= "five"; this.tlist.set(2, "three"); return this.expect(this.tlist[2], "three"); } + public listSize() { return this.expect(this.tlist.size(), 3); } + public listSubList() { tmp = this.tlist.subList(0, 2); return this.expect(#tmp, 2); } + public listSort() { tmp = this.tlist.sort(); return this.expect(tmp[2], 'two'); } + public listSortAsc() { tmp = this.tlist.sortAsc(); return this.expect(tmp[2], 'one'); } + public listSortCustom() { + dogs = []; + dogs @= new dog("Labrador"); + dogs @= new dog("Maltese"); + dogs @= new dog("German Shepherd"); + sortedDogs = dogs.sortCustom(::customComparator); + // TODO: Add list.join()! + return this.expect(sortedDogs[2].breed, "Maltese"); + } + public customComparator(object d1, object d2) { return d1.breed.compare(d2.breed); } + public listClear() { this.tlist.clear(); return this.expect(#this.tlist, 0); } + + /********************************************************************** + * map tests + *********************************************************************/ + public mapCreate() { this.tmap = new map(); return this.expectMap(this.tmap); } + public mapContainsKey() { this.tmap['name'] = "Tyler"; return this.expect(this.tmap.containsKey('name'), true); } + public mapContainsValue() { val = 'programmer'; this.tmap['occupation'] = val; return this.expect(this.tmap.containsVal(val), true); } + public mapGet() { return this.expect(this.tmap.get('occupation'), 'programmer'); } + public mapIsEmpty() { return this.expect(this.tmap.isEmpty(), false); } + public mapKeySet() { return this.expect(#this.tmap.keySet(), 2); } + public mapPut() { this.tmap.put('age', 32); return this.expect(this.tmap['age'], 32); } + public mapPutAll() { tm = {}; tm['1'] = 'one'; tm['2'] = 'two'; this.tmap.putAll(tm); return this.expect(this.tmap['1'], 'one'); } + public mapPutIfAbsent() { this.tmap.putIfAbsent('2', 'three'); return this.expect(this.tmap['2'], 'two'); } + public mapRemove() { this.tmap.remove('2'); return this.expect(this.tmap.containsKey('2'), false); } + public mapSize() { return this.expect(this.tmap.size(), #this.tmap); } + public mapValues() { mp = {}; mp['name'] = 'Tyler'; return this.expect(mp.values()[0], 'Tyler'); } + public mapClear() { this.tmap.clear(); return this.expect(#this.tmap, 0); } + + /********************************************************************** + * buffer tests + *********************************************************************/ + public bufferInstantiate() { this.buff = new buffer(); return this.expectObject(this.buff, 'buffer'); } + public bufferSize() { return this.expect(this.buff.size(), 1024); } + public bufferAddString() { this.buff.addString("welcome"); return this.expect(this.buff.getStringAt(this.buff.getWriteCursor()), "welcome"); } + public bufferAddByte() { this.buff.addByte(10); return this.expect(this.buff.getByte(), 10); } + public bufferAddUByte() { this.buff.addUByte(15); return this.expect(this.buff.getUByte(), 15); } + public bufferAddShort() { this.buff.addShort(12345); return this.expect(this.buff.getShort(), 12345); } + public bufferAddUShort() { this.buff.addUShort(12345); return this.expect(this.buff.getUShort(), 12345); } + public bufferAddInt() { this.buff.addInt(12345678); return this.expect(this.buff.getInt(), 12345678); } + public bufferAddUInt() { this.buff.addUInt(12345678); return this.expect(this.buff.getUInt(), 12345678); } + public bufferAddLong() { this.buff.addLong(1234567890); return this.expect(this.buff.getLong(), 1234567890); } + public bufferAddFloat() { this.buff.addFloat(123.456); return this.expect(math.round(this.buff.getFloat()), 123.0); } + public bufferAddDouble() { this.buff.addDouble(123456.123456); return this.expect(this.buff.getDouble(), 123456.123456); } + public bufferGetWriteCursor() { return this.expect(this.buff.getWriteCursor(), 41); } + public bufferGetReadCursor() { return this.expect(this.buff.getReadCursor(), 37); } + public bufferSetString() { this.buff.setString("Hello World"); return this.expect(this.buff.getString(), "Hello World"); } + public bufferSetByte() { this.buff = new buffer(); this.buff.setByte(0, 10); return this.expect(this.buff.getByte(0), 10); } + public bufferSetUByte() { this.buff.setUByte(1, 64); return this.expect(this.buff.getUByte(1), 64); } + public bufferSetShort() { this.buff.setShort(2, 1000); return this.expect(this.buff.getShort(2), 1000); } + public bufferSetUShort() { this.buff.setUShort(4, 1024); return this.expect(this.buff.getUShort(4), 1024); } + public bufferSetInt() { this.buff.setInt(6, 123456); return this.expect(this.buff.getInt(6), 123456); } + public bufferSetUInt() { this.buff.setUInt(10, 1234567); return this.expect(this.buff.getUInt(10), 1234567); } + public bufferSetLong() { this.buff.setLong(14, 1234567890); return this.expect(this.buff.getLong(14), 1234567890); } + public bufferSetFloat() { this.buff.setFloat(22, 123.456); return this.expect(math.round(this.buff.getFloat(22)), 123.0); } + public bufferSetDouble() { this.buff.setDouble(26, 12345.12345); return this.expect(this.buff.getDouble(26), 12345.12345); } + public bufferCopyFrom() { tmp = new buffer(); tmp.copyFrom(0, this.buff, 0, 34); return this.expect(tmp.getDouble(26), 12345.12345); } + public bufferCopyTo() { tmp = new buffer(); this.buff.copyTo(0, tmp, 0, 34); return this.expect(tmp.getDouble(26), 12345.12345); } + public bufferByteToBinary() { return this.expect(this.buff.byteToBinary(0), '00001010'); } + public bufferShortToBinary() { return this.expect(this.buff.shortToBinary(2), '0000001111101000'); } + public bufferIntToBinary() { return this.expect(this.buff.intToBinary(6), '00000000000000011110001001000000'); } + public bufferLongToBinary() { return this.expect(this.buff.longToBinary(14), '0000000000000000000000000000000001001001100101100000001011010010'); } + public bufferFloatToBinary() { return this.expect(this.buff.floatToBinary(22), '01000010111101101110100101111001'); } + public bufferDoubleToBinary() { return this.expect(this.buff.doubleToBinary(26), '0100000011001000000111001000111111001101001101011010100001011000'); } + public bufferClear() { this.buff.clear(); return this.expect(this.buff.getByte(0), 0); } + + /********************************************************************** + * date tests + *********************************************************************/ + public dateInstantiate() { this.dt = new date(); return this.expectObject(this.dt, 'date'); } + public dateSetHours() { this.dt.setHours(1); return this.expect(this.dt.getHours(), 1); } + public dateSetMinutes() { this.dt.setMinutes(30); return this.expect(this.dt.getMinutes(), 30); } + public dateSetSeconds() { this.dt.setSeconds(30); return this.expect(this.dt.getSeconds(), 30); } + public dateSetTime() { this.dt.setTime(3600); return this.expect(this.dt.getTime(), 3600); } + public dateToString() { return this.expectString(this.dt.toString()); } + public dateParse() { this.dt.parse("2014-12-31 23:59:59", "yyyy-MM-dd HH:mm:ss"); return this.expectObject(this.dt, 'date'); } + public dateFormat() { return this.expect(this.dt.format("yyyy-MM-dd HH:mm:ss"), "2014-12-31 23:59:59"); } + public dateIsEpoch() { this.dt = new date(0); return this.expect(this.dt.isEpoch(), true); } +} \ No newline at end of file