diff --git a/CHANGELOG.md b/CHANGELOG.md new file mode 100644 --- /dev/null +++ b/CHANGELOG.md @@ -0,0 +1,9 @@ +# Revision history for happy-dot + +## 1.0.0.0 -- 2019-12-21 + +* First version. + - Parsing of DOT files. + - Utility function to obtain adjacency of nodes in a DOT file. + - Utility function to output a DOT file from a list of nodes and edges. + - Pretty printing. diff --git a/LICENSE b/LICENSE new file mode 100644 --- /dev/null +++ b/LICENSE @@ -0,0 +1,674 @@ + GNU GENERAL PUBLIC LICENSE + Version 3, 29 June 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The GNU General Public License is a free, copyleft license for +software and other kinds of works. + + The licenses for most software and other practical works are designed +to take away your freedom to share and change the works. By contrast, +the GNU General Public License is intended to guarantee your freedom to +share and change all versions of a program--to make sure it remains free +software for all its users. We, the Free Software Foundation, use the +GNU General Public License for most of our software; it applies also to +any other work released this way by its authors. You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +them if you wish), that you receive source code or can get it if you +want it, that you can change the software or use pieces of it in new +free programs, and that you know you can do these things. + + To protect your rights, we need to prevent others from denying you +these rights or asking you to surrender the rights. Therefore, you have +certain responsibilities if you distribute copies of the software, or if +you modify it: responsibilities to respect the freedom of others. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must pass on to the recipients the same +freedoms that you received. You must make sure that they, too, receive +or can get the source code. And you must show them these terms so they +know their rights. + + Developers that use the GNU GPL protect your rights with two steps: +(1) assert copyright on the software, and (2) offer you this License +giving you legal permission to copy, distribute and/or modify it. + + For the developers' and authors' protection, the GPL clearly explains +that there is no warranty for this free software. For both users' and +authors' sake, the GPL requires that modified versions be marked as +changed, so that their problems will not be attributed erroneously to +authors of previous versions. + + Some devices are designed to deny users access to install or run +modified versions of the software inside them, although the manufacturer +can do so. This is fundamentally incompatible with the aim of +protecting users' freedom to change the software. The systematic +pattern of such abuse occurs in the area of products for individuals to +use, which is precisely where it is most unacceptable. Therefore, we +have designed this version of the GPL to prohibit the practice for those +products. If such problems arise substantially in other domains, we +stand ready to extend this provision to those domains in future versions +of the GPL, as needed to protect the freedom of users. + + Finally, every program is threatened constantly by software patents. +States should not allow patents to restrict development and use of +software on general-purpose computers, but in those that do, we wish to +avoid the special danger that patents applied to a free program could +make it effectively proprietary. To prevent this, the GPL assures that +patents cannot be used to render the program non-free. + + The precise terms and conditions for copying, distribution and +modification follow. + + TERMS AND CONDITIONS + + 0. Definitions. + + "This License" refers to version 3 of the GNU General Public License. + + "Copyright" also means copyright-like laws that apply to other kinds of +works, such as semiconductor masks. + + "The Program" refers to any copyrightable work licensed under this +License. Each licensee is addressed as "you". "Licensees" and +"recipients" may be individuals or organizations. + + To "modify" a work means to copy from or adapt all or part of the work +in a fashion requiring copyright permission, other than the making of an +exact copy. The resulting work is called a "modified version" of the +earlier work or a work "based on" the earlier work. + + A "covered work" means either the unmodified Program or a work based +on the Program. + + To "propagate" a work means to do anything with it that, without +permission, would make you directly or secondarily liable for +infringement under applicable copyright law, except executing it on a +computer or modifying a private copy. Propagation includes copying, +distribution (with or without modification), making available to the +public, and in some countries other activities as well. + + To "convey" a work means any kind of propagation that enables other +parties to make or receive copies. Mere interaction with a user through +a computer network, with no transfer of a copy, is not conveying. + + An interactive user interface displays "Appropriate Legal Notices" +to the extent that it includes a convenient and prominently visible +feature that (1) displays an appropriate copyright notice, and (2) +tells the user that there is no warranty for the work (except to the +extent that warranties are provided), that licensees may convey the +work under this License, and how to view a copy of this License. If +the interface presents a list of user commands or options, such as a +menu, a prominent item in the list meets this criterion. + + 1. Source Code. + + The "source code" for a work means the preferred form of the work +for making modifications to it. "Object code" means any non-source +form of a work. + + A "Standard Interface" means an interface that either is an official +standard defined by a recognized standards body, or, in the case of +interfaces specified for a particular programming language, one that +is widely used among developers working in that language. + + The "System Libraries" of an executable work include anything, other +than the work as a whole, that (a) is included in the normal form of +packaging a Major Component, but which is not part of that Major +Component, and (b) serves only to enable use of the work with that +Major Component, or to implement a Standard Interface for which an +implementation is available to the public in source code form. A +"Major Component", in this context, means a major essential component +(kernel, window system, and so on) of the specific operating system +(if any) on which the executable work runs, or a compiler used to +produce the work, or an object code interpreter used to run it. + + The "Corresponding Source" for a work in object code form means all +the source code needed to generate, install, and (for an executable +work) run the object code and to modify the work, including scripts to +control those activities. However, it does not include the work's +System Libraries, or general-purpose tools or generally available free +programs which are used unmodified in performing those activities but +which are not part of the work. For example, Corresponding Source +includes interface definition files associated with source files for +the work, and the source code for shared libraries and dynamically +linked subprograms that the work is specifically designed to require, +such as by intimate data communication or control flow between those +subprograms and other parts of the work. + + The Corresponding Source need not include anything that users +can regenerate automatically from other parts of the Corresponding +Source. + + The Corresponding Source for a work in source code form is that +same work. + + 2. Basic Permissions. + + All rights granted under this License are granted for the term of +copyright on the Program, and are irrevocable provided the stated +conditions are met. This License explicitly affirms your unlimited +permission to run the unmodified Program. The output from running a +covered work is covered by this License only if the output, given its +content, constitutes a covered work. This License acknowledges your +rights of fair use or other equivalent, as provided by copyright law. + + You may make, run and propagate covered works that you do not +convey, without conditions so long as your license otherwise remains +in force. You may convey covered works to others for the sole purpose +of having them make modifications exclusively for you, or provide you +with facilities for running those works, provided that you comply with +the terms of this License in conveying all material for which you do +not control copyright. Those thus making or running the covered works +for you must do so exclusively on your behalf, under your direction +and control, on terms that prohibit them from making any copies of +your copyrighted material outside their relationship with you. + + Conveying under any other circumstances is permitted solely under +the conditions stated below. Sublicensing is not allowed; section 10 +makes it unnecessary. + + 3. Protecting Users' Legal Rights From Anti-Circumvention Law. + + No covered work shall be deemed part of an effective technological +measure under any applicable law fulfilling obligations under article +11 of the WIPO copyright treaty adopted on 20 December 1996, or +similar laws prohibiting or restricting circumvention of such +measures. + + When you convey a covered work, you waive any legal power to forbid +circumvention of technological measures to the extent such circumvention +is effected by exercising rights under this License with respect to +the covered work, and you disclaim any intention to limit operation or +modification of the work as a means of enforcing, against the work's +users, your or third parties' legal rights to forbid circumvention of +technological measures. + + 4. Conveying Verbatim Copies. + + You may convey verbatim copies of the Program's source code as you +receive it, in any medium, provided that you conspicuously and +appropriately publish on each copy an appropriate copyright notice; +keep intact all notices stating that this License and any +non-permissive terms added in accord with section 7 apply to the code; +keep intact all notices of the absence of any warranty; and give all +recipients a copy of this License along with the Program. + + You may charge any price or no price for each copy that you convey, +and you may offer support or warranty protection for a fee. + + 5. Conveying Modified Source Versions. + + You may convey a work based on the Program, or the modifications to +produce it from the Program, in the form of source code under the +terms of section 4, provided that you also meet all of these conditions: + + a) The work must carry prominent notices stating that you modified + it, and giving a relevant date. + + b) The work must carry prominent notices stating that it is + released under this License and any conditions added under section + 7. This requirement modifies the requirement in section 4 to + "keep intact all notices". + + c) You must license the entire work, as a whole, under this + License to anyone who comes into possession of a copy. This + License will therefore apply, along with any applicable section 7 + additional terms, to the whole of the work, and all its parts, + regardless of how they are packaged. This License gives no + permission to license the work in any other way, but it does not + invalidate such permission if you have separately received it. + + d) If the work has interactive user interfaces, each must display + Appropriate Legal Notices; however, if the Program has interactive + interfaces that do not display Appropriate Legal Notices, your + work need not make them do so. + + A compilation of a covered work with other separate and independent +works, which are not by their nature extensions of the covered work, +and which are not combined with it such as to form a larger program, +in or on a volume of a storage or distribution medium, is called an +"aggregate" if the compilation and its resulting copyright are not +used to limit the access or legal rights of the compilation's users +beyond what the individual works permit. Inclusion of a covered work +in an aggregate does not cause this License to apply to the other +parts of the aggregate. + + 6. Conveying Non-Source Forms. + + You may convey a covered work in object code form under the terms +of sections 4 and 5, provided that you also convey the +machine-readable Corresponding Source under the terms of this License, +in one of these ways: + + a) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by the + Corresponding Source fixed on a durable physical medium + customarily used for software interchange. + + b) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by a + written offer, valid for at least three years and valid for as + long as you offer spare parts or customer support for that product + model, to give anyone who possesses the object code either (1) a + copy of the Corresponding Source for all the software in the + product that is covered by this License, on a durable physical + medium customarily used for software interchange, for a price no + more than your reasonable cost of physically performing this + conveying of source, or (2) access to copy the + Corresponding Source from a network server at no charge. + + c) Convey individual copies of the object code with a copy of the + written offer to provide the Corresponding Source. This + alternative is allowed only occasionally and noncommercially, and + only if you received the object code with such an offer, in accord + with subsection 6b. + + d) Convey the object code by offering access from a designated + place (gratis or for a charge), and offer equivalent access to the + Corresponding Source in the same way through the same place at no + further charge. You need not require recipients to copy the + Corresponding Source along with the object code. If the place to + copy the object code is a network server, the Corresponding Source + may be on a different server (operated by you or a third party) + that supports equivalent copying facilities, provided you maintain + clear directions next to the object code saying where to find the + Corresponding Source. Regardless of what server hosts the + Corresponding Source, you remain obligated to ensure that it is + available for as long as needed to satisfy these requirements. + + e) Convey the object code using peer-to-peer transmission, provided + you inform other peers where the object code and Corresponding + Source of the work are being offered to the general public at no + charge under subsection 6d. + + A separable portion of the object code, whose source code is excluded +from the Corresponding Source as a System Library, need not be +included in conveying the object code work. + + A "User Product" is either (1) a "consumer product", which means any +tangible personal property which is normally used for personal, family, +or household purposes, or (2) anything designed or sold for incorporation +into a dwelling. In determining whether a product is a consumer product, +doubtful cases shall be resolved in favor of coverage. For a particular +product received by a particular user, "normally used" refers to a +typical or common use of that class of product, regardless of the status +of the particular user or of the way in which the particular user +actually uses, or expects or is expected to use, the product. A product +is a consumer product regardless of whether the product has substantial +commercial, industrial or non-consumer uses, unless such uses represent +the only significant mode of use of the product. + + "Installation Information" for a User Product means any methods, +procedures, authorization keys, or other information required to install +and execute modified versions of a covered work in that User Product from +a modified version of its Corresponding Source. The information must +suffice to ensure that the continued functioning of the modified object +code is in no case prevented or interfered with solely because +modification has been made. + + If you convey an object code work under this section in, or with, or +specifically for use in, a User Product, and the conveying occurs as +part of a transaction in which the right of possession and use of the +User Product is transferred to the recipient in perpetuity or for a +fixed term (regardless of how the transaction is characterized), the +Corresponding Source conveyed under this section must be accompanied +by the Installation Information. But this requirement does not apply +if neither you nor any third party retains the ability to install +modified object code on the User Product (for example, the work has +been installed in ROM). + + The requirement to provide Installation Information does not include a +requirement to continue to provide support service, warranty, or updates +for a work that has been modified or installed by the recipient, or for +the User Product in which it has been modified or installed. Access to a +network may be denied when the modification itself materially and +adversely affects the operation of the network or violates the rules and +protocols for communication across the network. + + Corresponding Source conveyed, and Installation Information provided, +in accord with this section must be in a format that is publicly +documented (and with an implementation available to the public in +source code form), and must require no special password or key for +unpacking, reading or copying. + + 7. Additional Terms. + + "Additional permissions" are terms that supplement the terms of this +License by making exceptions from one or more of its conditions. +Additional permissions that are applicable to the entire Program shall +be treated as though they were included in this License, to the extent +that they are valid under applicable law. If additional permissions +apply only to part of the Program, that part may be used separately +under those permissions, but the entire Program remains governed by +this License without regard to the additional permissions. + + When you convey a copy of a covered work, you may at your option +remove any additional permissions from that copy, or from any part of +it. (Additional permissions may be written to require their own +removal in certain cases when you modify the work.) You may place +additional permissions on material, added by you to a covered work, +for which you have or can give appropriate copyright permission. + + Notwithstanding any other provision of this License, for material you +add to a covered work, you may (if authorized by the copyright holders of +that material) supplement the terms of this License with terms: + + a) Disclaiming warranty or limiting liability differently from the + terms of sections 15 and 16 of this License; or + + b) Requiring preservation of specified reasonable legal notices or + author attributions in that material or in the Appropriate Legal + Notices displayed by works containing it; or + + c) Prohibiting misrepresentation of the origin of that material, or + requiring that modified versions of such material be marked in + reasonable ways as different from the original version; or + + d) Limiting the use for publicity purposes of names of licensors or + authors of the material; or + + e) Declining to grant rights under trademark law for use of some + trade names, trademarks, or service marks; or + + f) Requiring indemnification of licensors and authors of that + material by anyone who conveys the material (or modified versions of + it) with contractual assumptions of liability to the recipient, for + any liability that these contractual assumptions directly impose on + those licensors and authors. + + All other non-permissive additional terms are considered "further +restrictions" within the meaning of section 10. If the Program as you +received it, or any part of it, contains a notice stating that it is +governed by this License along with a term that is a further +restriction, you may remove that term. If a license document contains +a further restriction but permits relicensing or conveying under this +License, you may add to a covered work material governed by the terms +of that license document, provided that the further restriction does +not survive such relicensing or conveying. + + If you add terms to a covered work in accord with this section, you +must place, in the relevant source files, a statement of the +additional terms that apply to those files, or a notice indicating +where to find the applicable terms. + + Additional terms, permissive or non-permissive, may be stated in the +form of a separately written license, or stated as exceptions; +the above requirements apply either way. + + 8. Termination. + + You may not propagate or modify a covered work except as expressly +provided under this License. Any attempt otherwise to propagate or +modify it is void, and will automatically terminate your rights under +this License (including any patent licenses granted under the third +paragraph of section 11). + + However, if you cease all violation of this License, then your +license from a particular copyright holder is reinstated (a) +provisionally, unless and until the copyright holder explicitly and +finally terminates your license, and (b) permanently, if the copyright +holder fails to notify you of the violation by some reasonable means +prior to 60 days after the cessation. + + Moreover, your license from a particular copyright holder is +reinstated permanently if the copyright holder notifies you of the +violation by some reasonable means, this is the first time you have +received notice of violation of this License (for any work) from that +copyright holder, and you cure the violation prior to 30 days after +your receipt of the notice. + + Termination of your rights under this section does not terminate the +licenses of parties who have received copies or rights from you under +this License. If your rights have been terminated and not permanently +reinstated, you do not qualify to receive new licenses for the same +material under section 10. + + 9. Acceptance Not Required for Having Copies. + + You are not required to accept this License in order to receive or +run a copy of the Program. Ancillary propagation of a covered work +occurring solely as a consequence of using peer-to-peer transmission +to receive a copy likewise does not require acceptance. However, +nothing other than this License grants you permission to propagate or +modify any covered work. These actions infringe copyright if you do +not accept this License. Therefore, by modifying or propagating a +covered work, you indicate your acceptance of this License to do so. + + 10. Automatic Licensing of Downstream Recipients. + + Each time you convey a covered work, the recipient automatically +receives a license from the original licensors, to run, modify and +propagate that work, subject to this License. You are not responsible +for enforcing compliance by third parties with this License. + + An "entity transaction" is a transaction transferring control of an +organization, or substantially all assets of one, or subdividing an +organization, or merging organizations. If propagation of a covered +work results from an entity transaction, each party to that +transaction who receives a copy of the work also receives whatever +licenses to the work the party's predecessor in interest had or could +give under the previous paragraph, plus a right to possession of the +Corresponding Source of the work from the predecessor in interest, if +the predecessor has it or can get it with reasonable efforts. + + You may not impose any further restrictions on the exercise of the +rights granted or affirmed under this License. For example, you may +not impose a license fee, royalty, or other charge for exercise of +rights granted under this License, and you may not initiate litigation +(including a cross-claim or counterclaim in a lawsuit) alleging that +any patent claim is infringed by making, using, selling, offering for +sale, or importing the Program or any portion of it. + + 11. Patents. + + A "contributor" is a copyright holder who authorizes use under this +License of the Program or a work on which the Program is based. The +work thus licensed is called the contributor's "contributor version". + + A contributor's "essential patent claims" are all patent claims +owned or controlled by the contributor, whether already acquired or +hereafter acquired, that would be infringed by some manner, permitted +by this License, of making, using, or selling its contributor version, +but do not include claims that would be infringed only as a +consequence of further modification of the contributor version. For +purposes of this definition, "control" includes the right to grant +patent sublicenses in a manner consistent with the requirements of +this License. + + Each contributor grants you a non-exclusive, worldwide, royalty-free +patent license under the contributor's essential patent claims, to +make, use, sell, offer for sale, import and otherwise run, modify and +propagate the contents of its contributor version. + + In the following three paragraphs, a "patent license" is any express +agreement or commitment, however denominated, not to enforce a patent +(such as an express permission to practice a patent or covenant not to +sue for patent infringement). To "grant" such a patent license to a +party means to make such an agreement or commitment not to enforce a +patent against the party. + + If you convey a covered work, knowingly relying on a patent license, +and the Corresponding Source of the work is not available for anyone +to copy, free of charge and under the terms of this License, through a +publicly available network server or other readily accessible means, +then you must either (1) cause the Corresponding Source to be so +available, or (2) arrange to deprive yourself of the benefit of the +patent license for this particular work, or (3) arrange, in a manner +consistent with the requirements of this License, to extend the patent +license to downstream recipients. "Knowingly relying" means you have +actual knowledge that, but for the patent license, your conveying the +covered work in a country, or your recipient's use of the covered work +in a country, would infringe one or more identifiable patents in that +country that you have reason to believe are valid. + + If, pursuant to or in connection with a single transaction or +arrangement, you convey, or propagate by procuring conveyance of, a +covered work, and grant a patent license to some of the parties +receiving the covered work authorizing them to use, propagate, modify +or convey a specific copy of the covered work, then the patent license +you grant is automatically extended to all recipients of the covered +work and works based on it. + + A patent license is "discriminatory" if it does not include within +the scope of its coverage, prohibits the exercise of, or is +conditioned on the non-exercise of one or more of the rights that are +specifically granted under this License. You may not convey a covered +work if you are a party to an arrangement with a third party that is +in the business of distributing software, under which you make payment +to the third party based on the extent of your activity of conveying +the work, and under which the third party grants, to any of the +parties who would receive the covered work from you, a discriminatory +patent license (a) in connection with copies of the covered work +conveyed by you (or copies made from those copies), or (b) primarily +for and in connection with specific products or compilations that +contain the covered work, unless you entered into that arrangement, +or that patent license was granted, prior to 28 March 2007. + + Nothing in this License shall be construed as excluding or limiting +any implied license or other defenses to infringement that may +otherwise be available to you under applicable patent law. + + 12. No Surrender of Others' Freedom. + + If conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot convey a +covered work so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you may +not convey it at all. For example, if you agree to terms that obligate you +to collect a royalty for further conveying from those to whom you convey +the Program, the only way you could satisfy both those terms and this +License would be to refrain entirely from conveying the Program. + + 13. Use with the GNU Affero General Public License. + + Notwithstanding any other provision of this License, you have +permission to link or combine any covered work with a work licensed +under version 3 of the GNU Affero General Public License into a single +combined work, and to convey the resulting work. The terms of this +License will continue to apply to the part which is the covered work, +but the special requirements of the GNU Affero General Public License, +section 13, concerning interaction through a network will apply to the +combination as such. + + 14. Revised Versions of this License. + + The Free Software Foundation may publish revised and/or new versions of +the GNU General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + + Each version is given a distinguishing version number. If the +Program specifies that a certain numbered version of the GNU General +Public License "or any later version" applies to it, you have the +option of following the terms and conditions either of that numbered +version or of any later version published by the Free Software +Foundation. If the Program does not specify a version number of the +GNU General Public License, you may choose any version ever published +by the Free Software Foundation. + + If the Program specifies that a proxy can decide which future +versions of the GNU General Public License can be used, that proxy's +public statement of acceptance of a version permanently authorizes you +to choose that version for the Program. + + Later license versions may give you additional or different +permissions. However, no additional obligations are imposed on any +author or copyright holder as a result of your choosing to follow a +later version. + + 15. Disclaimer of Warranty. + + THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY +APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT +HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY +OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM +IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF +ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. Limitation of Liability. + + IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS +THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY +GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE +USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF +DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD +PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), +EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF +SUCH DAMAGES. + + 17. Interpretation of Sections 15 and 16. + + If the disclaimer of warranty and limitation of liability provided +above cannot be given local legal effect according to their terms, +reviewing courts shall apply local law that most closely approximates +an absolute waiver of all civil liability in connection with the +Program, unless a warranty or assumption of liability accompanies a +copy of the Program in return for a fee. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +state the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . + +Also add information on how to contact you by electronic and paper mail. + + If the program does terminal interaction, make it output a short +notice like this when it starts in an interactive mode: + + Copyright (C) + This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, your program's commands +might be different; for a GUI interface, you would use an "about box". + + You should also get your employer (if you work as a programmer) or school, +if any, to sign a "copyright disclaimer" for the program, if necessary. +For more information on this, and how to apply and follow the GNU GPL, see +. + + The GNU General Public License does not permit incorporating your program +into proprietary programs. If your program is a subroutine library, you +may consider it more useful to permit linking proprietary applications with +the library. If this is what you want to do, use the GNU Lesser General +Public License instead of this License. But first, please read +. diff --git a/Setup.hs b/Setup.hs new file mode 100644 --- /dev/null +++ b/Setup.hs @@ -0,0 +1,2 @@ +import Distribution.Simple +main = defaultMain diff --git a/benchmarks/GraphGenerator.hs b/benchmarks/GraphGenerator.hs new file mode 100644 --- /dev/null +++ b/benchmarks/GraphGenerator.hs @@ -0,0 +1,17 @@ +module GraphGenerator where + +import Data.List + +generateGrid w h = intercalate "\n" $ concat + [ [ "graph \"grid-" ++ show (w,h) ++ "\" { "] + , [ intercalate " -- " [ '"' : show (r,c) ++ "\"" | c <- [1..w] ] | r <- [1..h] ] + , [ intercalate " -- " [ '"' : show (r,c) ++ "\"" | r <- [1..h] ] | c <- [1..w] ] + , ["}"] + ] + +generateComplete k = intercalate "\n" $ + [ "graph \"complete-" ++ show k ++ "\" { "] ++ + [ show v ++ " [color = blue, x = 20, y = 30, shape = circle];\n" ++ show v ++ " -- {" ++ intercalate " " [show u | u <- [1..v-1]] ++ "}" | v <- [1..k]] ++ ["}"] + + +instances = [generateGrid r r | r <- [50..100]] ++ [generateComplete k | k <- [100..150]] diff --git a/benchmarks/HappyDotBench.hs b/benchmarks/HappyDotBench.hs new file mode 100644 --- /dev/null +++ b/benchmarks/HappyDotBench.hs @@ -0,0 +1,36 @@ +{-# LANGUAGE BangPatterns #-} +module Main where + +import GraphGenerator + +import Language.Dot.Parser +import Language.Dot.Utils +import Data.List + +import System.Clock + +runBench !gStr = do + start <- getTime ProcessCPUTime + let Right ast = parse gStr + (_,_,name,_) = ast + (vertices, edges) = adjacency ast + !numVerts = length vertices + !numEdges = length edges + end <- getTime ProcessCPUTime + let delta = (toNanoSecs $ diffTimeSpec end start) `div` 10^6 + return $ ( intercalate "," + [ "happy-dot" + , show name + , show numVerts + , show numEdges + , show delta + ] , + delta) + +main = do + results <- mapM runBench instances + let times = map snd results + let avg = sum times + writeFile "benchmark-happy-dot.csv" $ intercalate "\n" $ "library, instance, vertices, edges, time (ms)" : map fst results + putStrLn $ "Total time: " ++ show avg ++ " milliseconds" + diff --git a/benchmarks/LanguageDotBench.hs b/benchmarks/LanguageDotBench.hs new file mode 100644 --- /dev/null +++ b/benchmarks/LanguageDotBench.hs @@ -0,0 +1,72 @@ +{-# LANGUAGE BangPatterns #-} +module Main where + +import GraphGenerator + +import Language.Dot.Parser +import Language.Dot.Syntax +import Data.List + +import System.Clock + +data GraphElement a = Node String [a] | Edge String String [a] + +adjacency (Graph _ _ _ stmts) = adjacency' [] [] stmts + where + adjacency' _ _ [] = ([],[]) + adjacency' nodeAttr edgeAttr (stmt:ss) = + case stmt of + (EdgeStatement subgraphs attributes) -> + let sgs = (map (subgraphAdjacency nodeAttr edgeAttr) subgraphs) + edges = concatMap snd (sgs) + nodes = map fst (sgs) + pathEdges = makePath ((reverse attributes) ++ edgeAttr) nodes + (ns, es) = adjacency' nodeAttr edgeAttr ss + in ((concat nodes) ++ ns, (edges ++ pathEdges) ++ es) + (NodeStatement (NodeId name _) attributes) -> + let (ns, es) = adjacency' nodeAttr edgeAttr ss + in ((Node (show name) (nodeAttr ++ attributes)) : ns, es) + (SubgraphStatement subgraph) -> case subgraph of + SubgraphRef name -> + let (ns, es) = adjacency' nodeAttr edgeAttr ss + in ((Node (show name) nodeAttr) : ns, es) + NewSubgraph name stmts -> adjacency' nodeAttr edgeAttr stmts + (AttributeStatement GraphAttributeStatement attributes) + -> adjacency' nodeAttr edgeAttr ss + (AssignmentStatement _ _) + -> adjacency' nodeAttr edgeAttr ss + (AttributeStatement EdgeAttributeStatement attributes) + -> adjacency' nodeAttr ((reverse attributes) ++ edgeAttr) ss + (AttributeStatement NodeAttributeStatement attributes) + -> adjacency' ((reverse attributes) ++ nodeAttr) edgeAttr ss + subgraphAdjacency nodeAttr edgeAttr (ENodeId _ (NodeId name port)) = ([Node (show name) []], []) + subgraphAdjacency nodeAttr edgeAttr (ESubgraph _ (NewSubgraph _ stmts)) = adjacency' nodeAttr edgeAttr stmts + subgraphAdjacency nodeAttr edgeAttr (ESubgraph _ (SubgraphRef name)) = ([Node (show name) nodeAttr], []) + makePath edgeAttr [n1] = [] + makePath edgeAttr (n0:n1:ns) = [Edge v0 v1 (reverse edgeAttr) | (Node v0 _) <- n0, (Node v1 _) <- n1] ++ makePath edgeAttr (n1:ns) + +runBench !gStr = do + start <- getTime ProcessCPUTime + let Right ast = parseDot "" gStr + (Graph _ _ (Just (StringId name)) _ ) = ast + (vertices, edges) = adjacency ast + !numVerts = length vertices + !numEdges = length edges + end <- getTime ProcessCPUTime + let delta = (toNanoSecs $ diffTimeSpec end start) `div` 10^6 + return $ ( intercalate "," + [ "language-dot" + , name + , show numVerts + , show numEdges + , show delta + ] , + delta) + +main = do + results <- mapM runBench instances + let times = map snd results + let avg = sum times + writeFile "benchmark-language-dot.csv" $ intercalate "\n" $ "library, instance, vertices, edges, time (ms)" : map fst results + putStrLn $ "Total time: " ++ show avg ++ " milliseconds" + diff --git a/dist/build/Language/Dot/Parser.hs b/dist/build/Language/Dot/Parser.hs new file mode 100644 --- /dev/null +++ b/dist/build/Language/Dot/Parser.hs @@ -0,0 +1,1403 @@ +{-# OPTIONS_GHC -w #-} +{-# OPTIONS -XMagicHash -XBangPatterns -XTypeSynonymInstances -XFlexibleInstances -cpp #-} +#if __GLASGOW_HASKELL__ >= 710 +{-# OPTIONS_GHC -XPartialTypeSignatures #-} +#endif +-------------------------------------------------------------------- +-- | +-- Module : Language.Dot.Parser +-- License : GPL-3 +-- +-- Maintainer : Marcelo Garlet Millani +-- Stability : experimental +-- Portability : portable +-- +-- Parsing function and abstract syntax tree for the [DOT language] +-- (https://www.graphviz.org/doc/info/lang.html). +-- +-- The parser is implemented using `happy`, and so is fairly fast. +-------------------------------------------------------------------- + +module Language.Dot.Parser + (parse + , GraphType(..) + , Name(..) + , Statement(..) + , Subgraph(..) + , Port(..) + , Compass(..) + ) where + +import HappyDot.Parser +import Language.Dot.Graph + +import Data.Char +import Control.Monad.Trans.State + +import qualified Debug.Trace as D +import qualified Data.Array as Happy_Data_Array +import qualified Data.Bits as Bits +import qualified GHC.Exts as Happy_GHC_Exts +import Control.Applicative(Applicative(..)) +import Control.Monad (ap) + +-- parser produced by Happy Version 1.19.12 + +newtype HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27 = HappyAbsSyn HappyAny +#if __GLASGOW_HASKELL__ >= 607 +type HappyAny = Happy_GHC_Exts.Any +#else +type HappyAny = forall a . a +#endif +happyIn4 :: t4 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn4 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn4 #-} +happyOut4 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t4 +happyOut4 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut4 #-} +happyIn5 :: t5 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn5 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn5 #-} +happyOut5 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t5 +happyOut5 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut5 #-} +happyIn6 :: t6 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn6 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn6 #-} +happyOut6 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t6 +happyOut6 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut6 #-} +happyIn7 :: t7 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn7 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn7 #-} +happyOut7 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t7 +happyOut7 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut7 #-} +happyIn8 :: t8 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn8 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn8 #-} +happyOut8 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t8 +happyOut8 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut8 #-} +happyIn9 :: t9 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn9 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn9 #-} +happyOut9 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t9 +happyOut9 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut9 #-} +happyIn10 :: t10 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn10 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn10 #-} +happyOut10 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t10 +happyOut10 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut10 #-} +happyIn11 :: t11 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn11 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn11 #-} +happyOut11 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t11 +happyOut11 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut11 #-} +happyIn12 :: t12 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn12 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn12 #-} +happyOut12 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t12 +happyOut12 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut12 #-} +happyIn13 :: t13 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn13 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn13 #-} +happyOut13 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t13 +happyOut13 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut13 #-} +happyIn14 :: t14 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn14 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn14 #-} +happyOut14 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t14 +happyOut14 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut14 #-} +happyIn15 :: t15 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn15 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn15 #-} +happyOut15 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t15 +happyOut15 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut15 #-} +happyIn16 :: t16 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn16 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn16 #-} +happyOut16 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t16 +happyOut16 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut16 #-} +happyIn17 :: t17 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn17 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn17 #-} +happyOut17 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t17 +happyOut17 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut17 #-} +happyIn18 :: t18 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn18 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn18 #-} +happyOut18 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t18 +happyOut18 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut18 #-} +happyIn19 :: t19 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn19 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn19 #-} +happyOut19 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t19 +happyOut19 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut19 #-} +happyIn20 :: t20 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn20 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn20 #-} +happyOut20 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t20 +happyOut20 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut20 #-} +happyIn21 :: t21 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn21 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn21 #-} +happyOut21 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t21 +happyOut21 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut21 #-} +happyIn22 :: t22 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn22 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn22 #-} +happyOut22 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t22 +happyOut22 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut22 #-} +happyIn23 :: t23 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn23 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn23 #-} +happyOut23 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t23 +happyOut23 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut23 #-} +happyIn24 :: t24 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn24 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn24 #-} +happyOut24 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t24 +happyOut24 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut24 #-} +happyIn25 :: t25 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn25 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn25 #-} +happyOut25 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t25 +happyOut25 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut25 #-} +happyIn26 :: t26 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn26 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn26 #-} +happyOut26 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t26 +happyOut26 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut26 #-} +happyIn27 :: t27 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn27 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn27 #-} +happyOut27 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t27 +happyOut27 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut27 #-} +happyInTok :: (Token) -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyInTok x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyInTok #-} +happyOutTok :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> (Token) +happyOutTok x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOutTok #-} + + +happyExpList :: HappyAddr +happyExpList = HappyA# "\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x3e\x06\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x03\x00\x00\x00\x80\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\xe0\x08\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x00\x08\x00\x00\x00\xc0\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x01\x02\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x30\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00"# + +{-# NOINLINE happyExpListPerState #-} +happyExpListPerState st = + token_strs_expected + where token_strs = ["error","%dummy","%start_dot","Graph","Strictness","GraphType","Name_empty","Name","Quoted_string","Quoted_sum","Stmt_list","Stmt_list_aux","Stmt_sep","Stmt","Attr_stmt","Attr_list","Attr_list_aux","A_list","Edge_stmt","EdgeRHS","Node_stmt","Node","Port","Subgraph","Xml","XmlList","XmlElement","graph","digraph","node","edge","subgraph","label","qlabel","strict","arrow","'='","'{'","'}'","'['","']'","':'","';'","','","'+'","xmlClose","xmlOpen","xmlProc","%eof"] + bit_start = st * 49 + bit_end = (st + 1) * 49 + read_bit = readArrayBit happyExpList + bits = map read_bit [bit_start..bit_end - 1] + bits_indexed = zip bits [0..48] + token_strs_expected = concatMap f bits_indexed + f (False, _) = [] + f (True, nr) = [token_strs !! nr] + +happyActOffsets :: HappyAddr +happyActOffsets = HappyA# "\xf9\xff\xf9\xff\x23\x00\x00\x00\xed\xff\x0d\x00\x00\x00\x00\x00\x07\x00\x00\x00\x00\x00\x09\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4f\x00\x36\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x52\x00\x1c\x00\x00\x00\x38\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x0d\x00\x00\x00\x47\x00\x00\x00\x34\x00\x00\x00\x00\x00\x56\x00\x46\x00\x00\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0d\x00\x0d\x00\x00\x00\x65\x00\x00\x00\x00\x00\x49\x00\x67\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x50\x00\x00\x00\x00\x00\x55\x00\x00\x00\x0d\x00\x00\x00\x6b\x00\x0d\x00\x00\x00\x00\x00"# + +happyGotoOffsets :: HappyAddr +happyGotoOffsets = HappyA# "\x68\x00\x76\x00\x77\x00\x00\x00\x00\x00\x0b\x00\x00\x00\x00\x00\x71\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x63\x00\x00\x00\x00\x00\x73\x00\x18\x00\x00\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x6c\x00\x6e\x00\x00\x00\x74\x00\x00\x00\x00\x00\x00\x00\x4c\x00\x72\x00\x5e\x00\x60\x00\x62\x00\x13\x00\x00\x00\x75\x00\x00\x00\x00\x00\x00\x00\x00\x00\x64\x00\x2a\x00\x00\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x05\x00\x32\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2e\x00\x78\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x70\x00\x00\x00\x7b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x35\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00"# + +happyAdjustOffset :: Happy_GHC_Exts.Int# -> Happy_GHC_Exts.Int# +happyAdjustOffset off = off + +happyDefActions :: HappyAddr +happyDefActions = HappyA# "\xfc\xff\x00\x00\x00\x00\xfd\xff\x00\x00\xf8\xff\xfb\xff\xfa\xff\x00\x00\xf9\xff\xf6\xff\xf4\xff\xf5\xff\xf7\xff\xf3\xff\xcd\xff\x00\x00\x00\x00\xfe\xff\xef\xff\x00\x00\xf2\xff\xce\xff\xcf\xff\xcd\xff\xcb\xff\x00\x00\xd5\xff\xd0\xff\xec\xff\xeb\xff\xe9\xff\xea\xff\xe1\xff\xe7\xff\xe1\xff\xe1\xff\xe1\xff\xf8\xff\xf1\xff\x00\x00\xe5\xff\xe3\xff\xe6\xff\xe4\xff\xe1\xff\x00\x00\xd6\xff\xe1\xff\xf0\xff\xee\xff\xed\xff\xd4\xff\x00\x00\x00\x00\xcc\xff\xd3\xff\xe8\xff\xde\xff\x00\x00\xd5\xff\xda\xff\xd9\xff\xd8\xff\xd7\xff\xdd\xff\xdf\xff\xd1\xff\xec\xff\xdc\xff\xdb\xff\x00\x00\xd2\xff\x00\x00\xe2\xff\x00\x00\x00\x00\xe0\xff"# + +happyCheck :: HappyAddr +happyCheck = HappyA# "\xff\xff\x08\x00\x01\x00\x16\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x04\x00\x05\x00\x06\x00\x0b\x00\x0c\x00\x03\x00\x04\x00\x05\x00\x06\x00\x0b\x00\x06\x00\x07\x00\x14\x00\x03\x00\x04\x00\x05\x00\x06\x00\x15\x00\x12\x00\x04\x00\x05\x00\x06\x00\x07\x00\x15\x00\x14\x00\x0a\x00\x0b\x00\x01\x00\x02\x00\x0a\x00\x0f\x00\x15\x00\x11\x00\x12\x00\x0f\x00\x14\x00\x15\x00\x04\x00\x05\x00\x06\x00\x07\x00\x04\x00\x05\x00\x06\x00\x07\x00\x04\x00\x05\x00\x06\x00\x04\x00\x05\x00\x06\x00\x12\x00\x07\x00\x14\x00\x15\x00\x12\x00\x0d\x00\x14\x00\x15\x00\x04\x00\x05\x00\x06\x00\x15\x00\x10\x00\x11\x00\x15\x00\x05\x00\x06\x00\x07\x00\x05\x00\x06\x00\x07\x00\x0b\x00\x0b\x00\x09\x00\x0b\x00\x15\x00\x10\x00\x11\x00\x0c\x00\x0d\x00\x14\x00\x06\x00\x10\x00\x14\x00\x0e\x00\x09\x00\x10\x00\x11\x00\x13\x00\x14\x00\x15\x00\x13\x00\x14\x00\x15\x00\x00\x00\x01\x00\x0c\x00\x0d\x00\x0c\x00\x0d\x00\x0c\x00\x0d\x00\x0c\x00\x0d\x00\x0c\x00\x0d\x00\x0f\x00\x0a\x00\x0f\x00\x01\x00\x07\x00\x02\x00\x17\x00\x08\x00\x07\x00\x09\x00\x0e\x00\x16\x00\x16\x00\x13\x00\x10\x00\x17\x00\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x13\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"# + +happyTable :: HappyAddr +happyTable = HappyA# "\x00\x00\x04\x00\x24\x00\xff\xff\x25\x00\x26\x00\x27\x00\x0e\x00\x0f\x00\x39\x00\x0a\x00\x0b\x00\x14\x00\x28\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x14\x00\x0e\x00\x0f\x00\x10\x00\x28\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x12\x00\x1b\x00\x0a\x00\x0b\x00\x1c\x00\x0c\x00\x10\x00\x1d\x00\x1e\x00\x07\x00\x08\x00\x36\x00\x1f\x00\x0c\x00\x20\x00\x21\x00\x37\x00\x22\x00\x0c\x00\x3c\x00\x0a\x00\x0b\x00\x1c\x00\x3c\x00\x0a\x00\x0b\x00\x1c\x00\x38\x00\x0a\x00\x0b\x00\x4b\x00\x0a\x00\x0b\x00\x3d\x00\x16\x00\x3e\x00\x0c\x00\x45\x00\x43\x00\x46\x00\x0c\x00\x4d\x00\x0a\x00\x0b\x00\x0c\x00\x33\x00\x34\x00\x0c\x00\x27\x00\x0e\x00\x0f\x00\x27\x00\x0e\x00\x0f\x00\x14\x00\x14\x00\x2f\x00\x14\x00\x0c\x00\x40\x00\x41\x00\x2f\x00\x2a\x00\x10\x00\x49\x00\x30\x00\x10\x00\x4b\x00\x3c\x00\x33\x00\x34\x00\x18\x00\x19\x00\x1a\x00\x38\x00\x19\x00\x1a\x00\x04\x00\x02\x00\x2c\x00\x2a\x00\x2b\x00\x2a\x00\x29\x00\x2a\x00\x41\x00\x2a\x00\x3a\x00\x2a\x00\x48\x00\x4d\x00\x37\x00\x02\x00\x12\x00\x05\x00\x16\x00\x14\x00\x43\x00\x31\x00\x44\x00\x10\x00\x1a\x00\x34\x00\x2d\x00\x16\x00\x49\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x34\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"# + +happyReduceArr = Happy_Data_Array.array (1, 52) [ + (1 , happyReduce_1), + (2 , happyReduce_2), + (3 , happyReduce_3), + (4 , happyReduce_4), + (5 , happyReduce_5), + (6 , happyReduce_6), + (7 , happyReduce_7), + (8 , happyReduce_8), + (9 , happyReduce_9), + (10 , happyReduce_10), + (11 , happyReduce_11), + (12 , happyReduce_12), + (13 , happyReduce_13), + (14 , happyReduce_14), + (15 , happyReduce_15), + (16 , happyReduce_16), + (17 , happyReduce_17), + (18 , happyReduce_18), + (19 , happyReduce_19), + (20 , happyReduce_20), + (21 , happyReduce_21), + (22 , happyReduce_22), + (23 , happyReduce_23), + (24 , happyReduce_24), + (25 , happyReduce_25), + (26 , happyReduce_26), + (27 , happyReduce_27), + (28 , happyReduce_28), + (29 , happyReduce_29), + (30 , happyReduce_30), + (31 , happyReduce_31), + (32 , happyReduce_32), + (33 , happyReduce_33), + (34 , happyReduce_34), + (35 , happyReduce_35), + (36 , happyReduce_36), + (37 , happyReduce_37), + (38 , happyReduce_38), + (39 , happyReduce_39), + (40 , happyReduce_40), + (41 , happyReduce_41), + (42 , happyReduce_42), + (43 , happyReduce_43), + (44 , happyReduce_44), + (45 , happyReduce_45), + (46 , happyReduce_46), + (47 , happyReduce_47), + (48 , happyReduce_48), + (49 , happyReduce_49), + (50 , happyReduce_50), + (51 , happyReduce_51), + (52 , happyReduce_52) + ] + +happy_n_terms = 23 :: Int +happy_n_nonterms = 24 :: Int + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_1 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_1 = happyReduce 4# 0# happyReduction_1 +happyReduction_1 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut5 happy_x_1 of { happy_var_1 -> + case happyOut6 happy_x_2 of { happy_var_2 -> + case happyOut7 happy_x_3 of { happy_var_3 -> + case happyOut11 happy_x_4 of { happy_var_4 -> + happyIn4 + ((happy_var_1, happy_var_2, happy_var_3, happy_var_4) + ) `HappyStk` happyRest}}}} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_2 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_2 = happySpecReduce_1 1# happyReduction_2 +happyReduction_2 happy_x_1 + = happyIn5 + (True + ) + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_3 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_3 = happySpecReduce_0 1# happyReduction_3 +happyReduction_3 = happyIn5 + (False + ) + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_4 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_4 = happySpecReduce_1 2# happyReduction_4 +happyReduction_4 happy_x_1 + = happyIn6 + (Graph + ) + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_5 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_5 = happySpecReduce_1 2# happyReduction_5 +happyReduction_5 happy_x_1 + = happyIn6 + (Digraph + ) + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_6 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_6 = happySpecReduce_1 3# happyReduction_6 +happyReduction_6 happy_x_1 + = case happyOut8 happy_x_1 of { happy_var_1 -> + happyIn7 + (Just happy_var_1 + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_7 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_7 = happySpecReduce_0 3# happyReduction_7 +happyReduction_7 = happyIn7 + (Nothing + ) + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_8 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_8 = happySpecReduce_1 4# happyReduction_8 +happyReduction_8 happy_x_1 + = case happyOutTok happy_x_1 of { (TokenLabel happy_var_1) -> + happyIn8 + (StringID happy_var_1 + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_9 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_9 = happySpecReduce_1 4# happyReduction_9 +happyReduction_9 happy_x_1 + = case happyOut9 happy_x_1 of { happy_var_1 -> + happyIn8 + (StringID happy_var_1 + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_10 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_10 = happySpecReduce_1 4# happyReduction_10 +happyReduction_10 happy_x_1 + = case happyOut25 happy_x_1 of { happy_var_1 -> + happyIn8 + (XMLID happy_var_1 + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_11 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_11 = happySpecReduce_1 5# happyReduction_11 +happyReduction_11 happy_x_1 + = case happyOut10 happy_x_1 of { happy_var_1 -> + happyIn9 + (concat $ reverse happy_var_1 + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_12 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_12 = happySpecReduce_1 6# happyReduction_12 +happyReduction_12 happy_x_1 + = case happyOutTok happy_x_1 of { (TokenQuotedLabel happy_var_1) -> + happyIn10 + ([happy_var_1] + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_13 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_13 = happySpecReduce_3 6# happyReduction_13 +happyReduction_13 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut10 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_3 of { (TokenQuotedLabel happy_var_3) -> + happyIn10 + (happy_var_3 : happy_var_1 + )}} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_14 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_14 = happySpecReduce_3 7# happyReduction_14 +happyReduction_14 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut12 happy_x_2 of { happy_var_2 -> + happyIn11 + (reverse happy_var_2 + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_15 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_15 = happySpecReduce_3 8# happyReduction_15 +happyReduction_15 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut12 happy_x_1 of { happy_var_1 -> + case happyOut14 happy_x_2 of { happy_var_2 -> + happyIn12 + (happy_var_2 : happy_var_1 + )}} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_16 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_16 = happySpecReduce_0 8# happyReduction_16 +happyReduction_16 = happyIn12 + ([] + ) + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_17 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_17 = happySpecReduce_1 9# happyReduction_17 +happyReduction_17 happy_x_1 + = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn13 + (Just happy_var_1 + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_18 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_18 = happySpecReduce_1 9# happyReduction_18 +happyReduction_18 happy_x_1 + = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn13 + (Just happy_var_1 + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_19 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_19 = happySpecReduce_0 9# happyReduction_19 +happyReduction_19 = happyIn13 + (Nothing + ) + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_20 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_20 = happySpecReduce_1 10# happyReduction_20 +happyReduction_20 happy_x_1 + = case happyOut15 happy_x_1 of { happy_var_1 -> + happyIn14 + (happy_var_1 + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_21 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_21 = happySpecReduce_1 10# happyReduction_21 +happyReduction_21 happy_x_1 + = case happyOut21 happy_x_1 of { happy_var_1 -> + happyIn14 + (happy_var_1 + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_22 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_22 = happySpecReduce_1 10# happyReduction_22 +happyReduction_22 happy_x_1 + = case happyOut19 happy_x_1 of { happy_var_1 -> + happyIn14 + (happy_var_1 + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_23 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_23 = happySpecReduce_3 10# happyReduction_23 +happyReduction_23 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut8 happy_x_1 of { happy_var_1 -> + case happyOut8 happy_x_3 of { happy_var_3 -> + happyIn14 + (AttributeStatement ( happy_var_1, happy_var_3) + )}} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_24 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_24 = happySpecReduce_1 10# happyReduction_24 +happyReduction_24 happy_x_1 + = case happyOut24 happy_x_1 of { happy_var_1 -> + happyIn14 + (SubgraphStatement happy_var_1 + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_25 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_25 = happySpecReduce_2 11# happyReduction_25 +happyReduction_25 happy_x_2 + happy_x_1 + = case happyOut16 happy_x_2 of { happy_var_2 -> + happyIn15 + (NodeAttribute happy_var_2 + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_26 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_26 = happySpecReduce_2 11# happyReduction_26 +happyReduction_26 happy_x_2 + happy_x_1 + = case happyOut16 happy_x_2 of { happy_var_2 -> + happyIn15 + (EdgeAttribute happy_var_2 + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_27 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_27 = happySpecReduce_2 11# happyReduction_27 +happyReduction_27 happy_x_2 + happy_x_1 + = case happyOut16 happy_x_2 of { happy_var_2 -> + happyIn15 + (GraphAttribute happy_var_2 + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_28 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_28 = happySpecReduce_1 12# happyReduction_28 +happyReduction_28 happy_x_1 + = case happyOut17 happy_x_1 of { happy_var_1 -> + happyIn16 + (reverse happy_var_1 + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_29 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_29 = happyReduce 4# 13# happyReduction_29 +happyReduction_29 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut17 happy_x_1 of { happy_var_1 -> + case happyOut18 happy_x_3 of { happy_var_3 -> + happyIn17 + (happy_var_3 ++ happy_var_1 + ) `HappyStk` happyRest}} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_30 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_30 = happySpecReduce_0 13# happyReduction_30 +happyReduction_30 = happyIn17 + ([] + ) + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_31 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_31 = happyReduce 5# 14# happyReduction_31 +happyReduction_31 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut18 happy_x_1 of { happy_var_1 -> + case happyOut8 happy_x_3 of { happy_var_3 -> + case happyOut8 happy_x_5 of { happy_var_5 -> + happyIn18 + (( happy_var_3, happy_var_5) : happy_var_1 + ) `HappyStk` happyRest}}} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_32 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_32 = happySpecReduce_0 14# happyReduction_32 +happyReduction_32 = happyIn18 + ([] + ) + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_33 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_33 = happySpecReduce_3 15# happyReduction_33 +happyReduction_33 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut22 happy_x_1 of { happy_var_1 -> + case happyOut20 happy_x_2 of { happy_var_2 -> + case happyOut16 happy_x_3 of { happy_var_3 -> + happyIn19 + (EdgeStatement ((uncurry NodeRef happy_var_1):(reverse happy_var_2)) happy_var_3 + )}}} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_34 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_34 = happySpecReduce_3 15# happyReduction_34 +happyReduction_34 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut24 happy_x_1 of { happy_var_1 -> + case happyOut20 happy_x_2 of { happy_var_2 -> + case happyOut16 happy_x_3 of { happy_var_3 -> + happyIn19 + (EdgeStatement (happy_var_1:(reverse happy_var_2)) happy_var_3 + )}}} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_35 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_35 = happySpecReduce_3 16# happyReduction_35 +happyReduction_35 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut20 happy_x_1 of { happy_var_1 -> + case happyOut22 happy_x_3 of { happy_var_3 -> + happyIn20 + ((uncurry NodeRef happy_var_3) : happy_var_1 + )}} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_36 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_36 = happySpecReduce_3 16# happyReduction_36 +happyReduction_36 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut20 happy_x_1 of { happy_var_1 -> + case happyOut24 happy_x_3 of { happy_var_3 -> + happyIn20 + (happy_var_3 : happy_var_1 + )}} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_37 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_37 = happySpecReduce_2 16# happyReduction_37 +happyReduction_37 happy_x_2 + happy_x_1 + = case happyOut22 happy_x_2 of { happy_var_2 -> + happyIn20 + ([uncurry NodeRef happy_var_2] + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_38 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_38 = happySpecReduce_2 16# happyReduction_38 +happyReduction_38 happy_x_2 + happy_x_1 + = case happyOut24 happy_x_2 of { happy_var_2 -> + happyIn20 + ([happy_var_2] + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_39 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_39 = happyMonadReduce 2# 16# happyReduction_39 +happyReduction_39 (happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen ((( getLineNumber `thenE` \line -> failE $ "Unfinished edge statement.")) + ) (\r -> happyReturn (happyIn20 r)) + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_40 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_40 = happyMonadReduce 2# 16# happyReduction_40 +happyReduction_40 (happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen ((( getLineNumber `thenE` \line -> failE $ "Unfinished edge statement.")) + ) (\r -> happyReturn (happyIn20 r)) + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_41 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_41 = happySpecReduce_2 17# happyReduction_41 +happyReduction_41 happy_x_2 + happy_x_1 + = case happyOut22 happy_x_1 of { happy_var_1 -> + case happyOut16 happy_x_2 of { happy_var_2 -> + happyIn21 + ((uncurry NodeStatement) happy_var_1 happy_var_2 + )}} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_42 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_42 = happySpecReduce_1 18# happyReduction_42 +happyReduction_42 happy_x_1 + = case happyOut8 happy_x_1 of { happy_var_1 -> + happyIn22 + ((happy_var_1, Nothing) + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_43 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_43 = happySpecReduce_2 18# happyReduction_43 +happyReduction_43 happy_x_2 + happy_x_1 + = case happyOut8 happy_x_1 of { happy_var_1 -> + case happyOut23 happy_x_2 of { happy_var_2 -> + happyIn22 + ((happy_var_1, (Just happy_var_2)) + )}} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_44 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_44 = happySpecReduce_2 19# happyReduction_44 +happyReduction_44 happy_x_2 + happy_x_1 + = case happyOut8 happy_x_2 of { happy_var_2 -> + happyIn23 + (case toCompass $ show happy_var_2 of + Just c -> Port Nothing (Just c) + Nothing -> Port (if show happy_var_2 == "_" then Nothing else (Just happy_var_2)) Nothing + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_45 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_45 = happyReduce 4# 19# happyReduction_45 +happyReduction_45 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut8 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_4 of { (TokenLabel happy_var_4) -> + happyIn23 + (Port (Just happy_var_2) (toCompass happy_var_4) + ) `HappyStk` happyRest}} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_46 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_46 = happySpecReduce_3 20# happyReduction_46 +happyReduction_46 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut7 happy_x_2 of { happy_var_2 -> + case happyOut11 happy_x_3 of { happy_var_3 -> + happyIn24 + (Subgraph happy_var_2 happy_var_3 + )}} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_47 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_47 = happySpecReduce_1 20# happyReduction_47 +happyReduction_47 happy_x_1 + = case happyOut11 happy_x_1 of { happy_var_1 -> + happyIn24 + (Subgraph Nothing happy_var_1 + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_48 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_48 = happySpecReduce_3 21# happyReduction_48 +happyReduction_48 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { (TokenOT happy_var_1) -> + case happyOut26 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { (TokenCT happy_var_3) -> + happyIn25 + (show happy_var_1 ++ (concat $ reverse happy_var_2) ++ show happy_var_3 + )}}} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_49 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_49 = happySpecReduce_2 22# happyReduction_49 +happyReduction_49 happy_x_2 + happy_x_1 + = case happyOut26 happy_x_1 of { happy_var_1 -> + case happyOut27 happy_x_2 of { happy_var_2 -> + happyIn26 + (happy_var_2 : happy_var_1 + )}} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_50 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_50 = happySpecReduce_0 22# happyReduction_50 +happyReduction_50 = happyIn26 + ([] + ) + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_51 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_51 = happySpecReduce_3 23# happyReduction_51 +happyReduction_51 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { (TokenOT happy_var_1) -> + case happyOut26 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { (TokenCT happy_var_3) -> + happyIn27 + (show happy_var_1 ++ (concat $ reverse happy_var_2) ++ show happy_var_3 + )}}} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_52 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_52 = happySpecReduce_1 23# happyReduction_52 +happyReduction_52 happy_x_1 + = case happyOutTok happy_x_1 of { (TokenProc happy_var_1) -> + happyIn27 + (show happy_var_1 + )} + +happyNewToken action sts stk + = lexer(\tk -> + let cont i = happyDoAction i tk action sts stk in + case tk of { + TokenEOF -> happyDoAction 22# tk action sts stk; + TokenGraph -> cont 1#; + TokenDigraph -> cont 2#; + TokenNode -> cont 3#; + TokenEdge -> cont 4#; + TokenSubgraph -> cont 5#; + TokenLabel happy_dollar_dollar -> cont 6#; + TokenQuotedLabel happy_dollar_dollar -> cont 7#; + TokenStrict -> cont 8#; + TokenArrow happy_dollar_dollar -> cont 9#; + TokenEQ -> cont 10#; + TokenOCB -> cont 11#; + TokenCCB -> cont 12#; + TokenOSB -> cont 13#; + TokenCSB -> cont 14#; + TokenCo -> cont 15#; + TokenSemiCo -> cont 16#; + TokenComma -> cont 17#; + TokenPlus -> cont 18#; + TokenCT happy_dollar_dollar -> cont 19#; + TokenOT happy_dollar_dollar -> cont 20#; + TokenProc happy_dollar_dollar -> cont 21#; + _ -> happyError' (tk, []) + }) + +happyError_ explist 22# tk = happyError' (tk, explist) +happyError_ explist _ tk = happyError' (tk, explist) + +happyThen :: () => P a -> (a -> P b) -> P b +happyThen = (thenE) +happyReturn :: () => a -> P a +happyReturn = (returnE) +#if __GLASGOW_HASKELL__ >= 710 +happyParse :: () => Happy_GHC_Exts.Int# -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) + +happyNewToken :: () => Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) + +happyDoAction :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) + +happyReduceArr :: () => Happy_Data_Array.Array Int (Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _)) + +#endif +happyThen1 :: () => P a -> (a -> P b) -> P b +happyThen1 = happyThen +happyReturn1 :: () => a -> P a +happyReturn1 = happyReturn +happyError' :: () => ((Token), [String]) -> P a +happyError' tk = (\(tokens, _) -> parseError tokens) tk +dot = happySomeParser where + happySomeParser = happyThen (happyParse 0#) (\x -> happyReturn (let {x' = happyOut4 x} in x')) + +happySeq = happyDontSeq + + +data Except a = Success a | Failure String +type P a = String -> Int -> Except a + +thenE :: P a -> (a -> P b) -> P b +thenE m k s l = + case m s l of + Success a -> k a s l + Failure e -> Failure e + +returnE :: a -> P a +returnE a s l = Success a + +failE :: String -> P a +failE e s l = Failure $ "Error on line " ++ show l ++ ": " ++ e + +catchE :: P a -> (String -> P a) -> P a +catchE m k s l = case m s l of + Success a -> Success a + Failure e -> k e s l +getLineNumber s l = Success l +parseError :: Token -> P a +parseError t = getLineNumber `thenE` \line -> failE $ "Parse error on line " ++ show line ++ "." + +data Token = + TokenGraph + | TokenDigraph + | TokenNode + | TokenEdge + | TokenSubgraph + | TokenStrict + | TokenLabel String + | TokenQuotedLabel String + | TokenXML String + | TokenCompass Compass + | TokenArrow Char + | TokenEQ + | TokenOCB + | TokenCCB + | TokenOSB + | TokenCSB + | TokenCo + | TokenSemiCo + | TokenComma + | TokenCT String + | TokenOT String + | TokenProc String + | TokenPlus + | TokenEOF + deriving (Eq) + +instance Show Token where + show tk = case tk of + TokenGraph -> "graph" + TokenDigraph -> "digraph" + TokenNode -> "node" + TokenEdge -> "edge" + TokenSubgraph -> "subgraph" + TokenStrict -> "strict" + TokenLabel label -> label + TokenQuotedLabel label -> label + TokenXML xml -> xml + TokenCompass compass -> show compass + TokenArrow c -> [c] + TokenEQ -> "=" + TokenOCB -> "{" + TokenCCB -> "]" + TokenOSB -> "[" + TokenCSB -> "]" + TokenCo -> ":" + TokenSemiCo -> ";" + TokenComma -> "," + TokenCT tag -> "" + TokenOT tag -> "<" ++ tag ++ ">" + TokenProc xml -> "" + TokenPlus -> "+" + TokenEOF -> "" + +-- | Parse a graph written in the DOT language. +parse s = case dot ('\n':s) 0 of -- A newline is added to treat '#' in the beginning of a line properly. + Success ast -> Right ast + Failure msg -> Left msg + +toCompass l = + case map toLower l of + "n" -> Just $ North + "ne" -> Just $ NorthEast + "e" -> Just $ East + "se" -> Just $ SouthEast + "s" -> Just $ South + "sw" -> Just $ SouthWest + "w" -> Just $ West + "nw" -> Just $ NorthWest + "c" -> Just $ Center + "_" -> Nothing + _ -> Nothing + +lexer :: (Token -> (P a)) -> (P a) +lexer cont str line = case dropWhile (\c -> c /= '\n' && isSpace c) str of + '\n':'#':s' -> let s'' = dropWhile (/= '\n') s' in lexer cont s'' (line + 1) + '\n':s' -> lexer cont s' (line +1) + ',':s' -> cont TokenComma s' line + ';':s' -> cont TokenSemiCo s' line + 's':'u':'b':'g':'r':'a':'p':'h':s' -> cont TokenSubgraph s' line + 'g':'r':'a':'p':'h':s' -> cont TokenGraph s' line + 'd':'i':'g':'r':'a':'p':'h':s' -> cont TokenDigraph s' line + 'e':'d':'g':'e':s' -> cont TokenEdge s' line + 'n':'o':'d':'e':s' -> cont TokenNode s' line + 's':'t':'r':'i':'c':'t':s' -> cont TokenStrict s' line + '{':s' -> cont TokenOCB s' line + '}':s' -> cont TokenCCB s' line + '[':s' -> cont TokenOSB s' line + ']':s' -> cont TokenCSB s' line + '+':s' -> cont TokenPlus s' line + '=':s' -> cont TokenEQ s' line + ':':s' -> cont TokenCo s' line + '-':'-':s' -> cont (TokenArrow '-') s' line + '-':'>':s' -> cont (TokenArrow '>') s' line + '/':'/':s' -> let s'' = dropWhile (/= '\n') s' in lexer cont s'' line + '/':'*':s' -> let (s'', line') = execState consumeComment (s', line) + in lexer cont s'' (line') + '"':s' -> let (qs, (s'', line')) = runState consumeQuotedString (s', line) + in case qs of + Right string -> cont (TokenQuotedLabel string) s'' line' + Left msg -> failE msg s' line' + '<':'/':s' -> let (tag, (s'', line')) = runState consumeTag (s', line) + in cont (TokenCT tag) (tail s'') line' + '<':'!':'-':'-':s' -> let (s'', line') = execState consumeXMLComment (s', line) + in lexer cont s'' line' + '<':'?':s' -> let (proc, (s'', line')) = runState consumeProcessing (s', line) + in cont (TokenProc proc) s'' line' + [] -> cont TokenEOF [] line + s' -> let (label, s'') = span (\x -> not $ isSpace x || x `elem` ";,{}[]=\"") s' + in if null label then failE ("Unexpected character: " ++ [head s'']) s' line + else cont (TokenLabel label) s'' line +{-# LINE 1 "templates/GenericTemplate.hs" #-} +-- $Id: GenericTemplate.hs,v 1.26 2005/01/14 14:47:22 simonmar Exp $ + + + + + + + + + + + + + +-- Do not remove this comment. Required to fix CPP parsing when using GCC and a clang-compiled alex. +#if __GLASGOW_HASKELL__ > 706 +#define LT(n,m) ((Happy_GHC_Exts.tagToEnum# (n Happy_GHC_Exts.<# m)) :: Bool) +#define GTE(n,m) ((Happy_GHC_Exts.tagToEnum# (n Happy_GHC_Exts.>=# m)) :: Bool) +#define EQ(n,m) ((Happy_GHC_Exts.tagToEnum# (n Happy_GHC_Exts.==# m)) :: Bool) +#else +#define LT(n,m) (n Happy_GHC_Exts.<# m) +#define GTE(n,m) (n Happy_GHC_Exts.>=# m) +#define EQ(n,m) (n Happy_GHC_Exts.==# m) +#endif + + + + + + + + + + + + + + + + + + + +data Happy_IntList = HappyCons Happy_GHC_Exts.Int# Happy_IntList + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +infixr 9 `HappyStk` +data HappyStk a = HappyStk a (HappyStk a) + +----------------------------------------------------------------------------- +-- starting the parse + +happyParse start_state = happyNewToken start_state notHappyAtAll notHappyAtAll + +----------------------------------------------------------------------------- +-- Accepting the parse + +-- If the current token is ERROR_TOK, it means we've just accepted a partial +-- parse (a %partial parser). We must ignore the saved token on the top of +-- the stack in this case. +happyAccept 0# tk st sts (_ `HappyStk` ans `HappyStk` _) = + happyReturn1 ans +happyAccept j tk st sts (HappyStk ans _) = + (happyTcHack j (happyTcHack st)) (happyReturn1 ans) + +----------------------------------------------------------------------------- +-- Arrays only: do the next action + + + +happyDoAction i tk st + = {- nothing -} + case action of + 0# -> {- nothing -} + happyFail (happyExpListPerState ((Happy_GHC_Exts.I# (st)) :: Int)) i tk st + -1# -> {- nothing -} + happyAccept i tk st + n | LT(n,(0# :: Happy_GHC_Exts.Int#)) -> {- nothing -} + (happyReduceArr Happy_Data_Array.! rule) i tk st + where rule = (Happy_GHC_Exts.I# ((Happy_GHC_Exts.negateInt# ((n Happy_GHC_Exts.+# (1# :: Happy_GHC_Exts.Int#)))))) + n -> {- nothing -} + happyShift new_state i tk st + where new_state = (n Happy_GHC_Exts.-# (1# :: Happy_GHC_Exts.Int#)) + where off = happyAdjustOffset (indexShortOffAddr happyActOffsets st) + off_i = (off Happy_GHC_Exts.+# i) + check = if GTE(off_i,(0# :: Happy_GHC_Exts.Int#)) + then EQ(indexShortOffAddr happyCheck off_i, i) + else False + action + | check = indexShortOffAddr happyTable off_i + | otherwise = indexShortOffAddr happyDefActions st + + + + +indexShortOffAddr (HappyA# arr) off = + Happy_GHC_Exts.narrow16Int# i + where + i = Happy_GHC_Exts.word2Int# (Happy_GHC_Exts.or# (Happy_GHC_Exts.uncheckedShiftL# high 8#) low) + high = Happy_GHC_Exts.int2Word# (Happy_GHC_Exts.ord# (Happy_GHC_Exts.indexCharOffAddr# arr (off' Happy_GHC_Exts.+# 1#))) + low = Happy_GHC_Exts.int2Word# (Happy_GHC_Exts.ord# (Happy_GHC_Exts.indexCharOffAddr# arr off')) + off' = off Happy_GHC_Exts.*# 2# + + + + +{-# INLINE happyLt #-} +happyLt x y = LT(x,y) + + +readArrayBit arr bit = + Bits.testBit (Happy_GHC_Exts.I# (indexShortOffAddr arr ((unbox_int bit) `Happy_GHC_Exts.iShiftRA#` 4#))) (bit `mod` 16) + where unbox_int (Happy_GHC_Exts.I# x) = x + + + + + + +data HappyAddr = HappyA# Happy_GHC_Exts.Addr# + + +----------------------------------------------------------------------------- +-- HappyState data type (not arrays) + + + + + + + + + + + + + +----------------------------------------------------------------------------- +-- Shifting a token + +happyShift new_state 0# tk st sts stk@(x `HappyStk` _) = + let i = (case Happy_GHC_Exts.unsafeCoerce# x of { (Happy_GHC_Exts.I# (i)) -> i }) in +-- trace "shifting the error token" $ + happyDoAction i tk new_state (HappyCons (st) (sts)) (stk) + +happyShift new_state i tk st sts stk = + happyNewToken new_state (HappyCons (st) (sts)) ((happyInTok (tk))`HappyStk`stk) + +-- happyReduce is specialised for the common cases. + +happySpecReduce_0 i fn 0# tk st sts stk + = happyFail [] 0# tk st sts stk +happySpecReduce_0 nt fn j tk st@((action)) sts stk + = happyGoto nt j tk st (HappyCons (st) (sts)) (fn `HappyStk` stk) + +happySpecReduce_1 i fn 0# tk st sts stk + = happyFail [] 0# tk st sts stk +happySpecReduce_1 nt fn j tk _ sts@((HappyCons (st@(action)) (_))) (v1`HappyStk`stk') + = let r = fn v1 in + happySeq r (happyGoto nt j tk st sts (r `HappyStk` stk')) + +happySpecReduce_2 i fn 0# tk st sts stk + = happyFail [] 0# tk st sts stk +happySpecReduce_2 nt fn j tk _ (HappyCons (_) (sts@((HappyCons (st@(action)) (_))))) (v1`HappyStk`v2`HappyStk`stk') + = let r = fn v1 v2 in + happySeq r (happyGoto nt j tk st sts (r `HappyStk` stk')) + +happySpecReduce_3 i fn 0# tk st sts stk + = happyFail [] 0# tk st sts stk +happySpecReduce_3 nt fn j tk _ (HappyCons (_) ((HappyCons (_) (sts@((HappyCons (st@(action)) (_))))))) (v1`HappyStk`v2`HappyStk`v3`HappyStk`stk') + = let r = fn v1 v2 v3 in + happySeq r (happyGoto nt j tk st sts (r `HappyStk` stk')) + +happyReduce k i fn 0# tk st sts stk + = happyFail [] 0# tk st sts stk +happyReduce k nt fn j tk st sts stk + = case happyDrop (k Happy_GHC_Exts.-# (1# :: Happy_GHC_Exts.Int#)) sts of + sts1@((HappyCons (st1@(action)) (_))) -> + let r = fn stk in -- it doesn't hurt to always seq here... + happyDoSeq r (happyGoto nt j tk st1 sts1 r) + +happyMonadReduce k nt fn 0# tk st sts stk + = happyFail [] 0# tk st sts stk +happyMonadReduce k nt fn j tk st sts stk = + case happyDrop k (HappyCons (st) (sts)) of + sts1@((HappyCons (st1@(action)) (_))) -> + let drop_stk = happyDropStk k stk in + happyThen1 (fn stk tk) (\r -> happyGoto nt j tk st1 sts1 (r `HappyStk` drop_stk)) + +happyMonad2Reduce k nt fn 0# tk st sts stk + = happyFail [] 0# tk st sts stk +happyMonad2Reduce k nt fn j tk st sts stk = + case happyDrop k (HappyCons (st) (sts)) of + sts1@((HappyCons (st1@(action)) (_))) -> + let drop_stk = happyDropStk k stk + + off = happyAdjustOffset (indexShortOffAddr happyGotoOffsets st1) + off_i = (off Happy_GHC_Exts.+# nt) + new_state = indexShortOffAddr happyTable off_i + + + + + in + happyThen1 (fn stk tk) (\r -> happyNewToken new_state sts1 (r `HappyStk` drop_stk)) + +happyDrop 0# l = l +happyDrop n (HappyCons (_) (t)) = happyDrop (n Happy_GHC_Exts.-# (1# :: Happy_GHC_Exts.Int#)) t + +happyDropStk 0# l = l +happyDropStk n (x `HappyStk` xs) = happyDropStk (n Happy_GHC_Exts.-# (1#::Happy_GHC_Exts.Int#)) xs + +----------------------------------------------------------------------------- +-- Moving to a new state after a reduction + + +happyGoto nt j tk st = + {- nothing -} + happyDoAction j tk new_state + where off = happyAdjustOffset (indexShortOffAddr happyGotoOffsets st) + off_i = (off Happy_GHC_Exts.+# nt) + new_state = indexShortOffAddr happyTable off_i + + + + +----------------------------------------------------------------------------- +-- Error recovery (ERROR_TOK is the error token) + +-- parse error if we are in recovery and we fail again +happyFail explist 0# tk old_st _ stk@(x `HappyStk` _) = + let i = (case Happy_GHC_Exts.unsafeCoerce# x of { (Happy_GHC_Exts.I# (i)) -> i }) in +-- trace "failing" $ + happyError_ explist i tk + +{- We don't need state discarding for our restricted implementation of + "error". In fact, it can cause some bogus parses, so I've disabled it + for now --SDM + +-- discard a state +happyFail ERROR_TOK tk old_st CONS(HAPPYSTATE(action),sts) + (saved_tok `HappyStk` _ `HappyStk` stk) = +-- trace ("discarding state, depth " ++ show (length stk)) $ + DO_ACTION(action,ERROR_TOK,tk,sts,(saved_tok`HappyStk`stk)) +-} + +-- Enter error recovery: generate an error token, +-- save the old token and carry on. +happyFail explist i tk (action) sts stk = +-- trace "entering error recovery" $ + happyDoAction 0# tk action sts ((Happy_GHC_Exts.unsafeCoerce# (Happy_GHC_Exts.I# (i))) `HappyStk` stk) + +-- Internal happy errors: + +notHappyAtAll :: a +notHappyAtAll = error "Internal Happy error\n" + +----------------------------------------------------------------------------- +-- Hack to get the typechecker to accept our action functions + + +happyTcHack :: Happy_GHC_Exts.Int# -> a -> a +happyTcHack x y = y +{-# INLINE happyTcHack #-} + + +----------------------------------------------------------------------------- +-- Seq-ing. If the --strict flag is given, then Happy emits +-- happySeq = happyDoSeq +-- otherwise it emits +-- happySeq = happyDontSeq + +happyDoSeq, happyDontSeq :: a -> b -> b +happyDoSeq a b = a `seq` b +happyDontSeq a b = b + +----------------------------------------------------------------------------- +-- Don't inline any functions from the template. GHC has a nasty habit +-- of deciding to inline happyGoto everywhere, which increases the size of +-- the generated parser quite a bit. + + +{-# NOINLINE happyDoAction #-} +{-# NOINLINE happyTable #-} +{-# NOINLINE happyCheck #-} +{-# NOINLINE happyActOffsets #-} +{-# NOINLINE happyGotoOffsets #-} +{-# NOINLINE happyDefActions #-} + +{-# NOINLINE happyShift #-} +{-# NOINLINE happySpecReduce_0 #-} +{-# NOINLINE happySpecReduce_1 #-} +{-# NOINLINE happySpecReduce_2 #-} +{-# NOINLINE happySpecReduce_3 #-} +{-# NOINLINE happyReduce #-} +{-# NOINLINE happyMonadReduce #-} +{-# NOINLINE happyGoto #-} +{-# NOINLINE happyFail #-} + +-- end of Happy Template. diff --git a/dist/build/bench-happy-dot/bench-happy-dot-tmp/Language/Dot/Parser.hs b/dist/build/bench-happy-dot/bench-happy-dot-tmp/Language/Dot/Parser.hs new file mode 100644 --- /dev/null +++ b/dist/build/bench-happy-dot/bench-happy-dot-tmp/Language/Dot/Parser.hs @@ -0,0 +1,1403 @@ +{-# OPTIONS_GHC -w #-} +{-# OPTIONS -XMagicHash -XBangPatterns -XTypeSynonymInstances -XFlexibleInstances -cpp #-} +#if __GLASGOW_HASKELL__ >= 710 +{-# OPTIONS_GHC -XPartialTypeSignatures #-} +#endif +-------------------------------------------------------------------- +-- | +-- Module : Language.Dot.Parser +-- License : GPL-3 +-- +-- Maintainer : Marcelo Garlet Millani +-- Stability : experimental +-- Portability : portable +-- +-- Parsing function and abstract syntax tree for the [DOT language] +-- (https://www.graphviz.org/doc/info/lang.html). +-- +-- The parser is implemented using `happy`, and so is fairly fast. +-------------------------------------------------------------------- + +module Language.Dot.Parser + (parse + , GraphType(..) + , Name(..) + , Statement(..) + , Subgraph(..) + , Port(..) + , Compass(..) + ) where + +import HappyDot.Parser +import Language.Dot.Graph + +import Data.Char +import Control.Monad.Trans.State + +import qualified Debug.Trace as D +import qualified Data.Array as Happy_Data_Array +import qualified Data.Bits as Bits +import qualified GHC.Exts as Happy_GHC_Exts +import Control.Applicative(Applicative(..)) +import Control.Monad (ap) + +-- parser produced by Happy Version 1.19.12 + +newtype HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27 = HappyAbsSyn HappyAny +#if __GLASGOW_HASKELL__ >= 607 +type HappyAny = Happy_GHC_Exts.Any +#else +type HappyAny = forall a . a +#endif +happyIn4 :: t4 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn4 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn4 #-} +happyOut4 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t4 +happyOut4 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut4 #-} +happyIn5 :: t5 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn5 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn5 #-} +happyOut5 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t5 +happyOut5 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut5 #-} +happyIn6 :: t6 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn6 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn6 #-} +happyOut6 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t6 +happyOut6 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut6 #-} +happyIn7 :: t7 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn7 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn7 #-} +happyOut7 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t7 +happyOut7 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut7 #-} +happyIn8 :: t8 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn8 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn8 #-} +happyOut8 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t8 +happyOut8 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut8 #-} +happyIn9 :: t9 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn9 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn9 #-} +happyOut9 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t9 +happyOut9 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut9 #-} +happyIn10 :: t10 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn10 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn10 #-} +happyOut10 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t10 +happyOut10 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut10 #-} +happyIn11 :: t11 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn11 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn11 #-} +happyOut11 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t11 +happyOut11 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut11 #-} +happyIn12 :: t12 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn12 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn12 #-} +happyOut12 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t12 +happyOut12 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut12 #-} +happyIn13 :: t13 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn13 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn13 #-} +happyOut13 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t13 +happyOut13 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut13 #-} +happyIn14 :: t14 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn14 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn14 #-} +happyOut14 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t14 +happyOut14 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut14 #-} +happyIn15 :: t15 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn15 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn15 #-} +happyOut15 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t15 +happyOut15 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut15 #-} +happyIn16 :: t16 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn16 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn16 #-} +happyOut16 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t16 +happyOut16 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut16 #-} +happyIn17 :: t17 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn17 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn17 #-} +happyOut17 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t17 +happyOut17 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut17 #-} +happyIn18 :: t18 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn18 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn18 #-} +happyOut18 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t18 +happyOut18 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut18 #-} +happyIn19 :: t19 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn19 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn19 #-} +happyOut19 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t19 +happyOut19 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut19 #-} +happyIn20 :: t20 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn20 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn20 #-} +happyOut20 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t20 +happyOut20 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut20 #-} +happyIn21 :: t21 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn21 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn21 #-} +happyOut21 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t21 +happyOut21 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut21 #-} +happyIn22 :: t22 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn22 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn22 #-} +happyOut22 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t22 +happyOut22 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut22 #-} +happyIn23 :: t23 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn23 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn23 #-} +happyOut23 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t23 +happyOut23 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut23 #-} +happyIn24 :: t24 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn24 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn24 #-} +happyOut24 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t24 +happyOut24 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut24 #-} +happyIn25 :: t25 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn25 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn25 #-} +happyOut25 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t25 +happyOut25 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut25 #-} +happyIn26 :: t26 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn26 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn26 #-} +happyOut26 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t26 +happyOut26 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut26 #-} +happyIn27 :: t27 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn27 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn27 #-} +happyOut27 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t27 +happyOut27 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut27 #-} +happyInTok :: (Token) -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyInTok x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyInTok #-} +happyOutTok :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> (Token) +happyOutTok x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOutTok #-} + + +happyExpList :: HappyAddr +happyExpList = HappyA# "\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x3e\x06\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x03\x00\x00\x00\x80\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\xe0\x08\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x00\x08\x00\x00\x00\xc0\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x01\x02\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x30\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00"# + +{-# NOINLINE happyExpListPerState #-} +happyExpListPerState st = + token_strs_expected + where token_strs = ["error","%dummy","%start_dot","Graph","Strictness","GraphType","Name_empty","Name","Quoted_string","Quoted_sum","Stmt_list","Stmt_list_aux","Stmt_sep","Stmt","Attr_stmt","Attr_list","Attr_list_aux","A_list","Edge_stmt","EdgeRHS","Node_stmt","Node","Port","Subgraph","Xml","XmlList","XmlElement","graph","digraph","node","edge","subgraph","label","qlabel","strict","arrow","'='","'{'","'}'","'['","']'","':'","';'","','","'+'","xmlClose","xmlOpen","xmlProc","%eof"] + bit_start = st * 49 + bit_end = (st + 1) * 49 + read_bit = readArrayBit happyExpList + bits = map read_bit [bit_start..bit_end - 1] + bits_indexed = zip bits [0..48] + token_strs_expected = concatMap f bits_indexed + f (False, _) = [] + f (True, nr) = [token_strs !! nr] + +happyActOffsets :: HappyAddr +happyActOffsets = HappyA# "\xf9\xff\xf9\xff\x23\x00\x00\x00\xed\xff\x0d\x00\x00\x00\x00\x00\x07\x00\x00\x00\x00\x00\x09\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4f\x00\x36\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x52\x00\x1c\x00\x00\x00\x38\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x0d\x00\x00\x00\x47\x00\x00\x00\x34\x00\x00\x00\x00\x00\x56\x00\x46\x00\x00\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0d\x00\x0d\x00\x00\x00\x65\x00\x00\x00\x00\x00\x49\x00\x67\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x50\x00\x00\x00\x00\x00\x55\x00\x00\x00\x0d\x00\x00\x00\x6b\x00\x0d\x00\x00\x00\x00\x00"# + +happyGotoOffsets :: HappyAddr +happyGotoOffsets = HappyA# "\x68\x00\x76\x00\x77\x00\x00\x00\x00\x00\x0b\x00\x00\x00\x00\x00\x71\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x63\x00\x00\x00\x00\x00\x73\x00\x18\x00\x00\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x6c\x00\x6e\x00\x00\x00\x74\x00\x00\x00\x00\x00\x00\x00\x4c\x00\x72\x00\x5e\x00\x60\x00\x62\x00\x13\x00\x00\x00\x75\x00\x00\x00\x00\x00\x00\x00\x00\x00\x64\x00\x2a\x00\x00\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x05\x00\x32\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2e\x00\x78\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x70\x00\x00\x00\x7b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x35\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00"# + +happyAdjustOffset :: Happy_GHC_Exts.Int# -> Happy_GHC_Exts.Int# +happyAdjustOffset off = off + +happyDefActions :: HappyAddr +happyDefActions = HappyA# "\xfc\xff\x00\x00\x00\x00\xfd\xff\x00\x00\xf8\xff\xfb\xff\xfa\xff\x00\x00\xf9\xff\xf6\xff\xf4\xff\xf5\xff\xf7\xff\xf3\xff\xcd\xff\x00\x00\x00\x00\xfe\xff\xef\xff\x00\x00\xf2\xff\xce\xff\xcf\xff\xcd\xff\xcb\xff\x00\x00\xd5\xff\xd0\xff\xec\xff\xeb\xff\xe9\xff\xea\xff\xe1\xff\xe7\xff\xe1\xff\xe1\xff\xe1\xff\xf8\xff\xf1\xff\x00\x00\xe5\xff\xe3\xff\xe6\xff\xe4\xff\xe1\xff\x00\x00\xd6\xff\xe1\xff\xf0\xff\xee\xff\xed\xff\xd4\xff\x00\x00\x00\x00\xcc\xff\xd3\xff\xe8\xff\xde\xff\x00\x00\xd5\xff\xda\xff\xd9\xff\xd8\xff\xd7\xff\xdd\xff\xdf\xff\xd1\xff\xec\xff\xdc\xff\xdb\xff\x00\x00\xd2\xff\x00\x00\xe2\xff\x00\x00\x00\x00\xe0\xff"# + +happyCheck :: HappyAddr +happyCheck = HappyA# "\xff\xff\x08\x00\x01\x00\x16\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x04\x00\x05\x00\x06\x00\x0b\x00\x0c\x00\x03\x00\x04\x00\x05\x00\x06\x00\x0b\x00\x06\x00\x07\x00\x14\x00\x03\x00\x04\x00\x05\x00\x06\x00\x15\x00\x12\x00\x04\x00\x05\x00\x06\x00\x07\x00\x15\x00\x14\x00\x0a\x00\x0b\x00\x01\x00\x02\x00\x0a\x00\x0f\x00\x15\x00\x11\x00\x12\x00\x0f\x00\x14\x00\x15\x00\x04\x00\x05\x00\x06\x00\x07\x00\x04\x00\x05\x00\x06\x00\x07\x00\x04\x00\x05\x00\x06\x00\x04\x00\x05\x00\x06\x00\x12\x00\x07\x00\x14\x00\x15\x00\x12\x00\x0d\x00\x14\x00\x15\x00\x04\x00\x05\x00\x06\x00\x15\x00\x10\x00\x11\x00\x15\x00\x05\x00\x06\x00\x07\x00\x05\x00\x06\x00\x07\x00\x0b\x00\x0b\x00\x09\x00\x0b\x00\x15\x00\x10\x00\x11\x00\x0c\x00\x0d\x00\x14\x00\x06\x00\x10\x00\x14\x00\x0e\x00\x09\x00\x10\x00\x11\x00\x13\x00\x14\x00\x15\x00\x13\x00\x14\x00\x15\x00\x00\x00\x01\x00\x0c\x00\x0d\x00\x0c\x00\x0d\x00\x0c\x00\x0d\x00\x0c\x00\x0d\x00\x0c\x00\x0d\x00\x0f\x00\x0a\x00\x0f\x00\x01\x00\x07\x00\x02\x00\x17\x00\x08\x00\x07\x00\x09\x00\x0e\x00\x16\x00\x16\x00\x13\x00\x10\x00\x17\x00\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x13\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"# + +happyTable :: HappyAddr +happyTable = HappyA# "\x00\x00\x04\x00\x24\x00\xff\xff\x25\x00\x26\x00\x27\x00\x0e\x00\x0f\x00\x39\x00\x0a\x00\x0b\x00\x14\x00\x28\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x14\x00\x0e\x00\x0f\x00\x10\x00\x28\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x12\x00\x1b\x00\x0a\x00\x0b\x00\x1c\x00\x0c\x00\x10\x00\x1d\x00\x1e\x00\x07\x00\x08\x00\x36\x00\x1f\x00\x0c\x00\x20\x00\x21\x00\x37\x00\x22\x00\x0c\x00\x3c\x00\x0a\x00\x0b\x00\x1c\x00\x3c\x00\x0a\x00\x0b\x00\x1c\x00\x38\x00\x0a\x00\x0b\x00\x4b\x00\x0a\x00\x0b\x00\x3d\x00\x16\x00\x3e\x00\x0c\x00\x45\x00\x43\x00\x46\x00\x0c\x00\x4d\x00\x0a\x00\x0b\x00\x0c\x00\x33\x00\x34\x00\x0c\x00\x27\x00\x0e\x00\x0f\x00\x27\x00\x0e\x00\x0f\x00\x14\x00\x14\x00\x2f\x00\x14\x00\x0c\x00\x40\x00\x41\x00\x2f\x00\x2a\x00\x10\x00\x49\x00\x30\x00\x10\x00\x4b\x00\x3c\x00\x33\x00\x34\x00\x18\x00\x19\x00\x1a\x00\x38\x00\x19\x00\x1a\x00\x04\x00\x02\x00\x2c\x00\x2a\x00\x2b\x00\x2a\x00\x29\x00\x2a\x00\x41\x00\x2a\x00\x3a\x00\x2a\x00\x48\x00\x4d\x00\x37\x00\x02\x00\x12\x00\x05\x00\x16\x00\x14\x00\x43\x00\x31\x00\x44\x00\x10\x00\x1a\x00\x34\x00\x2d\x00\x16\x00\x49\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x34\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"# + +happyReduceArr = Happy_Data_Array.array (1, 52) [ + (1 , happyReduce_1), + (2 , happyReduce_2), + (3 , happyReduce_3), + (4 , happyReduce_4), + (5 , happyReduce_5), + (6 , happyReduce_6), + (7 , happyReduce_7), + (8 , happyReduce_8), + (9 , happyReduce_9), + (10 , happyReduce_10), + (11 , happyReduce_11), + (12 , happyReduce_12), + (13 , happyReduce_13), + (14 , happyReduce_14), + (15 , happyReduce_15), + (16 , happyReduce_16), + (17 , happyReduce_17), + (18 , happyReduce_18), + (19 , happyReduce_19), + (20 , happyReduce_20), + (21 , happyReduce_21), + (22 , happyReduce_22), + (23 , happyReduce_23), + (24 , happyReduce_24), + (25 , happyReduce_25), + (26 , happyReduce_26), + (27 , happyReduce_27), + (28 , happyReduce_28), + (29 , happyReduce_29), + (30 , happyReduce_30), + (31 , happyReduce_31), + (32 , happyReduce_32), + (33 , happyReduce_33), + (34 , happyReduce_34), + (35 , happyReduce_35), + (36 , happyReduce_36), + (37 , happyReduce_37), + (38 , happyReduce_38), + (39 , happyReduce_39), + (40 , happyReduce_40), + (41 , happyReduce_41), + (42 , happyReduce_42), + (43 , happyReduce_43), + (44 , happyReduce_44), + (45 , happyReduce_45), + (46 , happyReduce_46), + (47 , happyReduce_47), + (48 , happyReduce_48), + (49 , happyReduce_49), + (50 , happyReduce_50), + (51 , happyReduce_51), + (52 , happyReduce_52) + ] + +happy_n_terms = 23 :: Int +happy_n_nonterms = 24 :: Int + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_1 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_1 = happyReduce 4# 0# happyReduction_1 +happyReduction_1 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut5 happy_x_1 of { happy_var_1 -> + case happyOut6 happy_x_2 of { happy_var_2 -> + case happyOut7 happy_x_3 of { happy_var_3 -> + case happyOut11 happy_x_4 of { happy_var_4 -> + happyIn4 + ((happy_var_1, happy_var_2, happy_var_3, happy_var_4) + ) `HappyStk` happyRest}}}} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_2 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_2 = happySpecReduce_1 1# happyReduction_2 +happyReduction_2 happy_x_1 + = happyIn5 + (True + ) + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_3 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_3 = happySpecReduce_0 1# happyReduction_3 +happyReduction_3 = happyIn5 + (False + ) + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_4 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_4 = happySpecReduce_1 2# happyReduction_4 +happyReduction_4 happy_x_1 + = happyIn6 + (Graph + ) + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_5 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_5 = happySpecReduce_1 2# happyReduction_5 +happyReduction_5 happy_x_1 + = happyIn6 + (Digraph + ) + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_6 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_6 = happySpecReduce_1 3# happyReduction_6 +happyReduction_6 happy_x_1 + = case happyOut8 happy_x_1 of { happy_var_1 -> + happyIn7 + (Just happy_var_1 + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_7 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_7 = happySpecReduce_0 3# happyReduction_7 +happyReduction_7 = happyIn7 + (Nothing + ) + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_8 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_8 = happySpecReduce_1 4# happyReduction_8 +happyReduction_8 happy_x_1 + = case happyOutTok happy_x_1 of { (TokenLabel happy_var_1) -> + happyIn8 + (StringID happy_var_1 + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_9 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_9 = happySpecReduce_1 4# happyReduction_9 +happyReduction_9 happy_x_1 + = case happyOut9 happy_x_1 of { happy_var_1 -> + happyIn8 + (StringID happy_var_1 + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_10 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_10 = happySpecReduce_1 4# happyReduction_10 +happyReduction_10 happy_x_1 + = case happyOut25 happy_x_1 of { happy_var_1 -> + happyIn8 + (XMLID happy_var_1 + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_11 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_11 = happySpecReduce_1 5# happyReduction_11 +happyReduction_11 happy_x_1 + = case happyOut10 happy_x_1 of { happy_var_1 -> + happyIn9 + (concat $ reverse happy_var_1 + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_12 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_12 = happySpecReduce_1 6# happyReduction_12 +happyReduction_12 happy_x_1 + = case happyOutTok happy_x_1 of { (TokenQuotedLabel happy_var_1) -> + happyIn10 + ([happy_var_1] + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_13 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_13 = happySpecReduce_3 6# happyReduction_13 +happyReduction_13 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut10 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_3 of { (TokenQuotedLabel happy_var_3) -> + happyIn10 + (happy_var_3 : happy_var_1 + )}} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_14 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_14 = happySpecReduce_3 7# happyReduction_14 +happyReduction_14 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut12 happy_x_2 of { happy_var_2 -> + happyIn11 + (reverse happy_var_2 + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_15 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_15 = happySpecReduce_3 8# happyReduction_15 +happyReduction_15 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut12 happy_x_1 of { happy_var_1 -> + case happyOut14 happy_x_2 of { happy_var_2 -> + happyIn12 + (happy_var_2 : happy_var_1 + )}} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_16 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_16 = happySpecReduce_0 8# happyReduction_16 +happyReduction_16 = happyIn12 + ([] + ) + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_17 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_17 = happySpecReduce_1 9# happyReduction_17 +happyReduction_17 happy_x_1 + = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn13 + (Just happy_var_1 + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_18 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_18 = happySpecReduce_1 9# happyReduction_18 +happyReduction_18 happy_x_1 + = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn13 + (Just happy_var_1 + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_19 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_19 = happySpecReduce_0 9# happyReduction_19 +happyReduction_19 = happyIn13 + (Nothing + ) + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_20 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_20 = happySpecReduce_1 10# happyReduction_20 +happyReduction_20 happy_x_1 + = case happyOut15 happy_x_1 of { happy_var_1 -> + happyIn14 + (happy_var_1 + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_21 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_21 = happySpecReduce_1 10# happyReduction_21 +happyReduction_21 happy_x_1 + = case happyOut21 happy_x_1 of { happy_var_1 -> + happyIn14 + (happy_var_1 + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_22 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_22 = happySpecReduce_1 10# happyReduction_22 +happyReduction_22 happy_x_1 + = case happyOut19 happy_x_1 of { happy_var_1 -> + happyIn14 + (happy_var_1 + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_23 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_23 = happySpecReduce_3 10# happyReduction_23 +happyReduction_23 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut8 happy_x_1 of { happy_var_1 -> + case happyOut8 happy_x_3 of { happy_var_3 -> + happyIn14 + (AttributeStatement ( happy_var_1, happy_var_3) + )}} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_24 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_24 = happySpecReduce_1 10# happyReduction_24 +happyReduction_24 happy_x_1 + = case happyOut24 happy_x_1 of { happy_var_1 -> + happyIn14 + (SubgraphStatement happy_var_1 + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_25 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_25 = happySpecReduce_2 11# happyReduction_25 +happyReduction_25 happy_x_2 + happy_x_1 + = case happyOut16 happy_x_2 of { happy_var_2 -> + happyIn15 + (NodeAttribute happy_var_2 + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_26 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_26 = happySpecReduce_2 11# happyReduction_26 +happyReduction_26 happy_x_2 + happy_x_1 + = case happyOut16 happy_x_2 of { happy_var_2 -> + happyIn15 + (EdgeAttribute happy_var_2 + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_27 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_27 = happySpecReduce_2 11# happyReduction_27 +happyReduction_27 happy_x_2 + happy_x_1 + = case happyOut16 happy_x_2 of { happy_var_2 -> + happyIn15 + (GraphAttribute happy_var_2 + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_28 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_28 = happySpecReduce_1 12# happyReduction_28 +happyReduction_28 happy_x_1 + = case happyOut17 happy_x_1 of { happy_var_1 -> + happyIn16 + (reverse happy_var_1 + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_29 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_29 = happyReduce 4# 13# happyReduction_29 +happyReduction_29 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut17 happy_x_1 of { happy_var_1 -> + case happyOut18 happy_x_3 of { happy_var_3 -> + happyIn17 + (happy_var_3 ++ happy_var_1 + ) `HappyStk` happyRest}} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_30 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_30 = happySpecReduce_0 13# happyReduction_30 +happyReduction_30 = happyIn17 + ([] + ) + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_31 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_31 = happyReduce 5# 14# happyReduction_31 +happyReduction_31 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut18 happy_x_1 of { happy_var_1 -> + case happyOut8 happy_x_3 of { happy_var_3 -> + case happyOut8 happy_x_5 of { happy_var_5 -> + happyIn18 + (( happy_var_3, happy_var_5) : happy_var_1 + ) `HappyStk` happyRest}}} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_32 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_32 = happySpecReduce_0 14# happyReduction_32 +happyReduction_32 = happyIn18 + ([] + ) + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_33 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_33 = happySpecReduce_3 15# happyReduction_33 +happyReduction_33 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut22 happy_x_1 of { happy_var_1 -> + case happyOut20 happy_x_2 of { happy_var_2 -> + case happyOut16 happy_x_3 of { happy_var_3 -> + happyIn19 + (EdgeStatement ((uncurry NodeRef happy_var_1):(reverse happy_var_2)) happy_var_3 + )}}} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_34 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_34 = happySpecReduce_3 15# happyReduction_34 +happyReduction_34 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut24 happy_x_1 of { happy_var_1 -> + case happyOut20 happy_x_2 of { happy_var_2 -> + case happyOut16 happy_x_3 of { happy_var_3 -> + happyIn19 + (EdgeStatement (happy_var_1:(reverse happy_var_2)) happy_var_3 + )}}} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_35 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_35 = happySpecReduce_3 16# happyReduction_35 +happyReduction_35 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut20 happy_x_1 of { happy_var_1 -> + case happyOut22 happy_x_3 of { happy_var_3 -> + happyIn20 + ((uncurry NodeRef happy_var_3) : happy_var_1 + )}} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_36 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_36 = happySpecReduce_3 16# happyReduction_36 +happyReduction_36 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut20 happy_x_1 of { happy_var_1 -> + case happyOut24 happy_x_3 of { happy_var_3 -> + happyIn20 + (happy_var_3 : happy_var_1 + )}} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_37 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_37 = happySpecReduce_2 16# happyReduction_37 +happyReduction_37 happy_x_2 + happy_x_1 + = case happyOut22 happy_x_2 of { happy_var_2 -> + happyIn20 + ([uncurry NodeRef happy_var_2] + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_38 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_38 = happySpecReduce_2 16# happyReduction_38 +happyReduction_38 happy_x_2 + happy_x_1 + = case happyOut24 happy_x_2 of { happy_var_2 -> + happyIn20 + ([happy_var_2] + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_39 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_39 = happyMonadReduce 2# 16# happyReduction_39 +happyReduction_39 (happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen ((( getLineNumber `thenE` \line -> failE $ "Unfinished edge statement.")) + ) (\r -> happyReturn (happyIn20 r)) + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_40 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_40 = happyMonadReduce 2# 16# happyReduction_40 +happyReduction_40 (happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen ((( getLineNumber `thenE` \line -> failE $ "Unfinished edge statement.")) + ) (\r -> happyReturn (happyIn20 r)) + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_41 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_41 = happySpecReduce_2 17# happyReduction_41 +happyReduction_41 happy_x_2 + happy_x_1 + = case happyOut22 happy_x_1 of { happy_var_1 -> + case happyOut16 happy_x_2 of { happy_var_2 -> + happyIn21 + ((uncurry NodeStatement) happy_var_1 happy_var_2 + )}} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_42 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_42 = happySpecReduce_1 18# happyReduction_42 +happyReduction_42 happy_x_1 + = case happyOut8 happy_x_1 of { happy_var_1 -> + happyIn22 + ((happy_var_1, Nothing) + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_43 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_43 = happySpecReduce_2 18# happyReduction_43 +happyReduction_43 happy_x_2 + happy_x_1 + = case happyOut8 happy_x_1 of { happy_var_1 -> + case happyOut23 happy_x_2 of { happy_var_2 -> + happyIn22 + ((happy_var_1, (Just happy_var_2)) + )}} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_44 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_44 = happySpecReduce_2 19# happyReduction_44 +happyReduction_44 happy_x_2 + happy_x_1 + = case happyOut8 happy_x_2 of { happy_var_2 -> + happyIn23 + (case toCompass $ show happy_var_2 of + Just c -> Port Nothing (Just c) + Nothing -> Port (if show happy_var_2 == "_" then Nothing else (Just happy_var_2)) Nothing + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_45 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_45 = happyReduce 4# 19# happyReduction_45 +happyReduction_45 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut8 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_4 of { (TokenLabel happy_var_4) -> + happyIn23 + (Port (Just happy_var_2) (toCompass happy_var_4) + ) `HappyStk` happyRest}} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_46 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_46 = happySpecReduce_3 20# happyReduction_46 +happyReduction_46 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut7 happy_x_2 of { happy_var_2 -> + case happyOut11 happy_x_3 of { happy_var_3 -> + happyIn24 + (Subgraph happy_var_2 happy_var_3 + )}} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_47 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_47 = happySpecReduce_1 20# happyReduction_47 +happyReduction_47 happy_x_1 + = case happyOut11 happy_x_1 of { happy_var_1 -> + happyIn24 + (Subgraph Nothing happy_var_1 + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_48 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_48 = happySpecReduce_3 21# happyReduction_48 +happyReduction_48 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { (TokenOT happy_var_1) -> + case happyOut26 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { (TokenCT happy_var_3) -> + happyIn25 + (show happy_var_1 ++ (concat $ reverse happy_var_2) ++ show happy_var_3 + )}}} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_49 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_49 = happySpecReduce_2 22# happyReduction_49 +happyReduction_49 happy_x_2 + happy_x_1 + = case happyOut26 happy_x_1 of { happy_var_1 -> + case happyOut27 happy_x_2 of { happy_var_2 -> + happyIn26 + (happy_var_2 : happy_var_1 + )}} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_50 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_50 = happySpecReduce_0 22# happyReduction_50 +happyReduction_50 = happyIn26 + ([] + ) + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_51 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_51 = happySpecReduce_3 23# happyReduction_51 +happyReduction_51 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { (TokenOT happy_var_1) -> + case happyOut26 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { (TokenCT happy_var_3) -> + happyIn27 + (show happy_var_1 ++ (concat $ reverse happy_var_2) ++ show happy_var_3 + )}}} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_52 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_52 = happySpecReduce_1 23# happyReduction_52 +happyReduction_52 happy_x_1 + = case happyOutTok happy_x_1 of { (TokenProc happy_var_1) -> + happyIn27 + (show happy_var_1 + )} + +happyNewToken action sts stk + = lexer(\tk -> + let cont i = happyDoAction i tk action sts stk in + case tk of { + TokenEOF -> happyDoAction 22# tk action sts stk; + TokenGraph -> cont 1#; + TokenDigraph -> cont 2#; + TokenNode -> cont 3#; + TokenEdge -> cont 4#; + TokenSubgraph -> cont 5#; + TokenLabel happy_dollar_dollar -> cont 6#; + TokenQuotedLabel happy_dollar_dollar -> cont 7#; + TokenStrict -> cont 8#; + TokenArrow happy_dollar_dollar -> cont 9#; + TokenEQ -> cont 10#; + TokenOCB -> cont 11#; + TokenCCB -> cont 12#; + TokenOSB -> cont 13#; + TokenCSB -> cont 14#; + TokenCo -> cont 15#; + TokenSemiCo -> cont 16#; + TokenComma -> cont 17#; + TokenPlus -> cont 18#; + TokenCT happy_dollar_dollar -> cont 19#; + TokenOT happy_dollar_dollar -> cont 20#; + TokenProc happy_dollar_dollar -> cont 21#; + _ -> happyError' (tk, []) + }) + +happyError_ explist 22# tk = happyError' (tk, explist) +happyError_ explist _ tk = happyError' (tk, explist) + +happyThen :: () => P a -> (a -> P b) -> P b +happyThen = (thenE) +happyReturn :: () => a -> P a +happyReturn = (returnE) +#if __GLASGOW_HASKELL__ >= 710 +happyParse :: () => Happy_GHC_Exts.Int# -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) + +happyNewToken :: () => Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) + +happyDoAction :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) + +happyReduceArr :: () => Happy_Data_Array.Array Int (Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _)) + +#endif +happyThen1 :: () => P a -> (a -> P b) -> P b +happyThen1 = happyThen +happyReturn1 :: () => a -> P a +happyReturn1 = happyReturn +happyError' :: () => ((Token), [String]) -> P a +happyError' tk = (\(tokens, _) -> parseError tokens) tk +dot = happySomeParser where + happySomeParser = happyThen (happyParse 0#) (\x -> happyReturn (let {x' = happyOut4 x} in x')) + +happySeq = happyDontSeq + + +data Except a = Success a | Failure String +type P a = String -> Int -> Except a + +thenE :: P a -> (a -> P b) -> P b +thenE m k s l = + case m s l of + Success a -> k a s l + Failure e -> Failure e + +returnE :: a -> P a +returnE a s l = Success a + +failE :: String -> P a +failE e s l = Failure $ "Error on line " ++ show l ++ ": " ++ e + +catchE :: P a -> (String -> P a) -> P a +catchE m k s l = case m s l of + Success a -> Success a + Failure e -> k e s l +getLineNumber s l = Success l +parseError :: Token -> P a +parseError t = getLineNumber `thenE` \line -> failE $ "Parse error on line " ++ show line ++ "." + +data Token = + TokenGraph + | TokenDigraph + | TokenNode + | TokenEdge + | TokenSubgraph + | TokenStrict + | TokenLabel String + | TokenQuotedLabel String + | TokenXML String + | TokenCompass Compass + | TokenArrow Char + | TokenEQ + | TokenOCB + | TokenCCB + | TokenOSB + | TokenCSB + | TokenCo + | TokenSemiCo + | TokenComma + | TokenCT String + | TokenOT String + | TokenProc String + | TokenPlus + | TokenEOF + deriving (Eq) + +instance Show Token where + show tk = case tk of + TokenGraph -> "graph" + TokenDigraph -> "digraph" + TokenNode -> "node" + TokenEdge -> "edge" + TokenSubgraph -> "subgraph" + TokenStrict -> "strict" + TokenLabel label -> label + TokenQuotedLabel label -> label + TokenXML xml -> xml + TokenCompass compass -> show compass + TokenArrow c -> [c] + TokenEQ -> "=" + TokenOCB -> "{" + TokenCCB -> "]" + TokenOSB -> "[" + TokenCSB -> "]" + TokenCo -> ":" + TokenSemiCo -> ";" + TokenComma -> "," + TokenCT tag -> "" + TokenOT tag -> "<" ++ tag ++ ">" + TokenProc xml -> "" + TokenPlus -> "+" + TokenEOF -> "" + +-- | Parse a graph written in the DOT language. +parse s = case dot ('\n':s) 0 of -- A newline is added to treat '#' in the beginning of a line properly. + Success ast -> Right ast + Failure msg -> Left msg + +toCompass l = + case map toLower l of + "n" -> Just $ North + "ne" -> Just $ NorthEast + "e" -> Just $ East + "se" -> Just $ SouthEast + "s" -> Just $ South + "sw" -> Just $ SouthWest + "w" -> Just $ West + "nw" -> Just $ NorthWest + "c" -> Just $ Center + "_" -> Nothing + _ -> Nothing + +lexer :: (Token -> (P a)) -> (P a) +lexer cont str line = case dropWhile (\c -> c /= '\n' && isSpace c) str of + '\n':'#':s' -> let s'' = dropWhile (/= '\n') s' in lexer cont s'' (line + 1) + '\n':s' -> lexer cont s' (line +1) + ',':s' -> cont TokenComma s' line + ';':s' -> cont TokenSemiCo s' line + 's':'u':'b':'g':'r':'a':'p':'h':s' -> cont TokenSubgraph s' line + 'g':'r':'a':'p':'h':s' -> cont TokenGraph s' line + 'd':'i':'g':'r':'a':'p':'h':s' -> cont TokenDigraph s' line + 'e':'d':'g':'e':s' -> cont TokenEdge s' line + 'n':'o':'d':'e':s' -> cont TokenNode s' line + 's':'t':'r':'i':'c':'t':s' -> cont TokenStrict s' line + '{':s' -> cont TokenOCB s' line + '}':s' -> cont TokenCCB s' line + '[':s' -> cont TokenOSB s' line + ']':s' -> cont TokenCSB s' line + '+':s' -> cont TokenPlus s' line + '=':s' -> cont TokenEQ s' line + ':':s' -> cont TokenCo s' line + '-':'-':s' -> cont (TokenArrow '-') s' line + '-':'>':s' -> cont (TokenArrow '>') s' line + '/':'/':s' -> let s'' = dropWhile (/= '\n') s' in lexer cont s'' line + '/':'*':s' -> let (s'', line') = execState consumeComment (s', line) + in lexer cont s'' (line') + '"':s' -> let (qs, (s'', line')) = runState consumeQuotedString (s', line) + in case qs of + Right string -> cont (TokenQuotedLabel string) s'' line' + Left msg -> failE msg s' line' + '<':'/':s' -> let (tag, (s'', line')) = runState consumeTag (s', line) + in cont (TokenCT tag) (tail s'') line' + '<':'!':'-':'-':s' -> let (s'', line') = execState consumeXMLComment (s', line) + in lexer cont s'' line' + '<':'?':s' -> let (proc, (s'', line')) = runState consumeProcessing (s', line) + in cont (TokenProc proc) s'' line' + [] -> cont TokenEOF [] line + s' -> let (label, s'') = span (\x -> not $ isSpace x || x `elem` ";,{}[]=\"") s' + in if null label then failE ("Unexpected character: " ++ [head s'']) s' line + else cont (TokenLabel label) s'' line +{-# LINE 1 "templates/GenericTemplate.hs" #-} +-- $Id: GenericTemplate.hs,v 1.26 2005/01/14 14:47:22 simonmar Exp $ + + + + + + + + + + + + + +-- Do not remove this comment. Required to fix CPP parsing when using GCC and a clang-compiled alex. +#if __GLASGOW_HASKELL__ > 706 +#define LT(n,m) ((Happy_GHC_Exts.tagToEnum# (n Happy_GHC_Exts.<# m)) :: Bool) +#define GTE(n,m) ((Happy_GHC_Exts.tagToEnum# (n Happy_GHC_Exts.>=# m)) :: Bool) +#define EQ(n,m) ((Happy_GHC_Exts.tagToEnum# (n Happy_GHC_Exts.==# m)) :: Bool) +#else +#define LT(n,m) (n Happy_GHC_Exts.<# m) +#define GTE(n,m) (n Happy_GHC_Exts.>=# m) +#define EQ(n,m) (n Happy_GHC_Exts.==# m) +#endif + + + + + + + + + + + + + + + + + + + +data Happy_IntList = HappyCons Happy_GHC_Exts.Int# Happy_IntList + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +infixr 9 `HappyStk` +data HappyStk a = HappyStk a (HappyStk a) + +----------------------------------------------------------------------------- +-- starting the parse + +happyParse start_state = happyNewToken start_state notHappyAtAll notHappyAtAll + +----------------------------------------------------------------------------- +-- Accepting the parse + +-- If the current token is ERROR_TOK, it means we've just accepted a partial +-- parse (a %partial parser). We must ignore the saved token on the top of +-- the stack in this case. +happyAccept 0# tk st sts (_ `HappyStk` ans `HappyStk` _) = + happyReturn1 ans +happyAccept j tk st sts (HappyStk ans _) = + (happyTcHack j (happyTcHack st)) (happyReturn1 ans) + +----------------------------------------------------------------------------- +-- Arrays only: do the next action + + + +happyDoAction i tk st + = {- nothing -} + case action of + 0# -> {- nothing -} + happyFail (happyExpListPerState ((Happy_GHC_Exts.I# (st)) :: Int)) i tk st + -1# -> {- nothing -} + happyAccept i tk st + n | LT(n,(0# :: Happy_GHC_Exts.Int#)) -> {- nothing -} + (happyReduceArr Happy_Data_Array.! rule) i tk st + where rule = (Happy_GHC_Exts.I# ((Happy_GHC_Exts.negateInt# ((n Happy_GHC_Exts.+# (1# :: Happy_GHC_Exts.Int#)))))) + n -> {- nothing -} + happyShift new_state i tk st + where new_state = (n Happy_GHC_Exts.-# (1# :: Happy_GHC_Exts.Int#)) + where off = happyAdjustOffset (indexShortOffAddr happyActOffsets st) + off_i = (off Happy_GHC_Exts.+# i) + check = if GTE(off_i,(0# :: Happy_GHC_Exts.Int#)) + then EQ(indexShortOffAddr happyCheck off_i, i) + else False + action + | check = indexShortOffAddr happyTable off_i + | otherwise = indexShortOffAddr happyDefActions st + + + + +indexShortOffAddr (HappyA# arr) off = + Happy_GHC_Exts.narrow16Int# i + where + i = Happy_GHC_Exts.word2Int# (Happy_GHC_Exts.or# (Happy_GHC_Exts.uncheckedShiftL# high 8#) low) + high = Happy_GHC_Exts.int2Word# (Happy_GHC_Exts.ord# (Happy_GHC_Exts.indexCharOffAddr# arr (off' Happy_GHC_Exts.+# 1#))) + low = Happy_GHC_Exts.int2Word# (Happy_GHC_Exts.ord# (Happy_GHC_Exts.indexCharOffAddr# arr off')) + off' = off Happy_GHC_Exts.*# 2# + + + + +{-# INLINE happyLt #-} +happyLt x y = LT(x,y) + + +readArrayBit arr bit = + Bits.testBit (Happy_GHC_Exts.I# (indexShortOffAddr arr ((unbox_int bit) `Happy_GHC_Exts.iShiftRA#` 4#))) (bit `mod` 16) + where unbox_int (Happy_GHC_Exts.I# x) = x + + + + + + +data HappyAddr = HappyA# Happy_GHC_Exts.Addr# + + +----------------------------------------------------------------------------- +-- HappyState data type (not arrays) + + + + + + + + + + + + + +----------------------------------------------------------------------------- +-- Shifting a token + +happyShift new_state 0# tk st sts stk@(x `HappyStk` _) = + let i = (case Happy_GHC_Exts.unsafeCoerce# x of { (Happy_GHC_Exts.I# (i)) -> i }) in +-- trace "shifting the error token" $ + happyDoAction i tk new_state (HappyCons (st) (sts)) (stk) + +happyShift new_state i tk st sts stk = + happyNewToken new_state (HappyCons (st) (sts)) ((happyInTok (tk))`HappyStk`stk) + +-- happyReduce is specialised for the common cases. + +happySpecReduce_0 i fn 0# tk st sts stk + = happyFail [] 0# tk st sts stk +happySpecReduce_0 nt fn j tk st@((action)) sts stk + = happyGoto nt j tk st (HappyCons (st) (sts)) (fn `HappyStk` stk) + +happySpecReduce_1 i fn 0# tk st sts stk + = happyFail [] 0# tk st sts stk +happySpecReduce_1 nt fn j tk _ sts@((HappyCons (st@(action)) (_))) (v1`HappyStk`stk') + = let r = fn v1 in + happySeq r (happyGoto nt j tk st sts (r `HappyStk` stk')) + +happySpecReduce_2 i fn 0# tk st sts stk + = happyFail [] 0# tk st sts stk +happySpecReduce_2 nt fn j tk _ (HappyCons (_) (sts@((HappyCons (st@(action)) (_))))) (v1`HappyStk`v2`HappyStk`stk') + = let r = fn v1 v2 in + happySeq r (happyGoto nt j tk st sts (r `HappyStk` stk')) + +happySpecReduce_3 i fn 0# tk st sts stk + = happyFail [] 0# tk st sts stk +happySpecReduce_3 nt fn j tk _ (HappyCons (_) ((HappyCons (_) (sts@((HappyCons (st@(action)) (_))))))) (v1`HappyStk`v2`HappyStk`v3`HappyStk`stk') + = let r = fn v1 v2 v3 in + happySeq r (happyGoto nt j tk st sts (r `HappyStk` stk')) + +happyReduce k i fn 0# tk st sts stk + = happyFail [] 0# tk st sts stk +happyReduce k nt fn j tk st sts stk + = case happyDrop (k Happy_GHC_Exts.-# (1# :: Happy_GHC_Exts.Int#)) sts of + sts1@((HappyCons (st1@(action)) (_))) -> + let r = fn stk in -- it doesn't hurt to always seq here... + happyDoSeq r (happyGoto nt j tk st1 sts1 r) + +happyMonadReduce k nt fn 0# tk st sts stk + = happyFail [] 0# tk st sts stk +happyMonadReduce k nt fn j tk st sts stk = + case happyDrop k (HappyCons (st) (sts)) of + sts1@((HappyCons (st1@(action)) (_))) -> + let drop_stk = happyDropStk k stk in + happyThen1 (fn stk tk) (\r -> happyGoto nt j tk st1 sts1 (r `HappyStk` drop_stk)) + +happyMonad2Reduce k nt fn 0# tk st sts stk + = happyFail [] 0# tk st sts stk +happyMonad2Reduce k nt fn j tk st sts stk = + case happyDrop k (HappyCons (st) (sts)) of + sts1@((HappyCons (st1@(action)) (_))) -> + let drop_stk = happyDropStk k stk + + off = happyAdjustOffset (indexShortOffAddr happyGotoOffsets st1) + off_i = (off Happy_GHC_Exts.+# nt) + new_state = indexShortOffAddr happyTable off_i + + + + + in + happyThen1 (fn stk tk) (\r -> happyNewToken new_state sts1 (r `HappyStk` drop_stk)) + +happyDrop 0# l = l +happyDrop n (HappyCons (_) (t)) = happyDrop (n Happy_GHC_Exts.-# (1# :: Happy_GHC_Exts.Int#)) t + +happyDropStk 0# l = l +happyDropStk n (x `HappyStk` xs) = happyDropStk (n Happy_GHC_Exts.-# (1#::Happy_GHC_Exts.Int#)) xs + +----------------------------------------------------------------------------- +-- Moving to a new state after a reduction + + +happyGoto nt j tk st = + {- nothing -} + happyDoAction j tk new_state + where off = happyAdjustOffset (indexShortOffAddr happyGotoOffsets st) + off_i = (off Happy_GHC_Exts.+# nt) + new_state = indexShortOffAddr happyTable off_i + + + + +----------------------------------------------------------------------------- +-- Error recovery (ERROR_TOK is the error token) + +-- parse error if we are in recovery and we fail again +happyFail explist 0# tk old_st _ stk@(x `HappyStk` _) = + let i = (case Happy_GHC_Exts.unsafeCoerce# x of { (Happy_GHC_Exts.I# (i)) -> i }) in +-- trace "failing" $ + happyError_ explist i tk + +{- We don't need state discarding for our restricted implementation of + "error". In fact, it can cause some bogus parses, so I've disabled it + for now --SDM + +-- discard a state +happyFail ERROR_TOK tk old_st CONS(HAPPYSTATE(action),sts) + (saved_tok `HappyStk` _ `HappyStk` stk) = +-- trace ("discarding state, depth " ++ show (length stk)) $ + DO_ACTION(action,ERROR_TOK,tk,sts,(saved_tok`HappyStk`stk)) +-} + +-- Enter error recovery: generate an error token, +-- save the old token and carry on. +happyFail explist i tk (action) sts stk = +-- trace "entering error recovery" $ + happyDoAction 0# tk action sts ((Happy_GHC_Exts.unsafeCoerce# (Happy_GHC_Exts.I# (i))) `HappyStk` stk) + +-- Internal happy errors: + +notHappyAtAll :: a +notHappyAtAll = error "Internal Happy error\n" + +----------------------------------------------------------------------------- +-- Hack to get the typechecker to accept our action functions + + +happyTcHack :: Happy_GHC_Exts.Int# -> a -> a +happyTcHack x y = y +{-# INLINE happyTcHack #-} + + +----------------------------------------------------------------------------- +-- Seq-ing. If the --strict flag is given, then Happy emits +-- happySeq = happyDoSeq +-- otherwise it emits +-- happySeq = happyDontSeq + +happyDoSeq, happyDontSeq :: a -> b -> b +happyDoSeq a b = a `seq` b +happyDontSeq a b = b + +----------------------------------------------------------------------------- +-- Don't inline any functions from the template. GHC has a nasty habit +-- of deciding to inline happyGoto everywhere, which increases the size of +-- the generated parser quite a bit. + + +{-# NOINLINE happyDoAction #-} +{-# NOINLINE happyTable #-} +{-# NOINLINE happyCheck #-} +{-# NOINLINE happyActOffsets #-} +{-# NOINLINE happyGotoOffsets #-} +{-# NOINLINE happyDefActions #-} + +{-# NOINLINE happyShift #-} +{-# NOINLINE happySpecReduce_0 #-} +{-# NOINLINE happySpecReduce_1 #-} +{-# NOINLINE happySpecReduce_2 #-} +{-# NOINLINE happySpecReduce_3 #-} +{-# NOINLINE happyReduce #-} +{-# NOINLINE happyMonadReduce #-} +{-# NOINLINE happyGoto #-} +{-# NOINLINE happyFail #-} + +-- end of Happy Template. diff --git a/dist/build/test-ast/test-ast-tmp/Language/Dot/Parser.hs b/dist/build/test-ast/test-ast-tmp/Language/Dot/Parser.hs new file mode 100644 --- /dev/null +++ b/dist/build/test-ast/test-ast-tmp/Language/Dot/Parser.hs @@ -0,0 +1,1403 @@ +{-# OPTIONS_GHC -w #-} +{-# OPTIONS -XMagicHash -XBangPatterns -XTypeSynonymInstances -XFlexibleInstances -cpp #-} +#if __GLASGOW_HASKELL__ >= 710 +{-# OPTIONS_GHC -XPartialTypeSignatures #-} +#endif +-------------------------------------------------------------------- +-- | +-- Module : Language.Dot.Parser +-- License : GPL-3 +-- +-- Maintainer : Marcelo Garlet Millani +-- Stability : experimental +-- Portability : portable +-- +-- Parsing function and abstract syntax tree for the [DOT language] +-- (https://www.graphviz.org/doc/info/lang.html). +-- +-- The parser is implemented using `happy`, and so is fairly fast. +-------------------------------------------------------------------- + +module Language.Dot.Parser + (parse + , GraphType(..) + , Name(..) + , Statement(..) + , Subgraph(..) + , Port(..) + , Compass(..) + ) where + +import HappyDot.Parser +import Language.Dot.Graph + +import Data.Char +import Control.Monad.Trans.State + +import qualified Debug.Trace as D +import qualified Data.Array as Happy_Data_Array +import qualified Data.Bits as Bits +import qualified GHC.Exts as Happy_GHC_Exts +import Control.Applicative(Applicative(..)) +import Control.Monad (ap) + +-- parser produced by Happy Version 1.19.12 + +newtype HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27 = HappyAbsSyn HappyAny +#if __GLASGOW_HASKELL__ >= 607 +type HappyAny = Happy_GHC_Exts.Any +#else +type HappyAny = forall a . a +#endif +happyIn4 :: t4 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn4 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn4 #-} +happyOut4 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t4 +happyOut4 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut4 #-} +happyIn5 :: t5 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn5 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn5 #-} +happyOut5 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t5 +happyOut5 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut5 #-} +happyIn6 :: t6 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn6 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn6 #-} +happyOut6 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t6 +happyOut6 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut6 #-} +happyIn7 :: t7 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn7 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn7 #-} +happyOut7 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t7 +happyOut7 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut7 #-} +happyIn8 :: t8 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn8 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn8 #-} +happyOut8 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t8 +happyOut8 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut8 #-} +happyIn9 :: t9 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn9 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn9 #-} +happyOut9 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t9 +happyOut9 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut9 #-} +happyIn10 :: t10 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn10 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn10 #-} +happyOut10 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t10 +happyOut10 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut10 #-} +happyIn11 :: t11 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn11 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn11 #-} +happyOut11 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t11 +happyOut11 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut11 #-} +happyIn12 :: t12 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn12 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn12 #-} +happyOut12 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t12 +happyOut12 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut12 #-} +happyIn13 :: t13 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn13 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn13 #-} +happyOut13 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t13 +happyOut13 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut13 #-} +happyIn14 :: t14 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn14 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn14 #-} +happyOut14 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t14 +happyOut14 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut14 #-} +happyIn15 :: t15 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn15 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn15 #-} +happyOut15 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t15 +happyOut15 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut15 #-} +happyIn16 :: t16 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn16 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn16 #-} +happyOut16 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t16 +happyOut16 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut16 #-} +happyIn17 :: t17 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn17 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn17 #-} +happyOut17 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t17 +happyOut17 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut17 #-} +happyIn18 :: t18 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn18 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn18 #-} +happyOut18 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t18 +happyOut18 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut18 #-} +happyIn19 :: t19 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn19 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn19 #-} +happyOut19 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t19 +happyOut19 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut19 #-} +happyIn20 :: t20 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn20 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn20 #-} +happyOut20 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t20 +happyOut20 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut20 #-} +happyIn21 :: t21 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn21 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn21 #-} +happyOut21 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t21 +happyOut21 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut21 #-} +happyIn22 :: t22 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn22 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn22 #-} +happyOut22 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t22 +happyOut22 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut22 #-} +happyIn23 :: t23 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn23 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn23 #-} +happyOut23 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t23 +happyOut23 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut23 #-} +happyIn24 :: t24 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn24 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn24 #-} +happyOut24 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t24 +happyOut24 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut24 #-} +happyIn25 :: t25 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn25 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn25 #-} +happyOut25 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t25 +happyOut25 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut25 #-} +happyIn26 :: t26 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn26 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn26 #-} +happyOut26 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t26 +happyOut26 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut26 #-} +happyIn27 :: t27 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn27 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn27 #-} +happyOut27 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t27 +happyOut27 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut27 #-} +happyInTok :: (Token) -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyInTok x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyInTok #-} +happyOutTok :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> (Token) +happyOutTok x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOutTok #-} + + +happyExpList :: HappyAddr +happyExpList = HappyA# "\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x3e\x06\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x03\x00\x00\x00\x80\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\xe0\x08\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x00\x08\x00\x00\x00\xc0\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x01\x02\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x30\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00"# + +{-# NOINLINE happyExpListPerState #-} +happyExpListPerState st = + token_strs_expected + where token_strs = ["error","%dummy","%start_dot","Graph","Strictness","GraphType","Name_empty","Name","Quoted_string","Quoted_sum","Stmt_list","Stmt_list_aux","Stmt_sep","Stmt","Attr_stmt","Attr_list","Attr_list_aux","A_list","Edge_stmt","EdgeRHS","Node_stmt","Node","Port","Subgraph","Xml","XmlList","XmlElement","graph","digraph","node","edge","subgraph","label","qlabel","strict","arrow","'='","'{'","'}'","'['","']'","':'","';'","','","'+'","xmlClose","xmlOpen","xmlProc","%eof"] + bit_start = st * 49 + bit_end = (st + 1) * 49 + read_bit = readArrayBit happyExpList + bits = map read_bit [bit_start..bit_end - 1] + bits_indexed = zip bits [0..48] + token_strs_expected = concatMap f bits_indexed + f (False, _) = [] + f (True, nr) = [token_strs !! nr] + +happyActOffsets :: HappyAddr +happyActOffsets = HappyA# "\xf9\xff\xf9\xff\x23\x00\x00\x00\xed\xff\x0d\x00\x00\x00\x00\x00\x07\x00\x00\x00\x00\x00\x09\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4f\x00\x36\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x52\x00\x1c\x00\x00\x00\x38\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x0d\x00\x00\x00\x47\x00\x00\x00\x34\x00\x00\x00\x00\x00\x56\x00\x46\x00\x00\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0d\x00\x0d\x00\x00\x00\x65\x00\x00\x00\x00\x00\x49\x00\x67\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x50\x00\x00\x00\x00\x00\x55\x00\x00\x00\x0d\x00\x00\x00\x6b\x00\x0d\x00\x00\x00\x00\x00"# + +happyGotoOffsets :: HappyAddr +happyGotoOffsets = HappyA# "\x68\x00\x76\x00\x77\x00\x00\x00\x00\x00\x0b\x00\x00\x00\x00\x00\x71\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x63\x00\x00\x00\x00\x00\x73\x00\x18\x00\x00\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x6c\x00\x6e\x00\x00\x00\x74\x00\x00\x00\x00\x00\x00\x00\x4c\x00\x72\x00\x5e\x00\x60\x00\x62\x00\x13\x00\x00\x00\x75\x00\x00\x00\x00\x00\x00\x00\x00\x00\x64\x00\x2a\x00\x00\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x05\x00\x32\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2e\x00\x78\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x70\x00\x00\x00\x7b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x35\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00"# + +happyAdjustOffset :: Happy_GHC_Exts.Int# -> Happy_GHC_Exts.Int# +happyAdjustOffset off = off + +happyDefActions :: HappyAddr +happyDefActions = HappyA# "\xfc\xff\x00\x00\x00\x00\xfd\xff\x00\x00\xf8\xff\xfb\xff\xfa\xff\x00\x00\xf9\xff\xf6\xff\xf4\xff\xf5\xff\xf7\xff\xf3\xff\xcd\xff\x00\x00\x00\x00\xfe\xff\xef\xff\x00\x00\xf2\xff\xce\xff\xcf\xff\xcd\xff\xcb\xff\x00\x00\xd5\xff\xd0\xff\xec\xff\xeb\xff\xe9\xff\xea\xff\xe1\xff\xe7\xff\xe1\xff\xe1\xff\xe1\xff\xf8\xff\xf1\xff\x00\x00\xe5\xff\xe3\xff\xe6\xff\xe4\xff\xe1\xff\x00\x00\xd6\xff\xe1\xff\xf0\xff\xee\xff\xed\xff\xd4\xff\x00\x00\x00\x00\xcc\xff\xd3\xff\xe8\xff\xde\xff\x00\x00\xd5\xff\xda\xff\xd9\xff\xd8\xff\xd7\xff\xdd\xff\xdf\xff\xd1\xff\xec\xff\xdc\xff\xdb\xff\x00\x00\xd2\xff\x00\x00\xe2\xff\x00\x00\x00\x00\xe0\xff"# + +happyCheck :: HappyAddr +happyCheck = HappyA# "\xff\xff\x08\x00\x01\x00\x16\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x04\x00\x05\x00\x06\x00\x0b\x00\x0c\x00\x03\x00\x04\x00\x05\x00\x06\x00\x0b\x00\x06\x00\x07\x00\x14\x00\x03\x00\x04\x00\x05\x00\x06\x00\x15\x00\x12\x00\x04\x00\x05\x00\x06\x00\x07\x00\x15\x00\x14\x00\x0a\x00\x0b\x00\x01\x00\x02\x00\x0a\x00\x0f\x00\x15\x00\x11\x00\x12\x00\x0f\x00\x14\x00\x15\x00\x04\x00\x05\x00\x06\x00\x07\x00\x04\x00\x05\x00\x06\x00\x07\x00\x04\x00\x05\x00\x06\x00\x04\x00\x05\x00\x06\x00\x12\x00\x07\x00\x14\x00\x15\x00\x12\x00\x0d\x00\x14\x00\x15\x00\x04\x00\x05\x00\x06\x00\x15\x00\x10\x00\x11\x00\x15\x00\x05\x00\x06\x00\x07\x00\x05\x00\x06\x00\x07\x00\x0b\x00\x0b\x00\x09\x00\x0b\x00\x15\x00\x10\x00\x11\x00\x0c\x00\x0d\x00\x14\x00\x06\x00\x10\x00\x14\x00\x0e\x00\x09\x00\x10\x00\x11\x00\x13\x00\x14\x00\x15\x00\x13\x00\x14\x00\x15\x00\x00\x00\x01\x00\x0c\x00\x0d\x00\x0c\x00\x0d\x00\x0c\x00\x0d\x00\x0c\x00\x0d\x00\x0c\x00\x0d\x00\x0f\x00\x0a\x00\x0f\x00\x01\x00\x07\x00\x02\x00\x17\x00\x08\x00\x07\x00\x09\x00\x0e\x00\x16\x00\x16\x00\x13\x00\x10\x00\x17\x00\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x13\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"# + +happyTable :: HappyAddr +happyTable = HappyA# "\x00\x00\x04\x00\x24\x00\xff\xff\x25\x00\x26\x00\x27\x00\x0e\x00\x0f\x00\x39\x00\x0a\x00\x0b\x00\x14\x00\x28\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x14\x00\x0e\x00\x0f\x00\x10\x00\x28\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x12\x00\x1b\x00\x0a\x00\x0b\x00\x1c\x00\x0c\x00\x10\x00\x1d\x00\x1e\x00\x07\x00\x08\x00\x36\x00\x1f\x00\x0c\x00\x20\x00\x21\x00\x37\x00\x22\x00\x0c\x00\x3c\x00\x0a\x00\x0b\x00\x1c\x00\x3c\x00\x0a\x00\x0b\x00\x1c\x00\x38\x00\x0a\x00\x0b\x00\x4b\x00\x0a\x00\x0b\x00\x3d\x00\x16\x00\x3e\x00\x0c\x00\x45\x00\x43\x00\x46\x00\x0c\x00\x4d\x00\x0a\x00\x0b\x00\x0c\x00\x33\x00\x34\x00\x0c\x00\x27\x00\x0e\x00\x0f\x00\x27\x00\x0e\x00\x0f\x00\x14\x00\x14\x00\x2f\x00\x14\x00\x0c\x00\x40\x00\x41\x00\x2f\x00\x2a\x00\x10\x00\x49\x00\x30\x00\x10\x00\x4b\x00\x3c\x00\x33\x00\x34\x00\x18\x00\x19\x00\x1a\x00\x38\x00\x19\x00\x1a\x00\x04\x00\x02\x00\x2c\x00\x2a\x00\x2b\x00\x2a\x00\x29\x00\x2a\x00\x41\x00\x2a\x00\x3a\x00\x2a\x00\x48\x00\x4d\x00\x37\x00\x02\x00\x12\x00\x05\x00\x16\x00\x14\x00\x43\x00\x31\x00\x44\x00\x10\x00\x1a\x00\x34\x00\x2d\x00\x16\x00\x49\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x34\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"# + +happyReduceArr = Happy_Data_Array.array (1, 52) [ + (1 , happyReduce_1), + (2 , happyReduce_2), + (3 , happyReduce_3), + (4 , happyReduce_4), + (5 , happyReduce_5), + (6 , happyReduce_6), + (7 , happyReduce_7), + (8 , happyReduce_8), + (9 , happyReduce_9), + (10 , happyReduce_10), + (11 , happyReduce_11), + (12 , happyReduce_12), + (13 , happyReduce_13), + (14 , happyReduce_14), + (15 , happyReduce_15), + (16 , happyReduce_16), + (17 , happyReduce_17), + (18 , happyReduce_18), + (19 , happyReduce_19), + (20 , happyReduce_20), + (21 , happyReduce_21), + (22 , happyReduce_22), + (23 , happyReduce_23), + (24 , happyReduce_24), + (25 , happyReduce_25), + (26 , happyReduce_26), + (27 , happyReduce_27), + (28 , happyReduce_28), + (29 , happyReduce_29), + (30 , happyReduce_30), + (31 , happyReduce_31), + (32 , happyReduce_32), + (33 , happyReduce_33), + (34 , happyReduce_34), + (35 , happyReduce_35), + (36 , happyReduce_36), + (37 , happyReduce_37), + (38 , happyReduce_38), + (39 , happyReduce_39), + (40 , happyReduce_40), + (41 , happyReduce_41), + (42 , happyReduce_42), + (43 , happyReduce_43), + (44 , happyReduce_44), + (45 , happyReduce_45), + (46 , happyReduce_46), + (47 , happyReduce_47), + (48 , happyReduce_48), + (49 , happyReduce_49), + (50 , happyReduce_50), + (51 , happyReduce_51), + (52 , happyReduce_52) + ] + +happy_n_terms = 23 :: Int +happy_n_nonterms = 24 :: Int + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_1 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_1 = happyReduce 4# 0# happyReduction_1 +happyReduction_1 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut5 happy_x_1 of { happy_var_1 -> + case happyOut6 happy_x_2 of { happy_var_2 -> + case happyOut7 happy_x_3 of { happy_var_3 -> + case happyOut11 happy_x_4 of { happy_var_4 -> + happyIn4 + ((happy_var_1, happy_var_2, happy_var_3, happy_var_4) + ) `HappyStk` happyRest}}}} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_2 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_2 = happySpecReduce_1 1# happyReduction_2 +happyReduction_2 happy_x_1 + = happyIn5 + (True + ) + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_3 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_3 = happySpecReduce_0 1# happyReduction_3 +happyReduction_3 = happyIn5 + (False + ) + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_4 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_4 = happySpecReduce_1 2# happyReduction_4 +happyReduction_4 happy_x_1 + = happyIn6 + (Graph + ) + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_5 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_5 = happySpecReduce_1 2# happyReduction_5 +happyReduction_5 happy_x_1 + = happyIn6 + (Digraph + ) + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_6 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_6 = happySpecReduce_1 3# happyReduction_6 +happyReduction_6 happy_x_1 + = case happyOut8 happy_x_1 of { happy_var_1 -> + happyIn7 + (Just happy_var_1 + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_7 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_7 = happySpecReduce_0 3# happyReduction_7 +happyReduction_7 = happyIn7 + (Nothing + ) + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_8 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_8 = happySpecReduce_1 4# happyReduction_8 +happyReduction_8 happy_x_1 + = case happyOutTok happy_x_1 of { (TokenLabel happy_var_1) -> + happyIn8 + (StringID happy_var_1 + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_9 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_9 = happySpecReduce_1 4# happyReduction_9 +happyReduction_9 happy_x_1 + = case happyOut9 happy_x_1 of { happy_var_1 -> + happyIn8 + (StringID happy_var_1 + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_10 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_10 = happySpecReduce_1 4# happyReduction_10 +happyReduction_10 happy_x_1 + = case happyOut25 happy_x_1 of { happy_var_1 -> + happyIn8 + (XMLID happy_var_1 + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_11 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_11 = happySpecReduce_1 5# happyReduction_11 +happyReduction_11 happy_x_1 + = case happyOut10 happy_x_1 of { happy_var_1 -> + happyIn9 + (concat $ reverse happy_var_1 + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_12 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_12 = happySpecReduce_1 6# happyReduction_12 +happyReduction_12 happy_x_1 + = case happyOutTok happy_x_1 of { (TokenQuotedLabel happy_var_1) -> + happyIn10 + ([happy_var_1] + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_13 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_13 = happySpecReduce_3 6# happyReduction_13 +happyReduction_13 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut10 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_3 of { (TokenQuotedLabel happy_var_3) -> + happyIn10 + (happy_var_3 : happy_var_1 + )}} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_14 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_14 = happySpecReduce_3 7# happyReduction_14 +happyReduction_14 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut12 happy_x_2 of { happy_var_2 -> + happyIn11 + (reverse happy_var_2 + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_15 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_15 = happySpecReduce_3 8# happyReduction_15 +happyReduction_15 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut12 happy_x_1 of { happy_var_1 -> + case happyOut14 happy_x_2 of { happy_var_2 -> + happyIn12 + (happy_var_2 : happy_var_1 + )}} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_16 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_16 = happySpecReduce_0 8# happyReduction_16 +happyReduction_16 = happyIn12 + ([] + ) + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_17 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_17 = happySpecReduce_1 9# happyReduction_17 +happyReduction_17 happy_x_1 + = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn13 + (Just happy_var_1 + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_18 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_18 = happySpecReduce_1 9# happyReduction_18 +happyReduction_18 happy_x_1 + = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn13 + (Just happy_var_1 + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_19 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_19 = happySpecReduce_0 9# happyReduction_19 +happyReduction_19 = happyIn13 + (Nothing + ) + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_20 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_20 = happySpecReduce_1 10# happyReduction_20 +happyReduction_20 happy_x_1 + = case happyOut15 happy_x_1 of { happy_var_1 -> + happyIn14 + (happy_var_1 + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_21 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_21 = happySpecReduce_1 10# happyReduction_21 +happyReduction_21 happy_x_1 + = case happyOut21 happy_x_1 of { happy_var_1 -> + happyIn14 + (happy_var_1 + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_22 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_22 = happySpecReduce_1 10# happyReduction_22 +happyReduction_22 happy_x_1 + = case happyOut19 happy_x_1 of { happy_var_1 -> + happyIn14 + (happy_var_1 + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_23 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_23 = happySpecReduce_3 10# happyReduction_23 +happyReduction_23 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut8 happy_x_1 of { happy_var_1 -> + case happyOut8 happy_x_3 of { happy_var_3 -> + happyIn14 + (AttributeStatement ( happy_var_1, happy_var_3) + )}} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_24 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_24 = happySpecReduce_1 10# happyReduction_24 +happyReduction_24 happy_x_1 + = case happyOut24 happy_x_1 of { happy_var_1 -> + happyIn14 + (SubgraphStatement happy_var_1 + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_25 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_25 = happySpecReduce_2 11# happyReduction_25 +happyReduction_25 happy_x_2 + happy_x_1 + = case happyOut16 happy_x_2 of { happy_var_2 -> + happyIn15 + (NodeAttribute happy_var_2 + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_26 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_26 = happySpecReduce_2 11# happyReduction_26 +happyReduction_26 happy_x_2 + happy_x_1 + = case happyOut16 happy_x_2 of { happy_var_2 -> + happyIn15 + (EdgeAttribute happy_var_2 + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_27 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_27 = happySpecReduce_2 11# happyReduction_27 +happyReduction_27 happy_x_2 + happy_x_1 + = case happyOut16 happy_x_2 of { happy_var_2 -> + happyIn15 + (GraphAttribute happy_var_2 + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_28 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_28 = happySpecReduce_1 12# happyReduction_28 +happyReduction_28 happy_x_1 + = case happyOut17 happy_x_1 of { happy_var_1 -> + happyIn16 + (reverse happy_var_1 + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_29 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_29 = happyReduce 4# 13# happyReduction_29 +happyReduction_29 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut17 happy_x_1 of { happy_var_1 -> + case happyOut18 happy_x_3 of { happy_var_3 -> + happyIn17 + (happy_var_3 ++ happy_var_1 + ) `HappyStk` happyRest}} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_30 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_30 = happySpecReduce_0 13# happyReduction_30 +happyReduction_30 = happyIn17 + ([] + ) + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_31 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_31 = happyReduce 5# 14# happyReduction_31 +happyReduction_31 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut18 happy_x_1 of { happy_var_1 -> + case happyOut8 happy_x_3 of { happy_var_3 -> + case happyOut8 happy_x_5 of { happy_var_5 -> + happyIn18 + (( happy_var_3, happy_var_5) : happy_var_1 + ) `HappyStk` happyRest}}} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_32 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_32 = happySpecReduce_0 14# happyReduction_32 +happyReduction_32 = happyIn18 + ([] + ) + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_33 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_33 = happySpecReduce_3 15# happyReduction_33 +happyReduction_33 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut22 happy_x_1 of { happy_var_1 -> + case happyOut20 happy_x_2 of { happy_var_2 -> + case happyOut16 happy_x_3 of { happy_var_3 -> + happyIn19 + (EdgeStatement ((uncurry NodeRef happy_var_1):(reverse happy_var_2)) happy_var_3 + )}}} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_34 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_34 = happySpecReduce_3 15# happyReduction_34 +happyReduction_34 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut24 happy_x_1 of { happy_var_1 -> + case happyOut20 happy_x_2 of { happy_var_2 -> + case happyOut16 happy_x_3 of { happy_var_3 -> + happyIn19 + (EdgeStatement (happy_var_1:(reverse happy_var_2)) happy_var_3 + )}}} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_35 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_35 = happySpecReduce_3 16# happyReduction_35 +happyReduction_35 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut20 happy_x_1 of { happy_var_1 -> + case happyOut22 happy_x_3 of { happy_var_3 -> + happyIn20 + ((uncurry NodeRef happy_var_3) : happy_var_1 + )}} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_36 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_36 = happySpecReduce_3 16# happyReduction_36 +happyReduction_36 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut20 happy_x_1 of { happy_var_1 -> + case happyOut24 happy_x_3 of { happy_var_3 -> + happyIn20 + (happy_var_3 : happy_var_1 + )}} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_37 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_37 = happySpecReduce_2 16# happyReduction_37 +happyReduction_37 happy_x_2 + happy_x_1 + = case happyOut22 happy_x_2 of { happy_var_2 -> + happyIn20 + ([uncurry NodeRef happy_var_2] + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_38 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_38 = happySpecReduce_2 16# happyReduction_38 +happyReduction_38 happy_x_2 + happy_x_1 + = case happyOut24 happy_x_2 of { happy_var_2 -> + happyIn20 + ([happy_var_2] + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_39 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_39 = happyMonadReduce 2# 16# happyReduction_39 +happyReduction_39 (happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen ((( getLineNumber `thenE` \line -> failE $ "Unfinished edge statement.")) + ) (\r -> happyReturn (happyIn20 r)) + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_40 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_40 = happyMonadReduce 2# 16# happyReduction_40 +happyReduction_40 (happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen ((( getLineNumber `thenE` \line -> failE $ "Unfinished edge statement.")) + ) (\r -> happyReturn (happyIn20 r)) + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_41 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_41 = happySpecReduce_2 17# happyReduction_41 +happyReduction_41 happy_x_2 + happy_x_1 + = case happyOut22 happy_x_1 of { happy_var_1 -> + case happyOut16 happy_x_2 of { happy_var_2 -> + happyIn21 + ((uncurry NodeStatement) happy_var_1 happy_var_2 + )}} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_42 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_42 = happySpecReduce_1 18# happyReduction_42 +happyReduction_42 happy_x_1 + = case happyOut8 happy_x_1 of { happy_var_1 -> + happyIn22 + ((happy_var_1, Nothing) + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_43 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_43 = happySpecReduce_2 18# happyReduction_43 +happyReduction_43 happy_x_2 + happy_x_1 + = case happyOut8 happy_x_1 of { happy_var_1 -> + case happyOut23 happy_x_2 of { happy_var_2 -> + happyIn22 + ((happy_var_1, (Just happy_var_2)) + )}} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_44 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_44 = happySpecReduce_2 19# happyReduction_44 +happyReduction_44 happy_x_2 + happy_x_1 + = case happyOut8 happy_x_2 of { happy_var_2 -> + happyIn23 + (case toCompass $ show happy_var_2 of + Just c -> Port Nothing (Just c) + Nothing -> Port (if show happy_var_2 == "_" then Nothing else (Just happy_var_2)) Nothing + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_45 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_45 = happyReduce 4# 19# happyReduction_45 +happyReduction_45 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut8 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_4 of { (TokenLabel happy_var_4) -> + happyIn23 + (Port (Just happy_var_2) (toCompass happy_var_4) + ) `HappyStk` happyRest}} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_46 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_46 = happySpecReduce_3 20# happyReduction_46 +happyReduction_46 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut7 happy_x_2 of { happy_var_2 -> + case happyOut11 happy_x_3 of { happy_var_3 -> + happyIn24 + (Subgraph happy_var_2 happy_var_3 + )}} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_47 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_47 = happySpecReduce_1 20# happyReduction_47 +happyReduction_47 happy_x_1 + = case happyOut11 happy_x_1 of { happy_var_1 -> + happyIn24 + (Subgraph Nothing happy_var_1 + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_48 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_48 = happySpecReduce_3 21# happyReduction_48 +happyReduction_48 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { (TokenOT happy_var_1) -> + case happyOut26 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { (TokenCT happy_var_3) -> + happyIn25 + (show happy_var_1 ++ (concat $ reverse happy_var_2) ++ show happy_var_3 + )}}} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_49 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_49 = happySpecReduce_2 22# happyReduction_49 +happyReduction_49 happy_x_2 + happy_x_1 + = case happyOut26 happy_x_1 of { happy_var_1 -> + case happyOut27 happy_x_2 of { happy_var_2 -> + happyIn26 + (happy_var_2 : happy_var_1 + )}} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_50 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_50 = happySpecReduce_0 22# happyReduction_50 +happyReduction_50 = happyIn26 + ([] + ) + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_51 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_51 = happySpecReduce_3 23# happyReduction_51 +happyReduction_51 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { (TokenOT happy_var_1) -> + case happyOut26 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { (TokenCT happy_var_3) -> + happyIn27 + (show happy_var_1 ++ (concat $ reverse happy_var_2) ++ show happy_var_3 + )}}} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_52 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_52 = happySpecReduce_1 23# happyReduction_52 +happyReduction_52 happy_x_1 + = case happyOutTok happy_x_1 of { (TokenProc happy_var_1) -> + happyIn27 + (show happy_var_1 + )} + +happyNewToken action sts stk + = lexer(\tk -> + let cont i = happyDoAction i tk action sts stk in + case tk of { + TokenEOF -> happyDoAction 22# tk action sts stk; + TokenGraph -> cont 1#; + TokenDigraph -> cont 2#; + TokenNode -> cont 3#; + TokenEdge -> cont 4#; + TokenSubgraph -> cont 5#; + TokenLabel happy_dollar_dollar -> cont 6#; + TokenQuotedLabel happy_dollar_dollar -> cont 7#; + TokenStrict -> cont 8#; + TokenArrow happy_dollar_dollar -> cont 9#; + TokenEQ -> cont 10#; + TokenOCB -> cont 11#; + TokenCCB -> cont 12#; + TokenOSB -> cont 13#; + TokenCSB -> cont 14#; + TokenCo -> cont 15#; + TokenSemiCo -> cont 16#; + TokenComma -> cont 17#; + TokenPlus -> cont 18#; + TokenCT happy_dollar_dollar -> cont 19#; + TokenOT happy_dollar_dollar -> cont 20#; + TokenProc happy_dollar_dollar -> cont 21#; + _ -> happyError' (tk, []) + }) + +happyError_ explist 22# tk = happyError' (tk, explist) +happyError_ explist _ tk = happyError' (tk, explist) + +happyThen :: () => P a -> (a -> P b) -> P b +happyThen = (thenE) +happyReturn :: () => a -> P a +happyReturn = (returnE) +#if __GLASGOW_HASKELL__ >= 710 +happyParse :: () => Happy_GHC_Exts.Int# -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) + +happyNewToken :: () => Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) + +happyDoAction :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) + +happyReduceArr :: () => Happy_Data_Array.Array Int (Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _)) + +#endif +happyThen1 :: () => P a -> (a -> P b) -> P b +happyThen1 = happyThen +happyReturn1 :: () => a -> P a +happyReturn1 = happyReturn +happyError' :: () => ((Token), [String]) -> P a +happyError' tk = (\(tokens, _) -> parseError tokens) tk +dot = happySomeParser where + happySomeParser = happyThen (happyParse 0#) (\x -> happyReturn (let {x' = happyOut4 x} in x')) + +happySeq = happyDontSeq + + +data Except a = Success a | Failure String +type P a = String -> Int -> Except a + +thenE :: P a -> (a -> P b) -> P b +thenE m k s l = + case m s l of + Success a -> k a s l + Failure e -> Failure e + +returnE :: a -> P a +returnE a s l = Success a + +failE :: String -> P a +failE e s l = Failure $ "Error on line " ++ show l ++ ": " ++ e + +catchE :: P a -> (String -> P a) -> P a +catchE m k s l = case m s l of + Success a -> Success a + Failure e -> k e s l +getLineNumber s l = Success l +parseError :: Token -> P a +parseError t = getLineNumber `thenE` \line -> failE $ "Parse error on line " ++ show line ++ "." + +data Token = + TokenGraph + | TokenDigraph + | TokenNode + | TokenEdge + | TokenSubgraph + | TokenStrict + | TokenLabel String + | TokenQuotedLabel String + | TokenXML String + | TokenCompass Compass + | TokenArrow Char + | TokenEQ + | TokenOCB + | TokenCCB + | TokenOSB + | TokenCSB + | TokenCo + | TokenSemiCo + | TokenComma + | TokenCT String + | TokenOT String + | TokenProc String + | TokenPlus + | TokenEOF + deriving (Eq) + +instance Show Token where + show tk = case tk of + TokenGraph -> "graph" + TokenDigraph -> "digraph" + TokenNode -> "node" + TokenEdge -> "edge" + TokenSubgraph -> "subgraph" + TokenStrict -> "strict" + TokenLabel label -> label + TokenQuotedLabel label -> label + TokenXML xml -> xml + TokenCompass compass -> show compass + TokenArrow c -> [c] + TokenEQ -> "=" + TokenOCB -> "{" + TokenCCB -> "]" + TokenOSB -> "[" + TokenCSB -> "]" + TokenCo -> ":" + TokenSemiCo -> ";" + TokenComma -> "," + TokenCT tag -> "" + TokenOT tag -> "<" ++ tag ++ ">" + TokenProc xml -> "" + TokenPlus -> "+" + TokenEOF -> "" + +-- | Parse a graph written in the DOT language. +parse s = case dot ('\n':s) 0 of -- A newline is added to treat '#' in the beginning of a line properly. + Success ast -> Right ast + Failure msg -> Left msg + +toCompass l = + case map toLower l of + "n" -> Just $ North + "ne" -> Just $ NorthEast + "e" -> Just $ East + "se" -> Just $ SouthEast + "s" -> Just $ South + "sw" -> Just $ SouthWest + "w" -> Just $ West + "nw" -> Just $ NorthWest + "c" -> Just $ Center + "_" -> Nothing + _ -> Nothing + +lexer :: (Token -> (P a)) -> (P a) +lexer cont str line = case dropWhile (\c -> c /= '\n' && isSpace c) str of + '\n':'#':s' -> let s'' = dropWhile (/= '\n') s' in lexer cont s'' (line + 1) + '\n':s' -> lexer cont s' (line +1) + ',':s' -> cont TokenComma s' line + ';':s' -> cont TokenSemiCo s' line + 's':'u':'b':'g':'r':'a':'p':'h':s' -> cont TokenSubgraph s' line + 'g':'r':'a':'p':'h':s' -> cont TokenGraph s' line + 'd':'i':'g':'r':'a':'p':'h':s' -> cont TokenDigraph s' line + 'e':'d':'g':'e':s' -> cont TokenEdge s' line + 'n':'o':'d':'e':s' -> cont TokenNode s' line + 's':'t':'r':'i':'c':'t':s' -> cont TokenStrict s' line + '{':s' -> cont TokenOCB s' line + '}':s' -> cont TokenCCB s' line + '[':s' -> cont TokenOSB s' line + ']':s' -> cont TokenCSB s' line + '+':s' -> cont TokenPlus s' line + '=':s' -> cont TokenEQ s' line + ':':s' -> cont TokenCo s' line + '-':'-':s' -> cont (TokenArrow '-') s' line + '-':'>':s' -> cont (TokenArrow '>') s' line + '/':'/':s' -> let s'' = dropWhile (/= '\n') s' in lexer cont s'' line + '/':'*':s' -> let (s'', line') = execState consumeComment (s', line) + in lexer cont s'' (line') + '"':s' -> let (qs, (s'', line')) = runState consumeQuotedString (s', line) + in case qs of + Right string -> cont (TokenQuotedLabel string) s'' line' + Left msg -> failE msg s' line' + '<':'/':s' -> let (tag, (s'', line')) = runState consumeTag (s', line) + in cont (TokenCT tag) (tail s'') line' + '<':'!':'-':'-':s' -> let (s'', line') = execState consumeXMLComment (s', line) + in lexer cont s'' line' + '<':'?':s' -> let (proc, (s'', line')) = runState consumeProcessing (s', line) + in cont (TokenProc proc) s'' line' + [] -> cont TokenEOF [] line + s' -> let (label, s'') = span (\x -> not $ isSpace x || x `elem` ";,{}[]=\"") s' + in if null label then failE ("Unexpected character: " ++ [head s'']) s' line + else cont (TokenLabel label) s'' line +{-# LINE 1 "templates/GenericTemplate.hs" #-} +-- $Id: GenericTemplate.hs,v 1.26 2005/01/14 14:47:22 simonmar Exp $ + + + + + + + + + + + + + +-- Do not remove this comment. Required to fix CPP parsing when using GCC and a clang-compiled alex. +#if __GLASGOW_HASKELL__ > 706 +#define LT(n,m) ((Happy_GHC_Exts.tagToEnum# (n Happy_GHC_Exts.<# m)) :: Bool) +#define GTE(n,m) ((Happy_GHC_Exts.tagToEnum# (n Happy_GHC_Exts.>=# m)) :: Bool) +#define EQ(n,m) ((Happy_GHC_Exts.tagToEnum# (n Happy_GHC_Exts.==# m)) :: Bool) +#else +#define LT(n,m) (n Happy_GHC_Exts.<# m) +#define GTE(n,m) (n Happy_GHC_Exts.>=# m) +#define EQ(n,m) (n Happy_GHC_Exts.==# m) +#endif + + + + + + + + + + + + + + + + + + + +data Happy_IntList = HappyCons Happy_GHC_Exts.Int# Happy_IntList + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +infixr 9 `HappyStk` +data HappyStk a = HappyStk a (HappyStk a) + +----------------------------------------------------------------------------- +-- starting the parse + +happyParse start_state = happyNewToken start_state notHappyAtAll notHappyAtAll + +----------------------------------------------------------------------------- +-- Accepting the parse + +-- If the current token is ERROR_TOK, it means we've just accepted a partial +-- parse (a %partial parser). We must ignore the saved token on the top of +-- the stack in this case. +happyAccept 0# tk st sts (_ `HappyStk` ans `HappyStk` _) = + happyReturn1 ans +happyAccept j tk st sts (HappyStk ans _) = + (happyTcHack j (happyTcHack st)) (happyReturn1 ans) + +----------------------------------------------------------------------------- +-- Arrays only: do the next action + + + +happyDoAction i tk st + = {- nothing -} + case action of + 0# -> {- nothing -} + happyFail (happyExpListPerState ((Happy_GHC_Exts.I# (st)) :: Int)) i tk st + -1# -> {- nothing -} + happyAccept i tk st + n | LT(n,(0# :: Happy_GHC_Exts.Int#)) -> {- nothing -} + (happyReduceArr Happy_Data_Array.! rule) i tk st + where rule = (Happy_GHC_Exts.I# ((Happy_GHC_Exts.negateInt# ((n Happy_GHC_Exts.+# (1# :: Happy_GHC_Exts.Int#)))))) + n -> {- nothing -} + happyShift new_state i tk st + where new_state = (n Happy_GHC_Exts.-# (1# :: Happy_GHC_Exts.Int#)) + where off = happyAdjustOffset (indexShortOffAddr happyActOffsets st) + off_i = (off Happy_GHC_Exts.+# i) + check = if GTE(off_i,(0# :: Happy_GHC_Exts.Int#)) + then EQ(indexShortOffAddr happyCheck off_i, i) + else False + action + | check = indexShortOffAddr happyTable off_i + | otherwise = indexShortOffAddr happyDefActions st + + + + +indexShortOffAddr (HappyA# arr) off = + Happy_GHC_Exts.narrow16Int# i + where + i = Happy_GHC_Exts.word2Int# (Happy_GHC_Exts.or# (Happy_GHC_Exts.uncheckedShiftL# high 8#) low) + high = Happy_GHC_Exts.int2Word# (Happy_GHC_Exts.ord# (Happy_GHC_Exts.indexCharOffAddr# arr (off' Happy_GHC_Exts.+# 1#))) + low = Happy_GHC_Exts.int2Word# (Happy_GHC_Exts.ord# (Happy_GHC_Exts.indexCharOffAddr# arr off')) + off' = off Happy_GHC_Exts.*# 2# + + + + +{-# INLINE happyLt #-} +happyLt x y = LT(x,y) + + +readArrayBit arr bit = + Bits.testBit (Happy_GHC_Exts.I# (indexShortOffAddr arr ((unbox_int bit) `Happy_GHC_Exts.iShiftRA#` 4#))) (bit `mod` 16) + where unbox_int (Happy_GHC_Exts.I# x) = x + + + + + + +data HappyAddr = HappyA# Happy_GHC_Exts.Addr# + + +----------------------------------------------------------------------------- +-- HappyState data type (not arrays) + + + + + + + + + + + + + +----------------------------------------------------------------------------- +-- Shifting a token + +happyShift new_state 0# tk st sts stk@(x `HappyStk` _) = + let i = (case Happy_GHC_Exts.unsafeCoerce# x of { (Happy_GHC_Exts.I# (i)) -> i }) in +-- trace "shifting the error token" $ + happyDoAction i tk new_state (HappyCons (st) (sts)) (stk) + +happyShift new_state i tk st sts stk = + happyNewToken new_state (HappyCons (st) (sts)) ((happyInTok (tk))`HappyStk`stk) + +-- happyReduce is specialised for the common cases. + +happySpecReduce_0 i fn 0# tk st sts stk + = happyFail [] 0# tk st sts stk +happySpecReduce_0 nt fn j tk st@((action)) sts stk + = happyGoto nt j tk st (HappyCons (st) (sts)) (fn `HappyStk` stk) + +happySpecReduce_1 i fn 0# tk st sts stk + = happyFail [] 0# tk st sts stk +happySpecReduce_1 nt fn j tk _ sts@((HappyCons (st@(action)) (_))) (v1`HappyStk`stk') + = let r = fn v1 in + happySeq r (happyGoto nt j tk st sts (r `HappyStk` stk')) + +happySpecReduce_2 i fn 0# tk st sts stk + = happyFail [] 0# tk st sts stk +happySpecReduce_2 nt fn j tk _ (HappyCons (_) (sts@((HappyCons (st@(action)) (_))))) (v1`HappyStk`v2`HappyStk`stk') + = let r = fn v1 v2 in + happySeq r (happyGoto nt j tk st sts (r `HappyStk` stk')) + +happySpecReduce_3 i fn 0# tk st sts stk + = happyFail [] 0# tk st sts stk +happySpecReduce_3 nt fn j tk _ (HappyCons (_) ((HappyCons (_) (sts@((HappyCons (st@(action)) (_))))))) (v1`HappyStk`v2`HappyStk`v3`HappyStk`stk') + = let r = fn v1 v2 v3 in + happySeq r (happyGoto nt j tk st sts (r `HappyStk` stk')) + +happyReduce k i fn 0# tk st sts stk + = happyFail [] 0# tk st sts stk +happyReduce k nt fn j tk st sts stk + = case happyDrop (k Happy_GHC_Exts.-# (1# :: Happy_GHC_Exts.Int#)) sts of + sts1@((HappyCons (st1@(action)) (_))) -> + let r = fn stk in -- it doesn't hurt to always seq here... + happyDoSeq r (happyGoto nt j tk st1 sts1 r) + +happyMonadReduce k nt fn 0# tk st sts stk + = happyFail [] 0# tk st sts stk +happyMonadReduce k nt fn j tk st sts stk = + case happyDrop k (HappyCons (st) (sts)) of + sts1@((HappyCons (st1@(action)) (_))) -> + let drop_stk = happyDropStk k stk in + happyThen1 (fn stk tk) (\r -> happyGoto nt j tk st1 sts1 (r `HappyStk` drop_stk)) + +happyMonad2Reduce k nt fn 0# tk st sts stk + = happyFail [] 0# tk st sts stk +happyMonad2Reduce k nt fn j tk st sts stk = + case happyDrop k (HappyCons (st) (sts)) of + sts1@((HappyCons (st1@(action)) (_))) -> + let drop_stk = happyDropStk k stk + + off = happyAdjustOffset (indexShortOffAddr happyGotoOffsets st1) + off_i = (off Happy_GHC_Exts.+# nt) + new_state = indexShortOffAddr happyTable off_i + + + + + in + happyThen1 (fn stk tk) (\r -> happyNewToken new_state sts1 (r `HappyStk` drop_stk)) + +happyDrop 0# l = l +happyDrop n (HappyCons (_) (t)) = happyDrop (n Happy_GHC_Exts.-# (1# :: Happy_GHC_Exts.Int#)) t + +happyDropStk 0# l = l +happyDropStk n (x `HappyStk` xs) = happyDropStk (n Happy_GHC_Exts.-# (1#::Happy_GHC_Exts.Int#)) xs + +----------------------------------------------------------------------------- +-- Moving to a new state after a reduction + + +happyGoto nt j tk st = + {- nothing -} + happyDoAction j tk new_state + where off = happyAdjustOffset (indexShortOffAddr happyGotoOffsets st) + off_i = (off Happy_GHC_Exts.+# nt) + new_state = indexShortOffAddr happyTable off_i + + + + +----------------------------------------------------------------------------- +-- Error recovery (ERROR_TOK is the error token) + +-- parse error if we are in recovery and we fail again +happyFail explist 0# tk old_st _ stk@(x `HappyStk` _) = + let i = (case Happy_GHC_Exts.unsafeCoerce# x of { (Happy_GHC_Exts.I# (i)) -> i }) in +-- trace "failing" $ + happyError_ explist i tk + +{- We don't need state discarding for our restricted implementation of + "error". In fact, it can cause some bogus parses, so I've disabled it + for now --SDM + +-- discard a state +happyFail ERROR_TOK tk old_st CONS(HAPPYSTATE(action),sts) + (saved_tok `HappyStk` _ `HappyStk` stk) = +-- trace ("discarding state, depth " ++ show (length stk)) $ + DO_ACTION(action,ERROR_TOK,tk,sts,(saved_tok`HappyStk`stk)) +-} + +-- Enter error recovery: generate an error token, +-- save the old token and carry on. +happyFail explist i tk (action) sts stk = +-- trace "entering error recovery" $ + happyDoAction 0# tk action sts ((Happy_GHC_Exts.unsafeCoerce# (Happy_GHC_Exts.I# (i))) `HappyStk` stk) + +-- Internal happy errors: + +notHappyAtAll :: a +notHappyAtAll = error "Internal Happy error\n" + +----------------------------------------------------------------------------- +-- Hack to get the typechecker to accept our action functions + + +happyTcHack :: Happy_GHC_Exts.Int# -> a -> a +happyTcHack x y = y +{-# INLINE happyTcHack #-} + + +----------------------------------------------------------------------------- +-- Seq-ing. If the --strict flag is given, then Happy emits +-- happySeq = happyDoSeq +-- otherwise it emits +-- happySeq = happyDontSeq + +happyDoSeq, happyDontSeq :: a -> b -> b +happyDoSeq a b = a `seq` b +happyDontSeq a b = b + +----------------------------------------------------------------------------- +-- Don't inline any functions from the template. GHC has a nasty habit +-- of deciding to inline happyGoto everywhere, which increases the size of +-- the generated parser quite a bit. + + +{-# NOINLINE happyDoAction #-} +{-# NOINLINE happyTable #-} +{-# NOINLINE happyCheck #-} +{-# NOINLINE happyActOffsets #-} +{-# NOINLINE happyGotoOffsets #-} +{-# NOINLINE happyDefActions #-} + +{-# NOINLINE happyShift #-} +{-# NOINLINE happySpecReduce_0 #-} +{-# NOINLINE happySpecReduce_1 #-} +{-# NOINLINE happySpecReduce_2 #-} +{-# NOINLINE happySpecReduce_3 #-} +{-# NOINLINE happyReduce #-} +{-# NOINLINE happyMonadReduce #-} +{-# NOINLINE happyGoto #-} +{-# NOINLINE happyFail #-} + +-- end of Happy Template. diff --git a/dist/build/test-pretty/test-pretty-tmp/Language/Dot/Parser.hs b/dist/build/test-pretty/test-pretty-tmp/Language/Dot/Parser.hs new file mode 100644 --- /dev/null +++ b/dist/build/test-pretty/test-pretty-tmp/Language/Dot/Parser.hs @@ -0,0 +1,1403 @@ +{-# OPTIONS_GHC -w #-} +{-# OPTIONS -XMagicHash -XBangPatterns -XTypeSynonymInstances -XFlexibleInstances -cpp #-} +#if __GLASGOW_HASKELL__ >= 710 +{-# OPTIONS_GHC -XPartialTypeSignatures #-} +#endif +-------------------------------------------------------------------- +-- | +-- Module : Language.Dot.Parser +-- License : GPL-3 +-- +-- Maintainer : Marcelo Garlet Millani +-- Stability : experimental +-- Portability : portable +-- +-- Parsing function and abstract syntax tree for the [DOT language] +-- (https://www.graphviz.org/doc/info/lang.html). +-- +-- The parser is implemented using `happy`, and so is fairly fast. +-------------------------------------------------------------------- + +module Language.Dot.Parser + (parse + , GraphType(..) + , Name(..) + , Statement(..) + , Subgraph(..) + , Port(..) + , Compass(..) + ) where + +import HappyDot.Parser +import Language.Dot.Graph + +import Data.Char +import Control.Monad.Trans.State + +import qualified Debug.Trace as D +import qualified Data.Array as Happy_Data_Array +import qualified Data.Bits as Bits +import qualified GHC.Exts as Happy_GHC_Exts +import Control.Applicative(Applicative(..)) +import Control.Monad (ap) + +-- parser produced by Happy Version 1.19.12 + +newtype HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27 = HappyAbsSyn HappyAny +#if __GLASGOW_HASKELL__ >= 607 +type HappyAny = Happy_GHC_Exts.Any +#else +type HappyAny = forall a . a +#endif +happyIn4 :: t4 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn4 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn4 #-} +happyOut4 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t4 +happyOut4 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut4 #-} +happyIn5 :: t5 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn5 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn5 #-} +happyOut5 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t5 +happyOut5 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut5 #-} +happyIn6 :: t6 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn6 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn6 #-} +happyOut6 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t6 +happyOut6 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut6 #-} +happyIn7 :: t7 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn7 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn7 #-} +happyOut7 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t7 +happyOut7 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut7 #-} +happyIn8 :: t8 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn8 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn8 #-} +happyOut8 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t8 +happyOut8 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut8 #-} +happyIn9 :: t9 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn9 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn9 #-} +happyOut9 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t9 +happyOut9 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut9 #-} +happyIn10 :: t10 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn10 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn10 #-} +happyOut10 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t10 +happyOut10 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut10 #-} +happyIn11 :: t11 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn11 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn11 #-} +happyOut11 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t11 +happyOut11 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut11 #-} +happyIn12 :: t12 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn12 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn12 #-} +happyOut12 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t12 +happyOut12 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut12 #-} +happyIn13 :: t13 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn13 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn13 #-} +happyOut13 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t13 +happyOut13 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut13 #-} +happyIn14 :: t14 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn14 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn14 #-} +happyOut14 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t14 +happyOut14 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut14 #-} +happyIn15 :: t15 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn15 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn15 #-} +happyOut15 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t15 +happyOut15 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut15 #-} +happyIn16 :: t16 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn16 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn16 #-} +happyOut16 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t16 +happyOut16 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut16 #-} +happyIn17 :: t17 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn17 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn17 #-} +happyOut17 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t17 +happyOut17 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut17 #-} +happyIn18 :: t18 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn18 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn18 #-} +happyOut18 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t18 +happyOut18 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut18 #-} +happyIn19 :: t19 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn19 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn19 #-} +happyOut19 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t19 +happyOut19 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut19 #-} +happyIn20 :: t20 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn20 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn20 #-} +happyOut20 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t20 +happyOut20 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut20 #-} +happyIn21 :: t21 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn21 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn21 #-} +happyOut21 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t21 +happyOut21 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut21 #-} +happyIn22 :: t22 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn22 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn22 #-} +happyOut22 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t22 +happyOut22 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut22 #-} +happyIn23 :: t23 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn23 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn23 #-} +happyOut23 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t23 +happyOut23 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut23 #-} +happyIn24 :: t24 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn24 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn24 #-} +happyOut24 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t24 +happyOut24 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut24 #-} +happyIn25 :: t25 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn25 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn25 #-} +happyOut25 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t25 +happyOut25 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut25 #-} +happyIn26 :: t26 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn26 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn26 #-} +happyOut26 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t26 +happyOut26 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut26 #-} +happyIn27 :: t27 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn27 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn27 #-} +happyOut27 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t27 +happyOut27 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut27 #-} +happyInTok :: (Token) -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyInTok x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyInTok #-} +happyOutTok :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> (Token) +happyOutTok x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOutTok #-} + + +happyExpList :: HappyAddr +happyExpList = HappyA# "\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x3e\x06\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x03\x00\x00\x00\x80\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\xe0\x08\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x00\x08\x00\x00\x00\xc0\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x01\x02\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x30\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00"# + +{-# NOINLINE happyExpListPerState #-} +happyExpListPerState st = + token_strs_expected + where token_strs = ["error","%dummy","%start_dot","Graph","Strictness","GraphType","Name_empty","Name","Quoted_string","Quoted_sum","Stmt_list","Stmt_list_aux","Stmt_sep","Stmt","Attr_stmt","Attr_list","Attr_list_aux","A_list","Edge_stmt","EdgeRHS","Node_stmt","Node","Port","Subgraph","Xml","XmlList","XmlElement","graph","digraph","node","edge","subgraph","label","qlabel","strict","arrow","'='","'{'","'}'","'['","']'","':'","';'","','","'+'","xmlClose","xmlOpen","xmlProc","%eof"] + bit_start = st * 49 + bit_end = (st + 1) * 49 + read_bit = readArrayBit happyExpList + bits = map read_bit [bit_start..bit_end - 1] + bits_indexed = zip bits [0..48] + token_strs_expected = concatMap f bits_indexed + f (False, _) = [] + f (True, nr) = [token_strs !! nr] + +happyActOffsets :: HappyAddr +happyActOffsets = HappyA# "\xf9\xff\xf9\xff\x23\x00\x00\x00\xed\xff\x0d\x00\x00\x00\x00\x00\x07\x00\x00\x00\x00\x00\x09\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4f\x00\x36\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x52\x00\x1c\x00\x00\x00\x38\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x0d\x00\x00\x00\x47\x00\x00\x00\x34\x00\x00\x00\x00\x00\x56\x00\x46\x00\x00\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0d\x00\x0d\x00\x00\x00\x65\x00\x00\x00\x00\x00\x49\x00\x67\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x50\x00\x00\x00\x00\x00\x55\x00\x00\x00\x0d\x00\x00\x00\x6b\x00\x0d\x00\x00\x00\x00\x00"# + +happyGotoOffsets :: HappyAddr +happyGotoOffsets = HappyA# "\x68\x00\x76\x00\x77\x00\x00\x00\x00\x00\x0b\x00\x00\x00\x00\x00\x71\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x63\x00\x00\x00\x00\x00\x73\x00\x18\x00\x00\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x6c\x00\x6e\x00\x00\x00\x74\x00\x00\x00\x00\x00\x00\x00\x4c\x00\x72\x00\x5e\x00\x60\x00\x62\x00\x13\x00\x00\x00\x75\x00\x00\x00\x00\x00\x00\x00\x00\x00\x64\x00\x2a\x00\x00\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x05\x00\x32\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2e\x00\x78\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x70\x00\x00\x00\x7b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x35\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00"# + +happyAdjustOffset :: Happy_GHC_Exts.Int# -> Happy_GHC_Exts.Int# +happyAdjustOffset off = off + +happyDefActions :: HappyAddr +happyDefActions = HappyA# "\xfc\xff\x00\x00\x00\x00\xfd\xff\x00\x00\xf8\xff\xfb\xff\xfa\xff\x00\x00\xf9\xff\xf6\xff\xf4\xff\xf5\xff\xf7\xff\xf3\xff\xcd\xff\x00\x00\x00\x00\xfe\xff\xef\xff\x00\x00\xf2\xff\xce\xff\xcf\xff\xcd\xff\xcb\xff\x00\x00\xd5\xff\xd0\xff\xec\xff\xeb\xff\xe9\xff\xea\xff\xe1\xff\xe7\xff\xe1\xff\xe1\xff\xe1\xff\xf8\xff\xf1\xff\x00\x00\xe5\xff\xe3\xff\xe6\xff\xe4\xff\xe1\xff\x00\x00\xd6\xff\xe1\xff\xf0\xff\xee\xff\xed\xff\xd4\xff\x00\x00\x00\x00\xcc\xff\xd3\xff\xe8\xff\xde\xff\x00\x00\xd5\xff\xda\xff\xd9\xff\xd8\xff\xd7\xff\xdd\xff\xdf\xff\xd1\xff\xec\xff\xdc\xff\xdb\xff\x00\x00\xd2\xff\x00\x00\xe2\xff\x00\x00\x00\x00\xe0\xff"# + +happyCheck :: HappyAddr +happyCheck = HappyA# "\xff\xff\x08\x00\x01\x00\x16\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x04\x00\x05\x00\x06\x00\x0b\x00\x0c\x00\x03\x00\x04\x00\x05\x00\x06\x00\x0b\x00\x06\x00\x07\x00\x14\x00\x03\x00\x04\x00\x05\x00\x06\x00\x15\x00\x12\x00\x04\x00\x05\x00\x06\x00\x07\x00\x15\x00\x14\x00\x0a\x00\x0b\x00\x01\x00\x02\x00\x0a\x00\x0f\x00\x15\x00\x11\x00\x12\x00\x0f\x00\x14\x00\x15\x00\x04\x00\x05\x00\x06\x00\x07\x00\x04\x00\x05\x00\x06\x00\x07\x00\x04\x00\x05\x00\x06\x00\x04\x00\x05\x00\x06\x00\x12\x00\x07\x00\x14\x00\x15\x00\x12\x00\x0d\x00\x14\x00\x15\x00\x04\x00\x05\x00\x06\x00\x15\x00\x10\x00\x11\x00\x15\x00\x05\x00\x06\x00\x07\x00\x05\x00\x06\x00\x07\x00\x0b\x00\x0b\x00\x09\x00\x0b\x00\x15\x00\x10\x00\x11\x00\x0c\x00\x0d\x00\x14\x00\x06\x00\x10\x00\x14\x00\x0e\x00\x09\x00\x10\x00\x11\x00\x13\x00\x14\x00\x15\x00\x13\x00\x14\x00\x15\x00\x00\x00\x01\x00\x0c\x00\x0d\x00\x0c\x00\x0d\x00\x0c\x00\x0d\x00\x0c\x00\x0d\x00\x0c\x00\x0d\x00\x0f\x00\x0a\x00\x0f\x00\x01\x00\x07\x00\x02\x00\x17\x00\x08\x00\x07\x00\x09\x00\x0e\x00\x16\x00\x16\x00\x13\x00\x10\x00\x17\x00\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x13\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"# + +happyTable :: HappyAddr +happyTable = HappyA# "\x00\x00\x04\x00\x24\x00\xff\xff\x25\x00\x26\x00\x27\x00\x0e\x00\x0f\x00\x39\x00\x0a\x00\x0b\x00\x14\x00\x28\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x14\x00\x0e\x00\x0f\x00\x10\x00\x28\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x12\x00\x1b\x00\x0a\x00\x0b\x00\x1c\x00\x0c\x00\x10\x00\x1d\x00\x1e\x00\x07\x00\x08\x00\x36\x00\x1f\x00\x0c\x00\x20\x00\x21\x00\x37\x00\x22\x00\x0c\x00\x3c\x00\x0a\x00\x0b\x00\x1c\x00\x3c\x00\x0a\x00\x0b\x00\x1c\x00\x38\x00\x0a\x00\x0b\x00\x4b\x00\x0a\x00\x0b\x00\x3d\x00\x16\x00\x3e\x00\x0c\x00\x45\x00\x43\x00\x46\x00\x0c\x00\x4d\x00\x0a\x00\x0b\x00\x0c\x00\x33\x00\x34\x00\x0c\x00\x27\x00\x0e\x00\x0f\x00\x27\x00\x0e\x00\x0f\x00\x14\x00\x14\x00\x2f\x00\x14\x00\x0c\x00\x40\x00\x41\x00\x2f\x00\x2a\x00\x10\x00\x49\x00\x30\x00\x10\x00\x4b\x00\x3c\x00\x33\x00\x34\x00\x18\x00\x19\x00\x1a\x00\x38\x00\x19\x00\x1a\x00\x04\x00\x02\x00\x2c\x00\x2a\x00\x2b\x00\x2a\x00\x29\x00\x2a\x00\x41\x00\x2a\x00\x3a\x00\x2a\x00\x48\x00\x4d\x00\x37\x00\x02\x00\x12\x00\x05\x00\x16\x00\x14\x00\x43\x00\x31\x00\x44\x00\x10\x00\x1a\x00\x34\x00\x2d\x00\x16\x00\x49\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x34\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"# + +happyReduceArr = Happy_Data_Array.array (1, 52) [ + (1 , happyReduce_1), + (2 , happyReduce_2), + (3 , happyReduce_3), + (4 , happyReduce_4), + (5 , happyReduce_5), + (6 , happyReduce_6), + (7 , happyReduce_7), + (8 , happyReduce_8), + (9 , happyReduce_9), + (10 , happyReduce_10), + (11 , happyReduce_11), + (12 , happyReduce_12), + (13 , happyReduce_13), + (14 , happyReduce_14), + (15 , happyReduce_15), + (16 , happyReduce_16), + (17 , happyReduce_17), + (18 , happyReduce_18), + (19 , happyReduce_19), + (20 , happyReduce_20), + (21 , happyReduce_21), + (22 , happyReduce_22), + (23 , happyReduce_23), + (24 , happyReduce_24), + (25 , happyReduce_25), + (26 , happyReduce_26), + (27 , happyReduce_27), + (28 , happyReduce_28), + (29 , happyReduce_29), + (30 , happyReduce_30), + (31 , happyReduce_31), + (32 , happyReduce_32), + (33 , happyReduce_33), + (34 , happyReduce_34), + (35 , happyReduce_35), + (36 , happyReduce_36), + (37 , happyReduce_37), + (38 , happyReduce_38), + (39 , happyReduce_39), + (40 , happyReduce_40), + (41 , happyReduce_41), + (42 , happyReduce_42), + (43 , happyReduce_43), + (44 , happyReduce_44), + (45 , happyReduce_45), + (46 , happyReduce_46), + (47 , happyReduce_47), + (48 , happyReduce_48), + (49 , happyReduce_49), + (50 , happyReduce_50), + (51 , happyReduce_51), + (52 , happyReduce_52) + ] + +happy_n_terms = 23 :: Int +happy_n_nonterms = 24 :: Int + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_1 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_1 = happyReduce 4# 0# happyReduction_1 +happyReduction_1 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut5 happy_x_1 of { happy_var_1 -> + case happyOut6 happy_x_2 of { happy_var_2 -> + case happyOut7 happy_x_3 of { happy_var_3 -> + case happyOut11 happy_x_4 of { happy_var_4 -> + happyIn4 + ((happy_var_1, happy_var_2, happy_var_3, happy_var_4) + ) `HappyStk` happyRest}}}} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_2 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_2 = happySpecReduce_1 1# happyReduction_2 +happyReduction_2 happy_x_1 + = happyIn5 + (True + ) + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_3 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_3 = happySpecReduce_0 1# happyReduction_3 +happyReduction_3 = happyIn5 + (False + ) + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_4 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_4 = happySpecReduce_1 2# happyReduction_4 +happyReduction_4 happy_x_1 + = happyIn6 + (Graph + ) + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_5 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_5 = happySpecReduce_1 2# happyReduction_5 +happyReduction_5 happy_x_1 + = happyIn6 + (Digraph + ) + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_6 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_6 = happySpecReduce_1 3# happyReduction_6 +happyReduction_6 happy_x_1 + = case happyOut8 happy_x_1 of { happy_var_1 -> + happyIn7 + (Just happy_var_1 + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_7 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_7 = happySpecReduce_0 3# happyReduction_7 +happyReduction_7 = happyIn7 + (Nothing + ) + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_8 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_8 = happySpecReduce_1 4# happyReduction_8 +happyReduction_8 happy_x_1 + = case happyOutTok happy_x_1 of { (TokenLabel happy_var_1) -> + happyIn8 + (StringID happy_var_1 + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_9 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_9 = happySpecReduce_1 4# happyReduction_9 +happyReduction_9 happy_x_1 + = case happyOut9 happy_x_1 of { happy_var_1 -> + happyIn8 + (StringID happy_var_1 + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_10 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_10 = happySpecReduce_1 4# happyReduction_10 +happyReduction_10 happy_x_1 + = case happyOut25 happy_x_1 of { happy_var_1 -> + happyIn8 + (XMLID happy_var_1 + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_11 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_11 = happySpecReduce_1 5# happyReduction_11 +happyReduction_11 happy_x_1 + = case happyOut10 happy_x_1 of { happy_var_1 -> + happyIn9 + (concat $ reverse happy_var_1 + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_12 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_12 = happySpecReduce_1 6# happyReduction_12 +happyReduction_12 happy_x_1 + = case happyOutTok happy_x_1 of { (TokenQuotedLabel happy_var_1) -> + happyIn10 + ([happy_var_1] + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_13 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_13 = happySpecReduce_3 6# happyReduction_13 +happyReduction_13 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut10 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_3 of { (TokenQuotedLabel happy_var_3) -> + happyIn10 + (happy_var_3 : happy_var_1 + )}} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_14 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_14 = happySpecReduce_3 7# happyReduction_14 +happyReduction_14 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut12 happy_x_2 of { happy_var_2 -> + happyIn11 + (reverse happy_var_2 + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_15 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_15 = happySpecReduce_3 8# happyReduction_15 +happyReduction_15 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut12 happy_x_1 of { happy_var_1 -> + case happyOut14 happy_x_2 of { happy_var_2 -> + happyIn12 + (happy_var_2 : happy_var_1 + )}} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_16 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_16 = happySpecReduce_0 8# happyReduction_16 +happyReduction_16 = happyIn12 + ([] + ) + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_17 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_17 = happySpecReduce_1 9# happyReduction_17 +happyReduction_17 happy_x_1 + = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn13 + (Just happy_var_1 + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_18 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_18 = happySpecReduce_1 9# happyReduction_18 +happyReduction_18 happy_x_1 + = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn13 + (Just happy_var_1 + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_19 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_19 = happySpecReduce_0 9# happyReduction_19 +happyReduction_19 = happyIn13 + (Nothing + ) + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_20 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_20 = happySpecReduce_1 10# happyReduction_20 +happyReduction_20 happy_x_1 + = case happyOut15 happy_x_1 of { happy_var_1 -> + happyIn14 + (happy_var_1 + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_21 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_21 = happySpecReduce_1 10# happyReduction_21 +happyReduction_21 happy_x_1 + = case happyOut21 happy_x_1 of { happy_var_1 -> + happyIn14 + (happy_var_1 + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_22 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_22 = happySpecReduce_1 10# happyReduction_22 +happyReduction_22 happy_x_1 + = case happyOut19 happy_x_1 of { happy_var_1 -> + happyIn14 + (happy_var_1 + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_23 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_23 = happySpecReduce_3 10# happyReduction_23 +happyReduction_23 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut8 happy_x_1 of { happy_var_1 -> + case happyOut8 happy_x_3 of { happy_var_3 -> + happyIn14 + (AttributeStatement ( happy_var_1, happy_var_3) + )}} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_24 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_24 = happySpecReduce_1 10# happyReduction_24 +happyReduction_24 happy_x_1 + = case happyOut24 happy_x_1 of { happy_var_1 -> + happyIn14 + (SubgraphStatement happy_var_1 + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_25 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_25 = happySpecReduce_2 11# happyReduction_25 +happyReduction_25 happy_x_2 + happy_x_1 + = case happyOut16 happy_x_2 of { happy_var_2 -> + happyIn15 + (NodeAttribute happy_var_2 + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_26 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_26 = happySpecReduce_2 11# happyReduction_26 +happyReduction_26 happy_x_2 + happy_x_1 + = case happyOut16 happy_x_2 of { happy_var_2 -> + happyIn15 + (EdgeAttribute happy_var_2 + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_27 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_27 = happySpecReduce_2 11# happyReduction_27 +happyReduction_27 happy_x_2 + happy_x_1 + = case happyOut16 happy_x_2 of { happy_var_2 -> + happyIn15 + (GraphAttribute happy_var_2 + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_28 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_28 = happySpecReduce_1 12# happyReduction_28 +happyReduction_28 happy_x_1 + = case happyOut17 happy_x_1 of { happy_var_1 -> + happyIn16 + (reverse happy_var_1 + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_29 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_29 = happyReduce 4# 13# happyReduction_29 +happyReduction_29 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut17 happy_x_1 of { happy_var_1 -> + case happyOut18 happy_x_3 of { happy_var_3 -> + happyIn17 + (happy_var_3 ++ happy_var_1 + ) `HappyStk` happyRest}} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_30 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_30 = happySpecReduce_0 13# happyReduction_30 +happyReduction_30 = happyIn17 + ([] + ) + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_31 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_31 = happyReduce 5# 14# happyReduction_31 +happyReduction_31 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut18 happy_x_1 of { happy_var_1 -> + case happyOut8 happy_x_3 of { happy_var_3 -> + case happyOut8 happy_x_5 of { happy_var_5 -> + happyIn18 + (( happy_var_3, happy_var_5) : happy_var_1 + ) `HappyStk` happyRest}}} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_32 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_32 = happySpecReduce_0 14# happyReduction_32 +happyReduction_32 = happyIn18 + ([] + ) + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_33 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_33 = happySpecReduce_3 15# happyReduction_33 +happyReduction_33 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut22 happy_x_1 of { happy_var_1 -> + case happyOut20 happy_x_2 of { happy_var_2 -> + case happyOut16 happy_x_3 of { happy_var_3 -> + happyIn19 + (EdgeStatement ((uncurry NodeRef happy_var_1):(reverse happy_var_2)) happy_var_3 + )}}} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_34 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_34 = happySpecReduce_3 15# happyReduction_34 +happyReduction_34 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut24 happy_x_1 of { happy_var_1 -> + case happyOut20 happy_x_2 of { happy_var_2 -> + case happyOut16 happy_x_3 of { happy_var_3 -> + happyIn19 + (EdgeStatement (happy_var_1:(reverse happy_var_2)) happy_var_3 + )}}} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_35 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_35 = happySpecReduce_3 16# happyReduction_35 +happyReduction_35 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut20 happy_x_1 of { happy_var_1 -> + case happyOut22 happy_x_3 of { happy_var_3 -> + happyIn20 + ((uncurry NodeRef happy_var_3) : happy_var_1 + )}} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_36 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_36 = happySpecReduce_3 16# happyReduction_36 +happyReduction_36 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut20 happy_x_1 of { happy_var_1 -> + case happyOut24 happy_x_3 of { happy_var_3 -> + happyIn20 + (happy_var_3 : happy_var_1 + )}} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_37 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_37 = happySpecReduce_2 16# happyReduction_37 +happyReduction_37 happy_x_2 + happy_x_1 + = case happyOut22 happy_x_2 of { happy_var_2 -> + happyIn20 + ([uncurry NodeRef happy_var_2] + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_38 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_38 = happySpecReduce_2 16# happyReduction_38 +happyReduction_38 happy_x_2 + happy_x_1 + = case happyOut24 happy_x_2 of { happy_var_2 -> + happyIn20 + ([happy_var_2] + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_39 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_39 = happyMonadReduce 2# 16# happyReduction_39 +happyReduction_39 (happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen ((( getLineNumber `thenE` \line -> failE $ "Unfinished edge statement.")) + ) (\r -> happyReturn (happyIn20 r)) + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_40 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_40 = happyMonadReduce 2# 16# happyReduction_40 +happyReduction_40 (happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen ((( getLineNumber `thenE` \line -> failE $ "Unfinished edge statement.")) + ) (\r -> happyReturn (happyIn20 r)) + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_41 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_41 = happySpecReduce_2 17# happyReduction_41 +happyReduction_41 happy_x_2 + happy_x_1 + = case happyOut22 happy_x_1 of { happy_var_1 -> + case happyOut16 happy_x_2 of { happy_var_2 -> + happyIn21 + ((uncurry NodeStatement) happy_var_1 happy_var_2 + )}} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_42 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_42 = happySpecReduce_1 18# happyReduction_42 +happyReduction_42 happy_x_1 + = case happyOut8 happy_x_1 of { happy_var_1 -> + happyIn22 + ((happy_var_1, Nothing) + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_43 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_43 = happySpecReduce_2 18# happyReduction_43 +happyReduction_43 happy_x_2 + happy_x_1 + = case happyOut8 happy_x_1 of { happy_var_1 -> + case happyOut23 happy_x_2 of { happy_var_2 -> + happyIn22 + ((happy_var_1, (Just happy_var_2)) + )}} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_44 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_44 = happySpecReduce_2 19# happyReduction_44 +happyReduction_44 happy_x_2 + happy_x_1 + = case happyOut8 happy_x_2 of { happy_var_2 -> + happyIn23 + (case toCompass $ show happy_var_2 of + Just c -> Port Nothing (Just c) + Nothing -> Port (if show happy_var_2 == "_" then Nothing else (Just happy_var_2)) Nothing + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_45 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_45 = happyReduce 4# 19# happyReduction_45 +happyReduction_45 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut8 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_4 of { (TokenLabel happy_var_4) -> + happyIn23 + (Port (Just happy_var_2) (toCompass happy_var_4) + ) `HappyStk` happyRest}} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_46 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_46 = happySpecReduce_3 20# happyReduction_46 +happyReduction_46 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut7 happy_x_2 of { happy_var_2 -> + case happyOut11 happy_x_3 of { happy_var_3 -> + happyIn24 + (Subgraph happy_var_2 happy_var_3 + )}} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_47 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_47 = happySpecReduce_1 20# happyReduction_47 +happyReduction_47 happy_x_1 + = case happyOut11 happy_x_1 of { happy_var_1 -> + happyIn24 + (Subgraph Nothing happy_var_1 + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_48 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_48 = happySpecReduce_3 21# happyReduction_48 +happyReduction_48 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { (TokenOT happy_var_1) -> + case happyOut26 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { (TokenCT happy_var_3) -> + happyIn25 + (show happy_var_1 ++ (concat $ reverse happy_var_2) ++ show happy_var_3 + )}}} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_49 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_49 = happySpecReduce_2 22# happyReduction_49 +happyReduction_49 happy_x_2 + happy_x_1 + = case happyOut26 happy_x_1 of { happy_var_1 -> + case happyOut27 happy_x_2 of { happy_var_2 -> + happyIn26 + (happy_var_2 : happy_var_1 + )}} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_50 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_50 = happySpecReduce_0 22# happyReduction_50 +happyReduction_50 = happyIn26 + ([] + ) + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_51 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_51 = happySpecReduce_3 23# happyReduction_51 +happyReduction_51 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { (TokenOT happy_var_1) -> + case happyOut26 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { (TokenCT happy_var_3) -> + happyIn27 + (show happy_var_1 ++ (concat $ reverse happy_var_2) ++ show happy_var_3 + )}}} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_52 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_52 = happySpecReduce_1 23# happyReduction_52 +happyReduction_52 happy_x_1 + = case happyOutTok happy_x_1 of { (TokenProc happy_var_1) -> + happyIn27 + (show happy_var_1 + )} + +happyNewToken action sts stk + = lexer(\tk -> + let cont i = happyDoAction i tk action sts stk in + case tk of { + TokenEOF -> happyDoAction 22# tk action sts stk; + TokenGraph -> cont 1#; + TokenDigraph -> cont 2#; + TokenNode -> cont 3#; + TokenEdge -> cont 4#; + TokenSubgraph -> cont 5#; + TokenLabel happy_dollar_dollar -> cont 6#; + TokenQuotedLabel happy_dollar_dollar -> cont 7#; + TokenStrict -> cont 8#; + TokenArrow happy_dollar_dollar -> cont 9#; + TokenEQ -> cont 10#; + TokenOCB -> cont 11#; + TokenCCB -> cont 12#; + TokenOSB -> cont 13#; + TokenCSB -> cont 14#; + TokenCo -> cont 15#; + TokenSemiCo -> cont 16#; + TokenComma -> cont 17#; + TokenPlus -> cont 18#; + TokenCT happy_dollar_dollar -> cont 19#; + TokenOT happy_dollar_dollar -> cont 20#; + TokenProc happy_dollar_dollar -> cont 21#; + _ -> happyError' (tk, []) + }) + +happyError_ explist 22# tk = happyError' (tk, explist) +happyError_ explist _ tk = happyError' (tk, explist) + +happyThen :: () => P a -> (a -> P b) -> P b +happyThen = (thenE) +happyReturn :: () => a -> P a +happyReturn = (returnE) +#if __GLASGOW_HASKELL__ >= 710 +happyParse :: () => Happy_GHC_Exts.Int# -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) + +happyNewToken :: () => Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) + +happyDoAction :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) + +happyReduceArr :: () => Happy_Data_Array.Array Int (Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _)) + +#endif +happyThen1 :: () => P a -> (a -> P b) -> P b +happyThen1 = happyThen +happyReturn1 :: () => a -> P a +happyReturn1 = happyReturn +happyError' :: () => ((Token), [String]) -> P a +happyError' tk = (\(tokens, _) -> parseError tokens) tk +dot = happySomeParser where + happySomeParser = happyThen (happyParse 0#) (\x -> happyReturn (let {x' = happyOut4 x} in x')) + +happySeq = happyDontSeq + + +data Except a = Success a | Failure String +type P a = String -> Int -> Except a + +thenE :: P a -> (a -> P b) -> P b +thenE m k s l = + case m s l of + Success a -> k a s l + Failure e -> Failure e + +returnE :: a -> P a +returnE a s l = Success a + +failE :: String -> P a +failE e s l = Failure $ "Error on line " ++ show l ++ ": " ++ e + +catchE :: P a -> (String -> P a) -> P a +catchE m k s l = case m s l of + Success a -> Success a + Failure e -> k e s l +getLineNumber s l = Success l +parseError :: Token -> P a +parseError t = getLineNumber `thenE` \line -> failE $ "Parse error on line " ++ show line ++ "." + +data Token = + TokenGraph + | TokenDigraph + | TokenNode + | TokenEdge + | TokenSubgraph + | TokenStrict + | TokenLabel String + | TokenQuotedLabel String + | TokenXML String + | TokenCompass Compass + | TokenArrow Char + | TokenEQ + | TokenOCB + | TokenCCB + | TokenOSB + | TokenCSB + | TokenCo + | TokenSemiCo + | TokenComma + | TokenCT String + | TokenOT String + | TokenProc String + | TokenPlus + | TokenEOF + deriving (Eq) + +instance Show Token where + show tk = case tk of + TokenGraph -> "graph" + TokenDigraph -> "digraph" + TokenNode -> "node" + TokenEdge -> "edge" + TokenSubgraph -> "subgraph" + TokenStrict -> "strict" + TokenLabel label -> label + TokenQuotedLabel label -> label + TokenXML xml -> xml + TokenCompass compass -> show compass + TokenArrow c -> [c] + TokenEQ -> "=" + TokenOCB -> "{" + TokenCCB -> "]" + TokenOSB -> "[" + TokenCSB -> "]" + TokenCo -> ":" + TokenSemiCo -> ";" + TokenComma -> "," + TokenCT tag -> "" + TokenOT tag -> "<" ++ tag ++ ">" + TokenProc xml -> "" + TokenPlus -> "+" + TokenEOF -> "" + +-- | Parse a graph written in the DOT language. +parse s = case dot ('\n':s) 0 of -- A newline is added to treat '#' in the beginning of a line properly. + Success ast -> Right ast + Failure msg -> Left msg + +toCompass l = + case map toLower l of + "n" -> Just $ North + "ne" -> Just $ NorthEast + "e" -> Just $ East + "se" -> Just $ SouthEast + "s" -> Just $ South + "sw" -> Just $ SouthWest + "w" -> Just $ West + "nw" -> Just $ NorthWest + "c" -> Just $ Center + "_" -> Nothing + _ -> Nothing + +lexer :: (Token -> (P a)) -> (P a) +lexer cont str line = case dropWhile (\c -> c /= '\n' && isSpace c) str of + '\n':'#':s' -> let s'' = dropWhile (/= '\n') s' in lexer cont s'' (line + 1) + '\n':s' -> lexer cont s' (line +1) + ',':s' -> cont TokenComma s' line + ';':s' -> cont TokenSemiCo s' line + 's':'u':'b':'g':'r':'a':'p':'h':s' -> cont TokenSubgraph s' line + 'g':'r':'a':'p':'h':s' -> cont TokenGraph s' line + 'd':'i':'g':'r':'a':'p':'h':s' -> cont TokenDigraph s' line + 'e':'d':'g':'e':s' -> cont TokenEdge s' line + 'n':'o':'d':'e':s' -> cont TokenNode s' line + 's':'t':'r':'i':'c':'t':s' -> cont TokenStrict s' line + '{':s' -> cont TokenOCB s' line + '}':s' -> cont TokenCCB s' line + '[':s' -> cont TokenOSB s' line + ']':s' -> cont TokenCSB s' line + '+':s' -> cont TokenPlus s' line + '=':s' -> cont TokenEQ s' line + ':':s' -> cont TokenCo s' line + '-':'-':s' -> cont (TokenArrow '-') s' line + '-':'>':s' -> cont (TokenArrow '>') s' line + '/':'/':s' -> let s'' = dropWhile (/= '\n') s' in lexer cont s'' line + '/':'*':s' -> let (s'', line') = execState consumeComment (s', line) + in lexer cont s'' (line') + '"':s' -> let (qs, (s'', line')) = runState consumeQuotedString (s', line) + in case qs of + Right string -> cont (TokenQuotedLabel string) s'' line' + Left msg -> failE msg s' line' + '<':'/':s' -> let (tag, (s'', line')) = runState consumeTag (s', line) + in cont (TokenCT tag) (tail s'') line' + '<':'!':'-':'-':s' -> let (s'', line') = execState consumeXMLComment (s', line) + in lexer cont s'' line' + '<':'?':s' -> let (proc, (s'', line')) = runState consumeProcessing (s', line) + in cont (TokenProc proc) s'' line' + [] -> cont TokenEOF [] line + s' -> let (label, s'') = span (\x -> not $ isSpace x || x `elem` ";,{}[]=\"") s' + in if null label then failE ("Unexpected character: " ++ [head s'']) s' line + else cont (TokenLabel label) s'' line +{-# LINE 1 "templates/GenericTemplate.hs" #-} +-- $Id: GenericTemplate.hs,v 1.26 2005/01/14 14:47:22 simonmar Exp $ + + + + + + + + + + + + + +-- Do not remove this comment. Required to fix CPP parsing when using GCC and a clang-compiled alex. +#if __GLASGOW_HASKELL__ > 706 +#define LT(n,m) ((Happy_GHC_Exts.tagToEnum# (n Happy_GHC_Exts.<# m)) :: Bool) +#define GTE(n,m) ((Happy_GHC_Exts.tagToEnum# (n Happy_GHC_Exts.>=# m)) :: Bool) +#define EQ(n,m) ((Happy_GHC_Exts.tagToEnum# (n Happy_GHC_Exts.==# m)) :: Bool) +#else +#define LT(n,m) (n Happy_GHC_Exts.<# m) +#define GTE(n,m) (n Happy_GHC_Exts.>=# m) +#define EQ(n,m) (n Happy_GHC_Exts.==# m) +#endif + + + + + + + + + + + + + + + + + + + +data Happy_IntList = HappyCons Happy_GHC_Exts.Int# Happy_IntList + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +infixr 9 `HappyStk` +data HappyStk a = HappyStk a (HappyStk a) + +----------------------------------------------------------------------------- +-- starting the parse + +happyParse start_state = happyNewToken start_state notHappyAtAll notHappyAtAll + +----------------------------------------------------------------------------- +-- Accepting the parse + +-- If the current token is ERROR_TOK, it means we've just accepted a partial +-- parse (a %partial parser). We must ignore the saved token on the top of +-- the stack in this case. +happyAccept 0# tk st sts (_ `HappyStk` ans `HappyStk` _) = + happyReturn1 ans +happyAccept j tk st sts (HappyStk ans _) = + (happyTcHack j (happyTcHack st)) (happyReturn1 ans) + +----------------------------------------------------------------------------- +-- Arrays only: do the next action + + + +happyDoAction i tk st + = {- nothing -} + case action of + 0# -> {- nothing -} + happyFail (happyExpListPerState ((Happy_GHC_Exts.I# (st)) :: Int)) i tk st + -1# -> {- nothing -} + happyAccept i tk st + n | LT(n,(0# :: Happy_GHC_Exts.Int#)) -> {- nothing -} + (happyReduceArr Happy_Data_Array.! rule) i tk st + where rule = (Happy_GHC_Exts.I# ((Happy_GHC_Exts.negateInt# ((n Happy_GHC_Exts.+# (1# :: Happy_GHC_Exts.Int#)))))) + n -> {- nothing -} + happyShift new_state i tk st + where new_state = (n Happy_GHC_Exts.-# (1# :: Happy_GHC_Exts.Int#)) + where off = happyAdjustOffset (indexShortOffAddr happyActOffsets st) + off_i = (off Happy_GHC_Exts.+# i) + check = if GTE(off_i,(0# :: Happy_GHC_Exts.Int#)) + then EQ(indexShortOffAddr happyCheck off_i, i) + else False + action + | check = indexShortOffAddr happyTable off_i + | otherwise = indexShortOffAddr happyDefActions st + + + + +indexShortOffAddr (HappyA# arr) off = + Happy_GHC_Exts.narrow16Int# i + where + i = Happy_GHC_Exts.word2Int# (Happy_GHC_Exts.or# (Happy_GHC_Exts.uncheckedShiftL# high 8#) low) + high = Happy_GHC_Exts.int2Word# (Happy_GHC_Exts.ord# (Happy_GHC_Exts.indexCharOffAddr# arr (off' Happy_GHC_Exts.+# 1#))) + low = Happy_GHC_Exts.int2Word# (Happy_GHC_Exts.ord# (Happy_GHC_Exts.indexCharOffAddr# arr off')) + off' = off Happy_GHC_Exts.*# 2# + + + + +{-# INLINE happyLt #-} +happyLt x y = LT(x,y) + + +readArrayBit arr bit = + Bits.testBit (Happy_GHC_Exts.I# (indexShortOffAddr arr ((unbox_int bit) `Happy_GHC_Exts.iShiftRA#` 4#))) (bit `mod` 16) + where unbox_int (Happy_GHC_Exts.I# x) = x + + + + + + +data HappyAddr = HappyA# Happy_GHC_Exts.Addr# + + +----------------------------------------------------------------------------- +-- HappyState data type (not arrays) + + + + + + + + + + + + + +----------------------------------------------------------------------------- +-- Shifting a token + +happyShift new_state 0# tk st sts stk@(x `HappyStk` _) = + let i = (case Happy_GHC_Exts.unsafeCoerce# x of { (Happy_GHC_Exts.I# (i)) -> i }) in +-- trace "shifting the error token" $ + happyDoAction i tk new_state (HappyCons (st) (sts)) (stk) + +happyShift new_state i tk st sts stk = + happyNewToken new_state (HappyCons (st) (sts)) ((happyInTok (tk))`HappyStk`stk) + +-- happyReduce is specialised for the common cases. + +happySpecReduce_0 i fn 0# tk st sts stk + = happyFail [] 0# tk st sts stk +happySpecReduce_0 nt fn j tk st@((action)) sts stk + = happyGoto nt j tk st (HappyCons (st) (sts)) (fn `HappyStk` stk) + +happySpecReduce_1 i fn 0# tk st sts stk + = happyFail [] 0# tk st sts stk +happySpecReduce_1 nt fn j tk _ sts@((HappyCons (st@(action)) (_))) (v1`HappyStk`stk') + = let r = fn v1 in + happySeq r (happyGoto nt j tk st sts (r `HappyStk` stk')) + +happySpecReduce_2 i fn 0# tk st sts stk + = happyFail [] 0# tk st sts stk +happySpecReduce_2 nt fn j tk _ (HappyCons (_) (sts@((HappyCons (st@(action)) (_))))) (v1`HappyStk`v2`HappyStk`stk') + = let r = fn v1 v2 in + happySeq r (happyGoto nt j tk st sts (r `HappyStk` stk')) + +happySpecReduce_3 i fn 0# tk st sts stk + = happyFail [] 0# tk st sts stk +happySpecReduce_3 nt fn j tk _ (HappyCons (_) ((HappyCons (_) (sts@((HappyCons (st@(action)) (_))))))) (v1`HappyStk`v2`HappyStk`v3`HappyStk`stk') + = let r = fn v1 v2 v3 in + happySeq r (happyGoto nt j tk st sts (r `HappyStk` stk')) + +happyReduce k i fn 0# tk st sts stk + = happyFail [] 0# tk st sts stk +happyReduce k nt fn j tk st sts stk + = case happyDrop (k Happy_GHC_Exts.-# (1# :: Happy_GHC_Exts.Int#)) sts of + sts1@((HappyCons (st1@(action)) (_))) -> + let r = fn stk in -- it doesn't hurt to always seq here... + happyDoSeq r (happyGoto nt j tk st1 sts1 r) + +happyMonadReduce k nt fn 0# tk st sts stk + = happyFail [] 0# tk st sts stk +happyMonadReduce k nt fn j tk st sts stk = + case happyDrop k (HappyCons (st) (sts)) of + sts1@((HappyCons (st1@(action)) (_))) -> + let drop_stk = happyDropStk k stk in + happyThen1 (fn stk tk) (\r -> happyGoto nt j tk st1 sts1 (r `HappyStk` drop_stk)) + +happyMonad2Reduce k nt fn 0# tk st sts stk + = happyFail [] 0# tk st sts stk +happyMonad2Reduce k nt fn j tk st sts stk = + case happyDrop k (HappyCons (st) (sts)) of + sts1@((HappyCons (st1@(action)) (_))) -> + let drop_stk = happyDropStk k stk + + off = happyAdjustOffset (indexShortOffAddr happyGotoOffsets st1) + off_i = (off Happy_GHC_Exts.+# nt) + new_state = indexShortOffAddr happyTable off_i + + + + + in + happyThen1 (fn stk tk) (\r -> happyNewToken new_state sts1 (r `HappyStk` drop_stk)) + +happyDrop 0# l = l +happyDrop n (HappyCons (_) (t)) = happyDrop (n Happy_GHC_Exts.-# (1# :: Happy_GHC_Exts.Int#)) t + +happyDropStk 0# l = l +happyDropStk n (x `HappyStk` xs) = happyDropStk (n Happy_GHC_Exts.-# (1#::Happy_GHC_Exts.Int#)) xs + +----------------------------------------------------------------------------- +-- Moving to a new state after a reduction + + +happyGoto nt j tk st = + {- nothing -} + happyDoAction j tk new_state + where off = happyAdjustOffset (indexShortOffAddr happyGotoOffsets st) + off_i = (off Happy_GHC_Exts.+# nt) + new_state = indexShortOffAddr happyTable off_i + + + + +----------------------------------------------------------------------------- +-- Error recovery (ERROR_TOK is the error token) + +-- parse error if we are in recovery and we fail again +happyFail explist 0# tk old_st _ stk@(x `HappyStk` _) = + let i = (case Happy_GHC_Exts.unsafeCoerce# x of { (Happy_GHC_Exts.I# (i)) -> i }) in +-- trace "failing" $ + happyError_ explist i tk + +{- We don't need state discarding for our restricted implementation of + "error". In fact, it can cause some bogus parses, so I've disabled it + for now --SDM + +-- discard a state +happyFail ERROR_TOK tk old_st CONS(HAPPYSTATE(action),sts) + (saved_tok `HappyStk` _ `HappyStk` stk) = +-- trace ("discarding state, depth " ++ show (length stk)) $ + DO_ACTION(action,ERROR_TOK,tk,sts,(saved_tok`HappyStk`stk)) +-} + +-- Enter error recovery: generate an error token, +-- save the old token and carry on. +happyFail explist i tk (action) sts stk = +-- trace "entering error recovery" $ + happyDoAction 0# tk action sts ((Happy_GHC_Exts.unsafeCoerce# (Happy_GHC_Exts.I# (i))) `HappyStk` stk) + +-- Internal happy errors: + +notHappyAtAll :: a +notHappyAtAll = error "Internal Happy error\n" + +----------------------------------------------------------------------------- +-- Hack to get the typechecker to accept our action functions + + +happyTcHack :: Happy_GHC_Exts.Int# -> a -> a +happyTcHack x y = y +{-# INLINE happyTcHack #-} + + +----------------------------------------------------------------------------- +-- Seq-ing. If the --strict flag is given, then Happy emits +-- happySeq = happyDoSeq +-- otherwise it emits +-- happySeq = happyDontSeq + +happyDoSeq, happyDontSeq :: a -> b -> b +happyDoSeq a b = a `seq` b +happyDontSeq a b = b + +----------------------------------------------------------------------------- +-- Don't inline any functions from the template. GHC has a nasty habit +-- of deciding to inline happyGoto everywhere, which increases the size of +-- the generated parser quite a bit. + + +{-# NOINLINE happyDoAction #-} +{-# NOINLINE happyTable #-} +{-# NOINLINE happyCheck #-} +{-# NOINLINE happyActOffsets #-} +{-# NOINLINE happyGotoOffsets #-} +{-# NOINLINE happyDefActions #-} + +{-# NOINLINE happyShift #-} +{-# NOINLINE happySpecReduce_0 #-} +{-# NOINLINE happySpecReduce_1 #-} +{-# NOINLINE happySpecReduce_2 #-} +{-# NOINLINE happySpecReduce_3 #-} +{-# NOINLINE happyReduce #-} +{-# NOINLINE happyMonadReduce #-} +{-# NOINLINE happyGoto #-} +{-# NOINLINE happyFail #-} + +-- end of Happy Template. diff --git a/dist/build/test-utils/test-utils-tmp/Language/Dot/Parser.hs b/dist/build/test-utils/test-utils-tmp/Language/Dot/Parser.hs new file mode 100644 --- /dev/null +++ b/dist/build/test-utils/test-utils-tmp/Language/Dot/Parser.hs @@ -0,0 +1,1403 @@ +{-# OPTIONS_GHC -w #-} +{-# OPTIONS -XMagicHash -XBangPatterns -XTypeSynonymInstances -XFlexibleInstances -cpp #-} +#if __GLASGOW_HASKELL__ >= 710 +{-# OPTIONS_GHC -XPartialTypeSignatures #-} +#endif +-------------------------------------------------------------------- +-- | +-- Module : Language.Dot.Parser +-- License : GPL-3 +-- +-- Maintainer : Marcelo Garlet Millani +-- Stability : experimental +-- Portability : portable +-- +-- Parsing function and abstract syntax tree for the [DOT language] +-- (https://www.graphviz.org/doc/info/lang.html). +-- +-- The parser is implemented using `happy`, and so is fairly fast. +-------------------------------------------------------------------- + +module Language.Dot.Parser + (parse + , GraphType(..) + , Name(..) + , Statement(..) + , Subgraph(..) + , Port(..) + , Compass(..) + ) where + +import HappyDot.Parser +import Language.Dot.Graph + +import Data.Char +import Control.Monad.Trans.State + +import qualified Debug.Trace as D +import qualified Data.Array as Happy_Data_Array +import qualified Data.Bits as Bits +import qualified GHC.Exts as Happy_GHC_Exts +import Control.Applicative(Applicative(..)) +import Control.Monad (ap) + +-- parser produced by Happy Version 1.19.12 + +newtype HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27 = HappyAbsSyn HappyAny +#if __GLASGOW_HASKELL__ >= 607 +type HappyAny = Happy_GHC_Exts.Any +#else +type HappyAny = forall a . a +#endif +happyIn4 :: t4 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn4 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn4 #-} +happyOut4 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t4 +happyOut4 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut4 #-} +happyIn5 :: t5 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn5 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn5 #-} +happyOut5 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t5 +happyOut5 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut5 #-} +happyIn6 :: t6 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn6 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn6 #-} +happyOut6 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t6 +happyOut6 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut6 #-} +happyIn7 :: t7 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn7 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn7 #-} +happyOut7 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t7 +happyOut7 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut7 #-} +happyIn8 :: t8 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn8 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn8 #-} +happyOut8 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t8 +happyOut8 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut8 #-} +happyIn9 :: t9 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn9 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn9 #-} +happyOut9 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t9 +happyOut9 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut9 #-} +happyIn10 :: t10 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn10 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn10 #-} +happyOut10 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t10 +happyOut10 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut10 #-} +happyIn11 :: t11 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn11 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn11 #-} +happyOut11 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t11 +happyOut11 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut11 #-} +happyIn12 :: t12 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn12 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn12 #-} +happyOut12 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t12 +happyOut12 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut12 #-} +happyIn13 :: t13 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn13 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn13 #-} +happyOut13 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t13 +happyOut13 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut13 #-} +happyIn14 :: t14 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn14 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn14 #-} +happyOut14 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t14 +happyOut14 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut14 #-} +happyIn15 :: t15 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn15 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn15 #-} +happyOut15 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t15 +happyOut15 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut15 #-} +happyIn16 :: t16 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn16 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn16 #-} +happyOut16 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t16 +happyOut16 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut16 #-} +happyIn17 :: t17 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn17 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn17 #-} +happyOut17 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t17 +happyOut17 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut17 #-} +happyIn18 :: t18 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn18 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn18 #-} +happyOut18 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t18 +happyOut18 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut18 #-} +happyIn19 :: t19 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn19 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn19 #-} +happyOut19 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t19 +happyOut19 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut19 #-} +happyIn20 :: t20 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn20 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn20 #-} +happyOut20 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t20 +happyOut20 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut20 #-} +happyIn21 :: t21 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn21 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn21 #-} +happyOut21 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t21 +happyOut21 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut21 #-} +happyIn22 :: t22 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn22 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn22 #-} +happyOut22 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t22 +happyOut22 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut22 #-} +happyIn23 :: t23 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn23 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn23 #-} +happyOut23 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t23 +happyOut23 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut23 #-} +happyIn24 :: t24 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn24 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn24 #-} +happyOut24 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t24 +happyOut24 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut24 #-} +happyIn25 :: t25 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn25 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn25 #-} +happyOut25 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t25 +happyOut25 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut25 #-} +happyIn26 :: t26 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn26 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn26 #-} +happyOut26 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t26 +happyOut26 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut26 #-} +happyIn27 :: t27 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyIn27 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn27 #-} +happyOut27 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> t27 +happyOut27 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut27 #-} +happyInTok :: (Token) -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) +happyInTok x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyInTok #-} +happyOutTok :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27) -> (Token) +happyOutTok x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOutTok #-} + + +happyExpList :: HappyAddr +happyExpList = HappyA# "\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x3e\x06\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x03\x00\x00\x00\x80\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\xe0\x08\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x00\x08\x00\x00\x00\xc0\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x01\x02\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x30\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00"# + +{-# NOINLINE happyExpListPerState #-} +happyExpListPerState st = + token_strs_expected + where token_strs = ["error","%dummy","%start_dot","Graph","Strictness","GraphType","Name_empty","Name","Quoted_string","Quoted_sum","Stmt_list","Stmt_list_aux","Stmt_sep","Stmt","Attr_stmt","Attr_list","Attr_list_aux","A_list","Edge_stmt","EdgeRHS","Node_stmt","Node","Port","Subgraph","Xml","XmlList","XmlElement","graph","digraph","node","edge","subgraph","label","qlabel","strict","arrow","'='","'{'","'}'","'['","']'","':'","';'","','","'+'","xmlClose","xmlOpen","xmlProc","%eof"] + bit_start = st * 49 + bit_end = (st + 1) * 49 + read_bit = readArrayBit happyExpList + bits = map read_bit [bit_start..bit_end - 1] + bits_indexed = zip bits [0..48] + token_strs_expected = concatMap f bits_indexed + f (False, _) = [] + f (True, nr) = [token_strs !! nr] + +happyActOffsets :: HappyAddr +happyActOffsets = HappyA# "\xf9\xff\xf9\xff\x23\x00\x00\x00\xed\xff\x0d\x00\x00\x00\x00\x00\x07\x00\x00\x00\x00\x00\x09\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4f\x00\x36\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x52\x00\x1c\x00\x00\x00\x38\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x0d\x00\x00\x00\x47\x00\x00\x00\x34\x00\x00\x00\x00\x00\x56\x00\x46\x00\x00\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0d\x00\x0d\x00\x00\x00\x65\x00\x00\x00\x00\x00\x49\x00\x67\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x50\x00\x00\x00\x00\x00\x55\x00\x00\x00\x0d\x00\x00\x00\x6b\x00\x0d\x00\x00\x00\x00\x00"# + +happyGotoOffsets :: HappyAddr +happyGotoOffsets = HappyA# "\x68\x00\x76\x00\x77\x00\x00\x00\x00\x00\x0b\x00\x00\x00\x00\x00\x71\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x63\x00\x00\x00\x00\x00\x73\x00\x18\x00\x00\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x6c\x00\x6e\x00\x00\x00\x74\x00\x00\x00\x00\x00\x00\x00\x4c\x00\x72\x00\x5e\x00\x60\x00\x62\x00\x13\x00\x00\x00\x75\x00\x00\x00\x00\x00\x00\x00\x00\x00\x64\x00\x2a\x00\x00\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x05\x00\x32\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2e\x00\x78\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x70\x00\x00\x00\x7b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x35\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00"# + +happyAdjustOffset :: Happy_GHC_Exts.Int# -> Happy_GHC_Exts.Int# +happyAdjustOffset off = off + +happyDefActions :: HappyAddr +happyDefActions = HappyA# "\xfc\xff\x00\x00\x00\x00\xfd\xff\x00\x00\xf8\xff\xfb\xff\xfa\xff\x00\x00\xf9\xff\xf6\xff\xf4\xff\xf5\xff\xf7\xff\xf3\xff\xcd\xff\x00\x00\x00\x00\xfe\xff\xef\xff\x00\x00\xf2\xff\xce\xff\xcf\xff\xcd\xff\xcb\xff\x00\x00\xd5\xff\xd0\xff\xec\xff\xeb\xff\xe9\xff\xea\xff\xe1\xff\xe7\xff\xe1\xff\xe1\xff\xe1\xff\xf8\xff\xf1\xff\x00\x00\xe5\xff\xe3\xff\xe6\xff\xe4\xff\xe1\xff\x00\x00\xd6\xff\xe1\xff\xf0\xff\xee\xff\xed\xff\xd4\xff\x00\x00\x00\x00\xcc\xff\xd3\xff\xe8\xff\xde\xff\x00\x00\xd5\xff\xda\xff\xd9\xff\xd8\xff\xd7\xff\xdd\xff\xdf\xff\xd1\xff\xec\xff\xdc\xff\xdb\xff\x00\x00\xd2\xff\x00\x00\xe2\xff\x00\x00\x00\x00\xe0\xff"# + +happyCheck :: HappyAddr +happyCheck = HappyA# "\xff\xff\x08\x00\x01\x00\x16\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x04\x00\x05\x00\x06\x00\x0b\x00\x0c\x00\x03\x00\x04\x00\x05\x00\x06\x00\x0b\x00\x06\x00\x07\x00\x14\x00\x03\x00\x04\x00\x05\x00\x06\x00\x15\x00\x12\x00\x04\x00\x05\x00\x06\x00\x07\x00\x15\x00\x14\x00\x0a\x00\x0b\x00\x01\x00\x02\x00\x0a\x00\x0f\x00\x15\x00\x11\x00\x12\x00\x0f\x00\x14\x00\x15\x00\x04\x00\x05\x00\x06\x00\x07\x00\x04\x00\x05\x00\x06\x00\x07\x00\x04\x00\x05\x00\x06\x00\x04\x00\x05\x00\x06\x00\x12\x00\x07\x00\x14\x00\x15\x00\x12\x00\x0d\x00\x14\x00\x15\x00\x04\x00\x05\x00\x06\x00\x15\x00\x10\x00\x11\x00\x15\x00\x05\x00\x06\x00\x07\x00\x05\x00\x06\x00\x07\x00\x0b\x00\x0b\x00\x09\x00\x0b\x00\x15\x00\x10\x00\x11\x00\x0c\x00\x0d\x00\x14\x00\x06\x00\x10\x00\x14\x00\x0e\x00\x09\x00\x10\x00\x11\x00\x13\x00\x14\x00\x15\x00\x13\x00\x14\x00\x15\x00\x00\x00\x01\x00\x0c\x00\x0d\x00\x0c\x00\x0d\x00\x0c\x00\x0d\x00\x0c\x00\x0d\x00\x0c\x00\x0d\x00\x0f\x00\x0a\x00\x0f\x00\x01\x00\x07\x00\x02\x00\x17\x00\x08\x00\x07\x00\x09\x00\x0e\x00\x16\x00\x16\x00\x13\x00\x10\x00\x17\x00\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x13\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"# + +happyTable :: HappyAddr +happyTable = HappyA# "\x00\x00\x04\x00\x24\x00\xff\xff\x25\x00\x26\x00\x27\x00\x0e\x00\x0f\x00\x39\x00\x0a\x00\x0b\x00\x14\x00\x28\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x14\x00\x0e\x00\x0f\x00\x10\x00\x28\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x12\x00\x1b\x00\x0a\x00\x0b\x00\x1c\x00\x0c\x00\x10\x00\x1d\x00\x1e\x00\x07\x00\x08\x00\x36\x00\x1f\x00\x0c\x00\x20\x00\x21\x00\x37\x00\x22\x00\x0c\x00\x3c\x00\x0a\x00\x0b\x00\x1c\x00\x3c\x00\x0a\x00\x0b\x00\x1c\x00\x38\x00\x0a\x00\x0b\x00\x4b\x00\x0a\x00\x0b\x00\x3d\x00\x16\x00\x3e\x00\x0c\x00\x45\x00\x43\x00\x46\x00\x0c\x00\x4d\x00\x0a\x00\x0b\x00\x0c\x00\x33\x00\x34\x00\x0c\x00\x27\x00\x0e\x00\x0f\x00\x27\x00\x0e\x00\x0f\x00\x14\x00\x14\x00\x2f\x00\x14\x00\x0c\x00\x40\x00\x41\x00\x2f\x00\x2a\x00\x10\x00\x49\x00\x30\x00\x10\x00\x4b\x00\x3c\x00\x33\x00\x34\x00\x18\x00\x19\x00\x1a\x00\x38\x00\x19\x00\x1a\x00\x04\x00\x02\x00\x2c\x00\x2a\x00\x2b\x00\x2a\x00\x29\x00\x2a\x00\x41\x00\x2a\x00\x3a\x00\x2a\x00\x48\x00\x4d\x00\x37\x00\x02\x00\x12\x00\x05\x00\x16\x00\x14\x00\x43\x00\x31\x00\x44\x00\x10\x00\x1a\x00\x34\x00\x2d\x00\x16\x00\x49\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x34\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"# + +happyReduceArr = Happy_Data_Array.array (1, 52) [ + (1 , happyReduce_1), + (2 , happyReduce_2), + (3 , happyReduce_3), + (4 , happyReduce_4), + (5 , happyReduce_5), + (6 , happyReduce_6), + (7 , happyReduce_7), + (8 , happyReduce_8), + (9 , happyReduce_9), + (10 , happyReduce_10), + (11 , happyReduce_11), + (12 , happyReduce_12), + (13 , happyReduce_13), + (14 , happyReduce_14), + (15 , happyReduce_15), + (16 , happyReduce_16), + (17 , happyReduce_17), + (18 , happyReduce_18), + (19 , happyReduce_19), + (20 , happyReduce_20), + (21 , happyReduce_21), + (22 , happyReduce_22), + (23 , happyReduce_23), + (24 , happyReduce_24), + (25 , happyReduce_25), + (26 , happyReduce_26), + (27 , happyReduce_27), + (28 , happyReduce_28), + (29 , happyReduce_29), + (30 , happyReduce_30), + (31 , happyReduce_31), + (32 , happyReduce_32), + (33 , happyReduce_33), + (34 , happyReduce_34), + (35 , happyReduce_35), + (36 , happyReduce_36), + (37 , happyReduce_37), + (38 , happyReduce_38), + (39 , happyReduce_39), + (40 , happyReduce_40), + (41 , happyReduce_41), + (42 , happyReduce_42), + (43 , happyReduce_43), + (44 , happyReduce_44), + (45 , happyReduce_45), + (46 , happyReduce_46), + (47 , happyReduce_47), + (48 , happyReduce_48), + (49 , happyReduce_49), + (50 , happyReduce_50), + (51 , happyReduce_51), + (52 , happyReduce_52) + ] + +happy_n_terms = 23 :: Int +happy_n_nonterms = 24 :: Int + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_1 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_1 = happyReduce 4# 0# happyReduction_1 +happyReduction_1 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut5 happy_x_1 of { happy_var_1 -> + case happyOut6 happy_x_2 of { happy_var_2 -> + case happyOut7 happy_x_3 of { happy_var_3 -> + case happyOut11 happy_x_4 of { happy_var_4 -> + happyIn4 + ((happy_var_1, happy_var_2, happy_var_3, happy_var_4) + ) `HappyStk` happyRest}}}} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_2 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_2 = happySpecReduce_1 1# happyReduction_2 +happyReduction_2 happy_x_1 + = happyIn5 + (True + ) + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_3 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_3 = happySpecReduce_0 1# happyReduction_3 +happyReduction_3 = happyIn5 + (False + ) + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_4 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_4 = happySpecReduce_1 2# happyReduction_4 +happyReduction_4 happy_x_1 + = happyIn6 + (Graph + ) + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_5 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_5 = happySpecReduce_1 2# happyReduction_5 +happyReduction_5 happy_x_1 + = happyIn6 + (Digraph + ) + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_6 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_6 = happySpecReduce_1 3# happyReduction_6 +happyReduction_6 happy_x_1 + = case happyOut8 happy_x_1 of { happy_var_1 -> + happyIn7 + (Just happy_var_1 + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_7 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_7 = happySpecReduce_0 3# happyReduction_7 +happyReduction_7 = happyIn7 + (Nothing + ) + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_8 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_8 = happySpecReduce_1 4# happyReduction_8 +happyReduction_8 happy_x_1 + = case happyOutTok happy_x_1 of { (TokenLabel happy_var_1) -> + happyIn8 + (StringID happy_var_1 + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_9 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_9 = happySpecReduce_1 4# happyReduction_9 +happyReduction_9 happy_x_1 + = case happyOut9 happy_x_1 of { happy_var_1 -> + happyIn8 + (StringID happy_var_1 + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_10 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_10 = happySpecReduce_1 4# happyReduction_10 +happyReduction_10 happy_x_1 + = case happyOut25 happy_x_1 of { happy_var_1 -> + happyIn8 + (XMLID happy_var_1 + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_11 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_11 = happySpecReduce_1 5# happyReduction_11 +happyReduction_11 happy_x_1 + = case happyOut10 happy_x_1 of { happy_var_1 -> + happyIn9 + (concat $ reverse happy_var_1 + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_12 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_12 = happySpecReduce_1 6# happyReduction_12 +happyReduction_12 happy_x_1 + = case happyOutTok happy_x_1 of { (TokenQuotedLabel happy_var_1) -> + happyIn10 + ([happy_var_1] + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_13 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_13 = happySpecReduce_3 6# happyReduction_13 +happyReduction_13 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut10 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_3 of { (TokenQuotedLabel happy_var_3) -> + happyIn10 + (happy_var_3 : happy_var_1 + )}} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_14 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_14 = happySpecReduce_3 7# happyReduction_14 +happyReduction_14 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut12 happy_x_2 of { happy_var_2 -> + happyIn11 + (reverse happy_var_2 + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_15 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_15 = happySpecReduce_3 8# happyReduction_15 +happyReduction_15 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut12 happy_x_1 of { happy_var_1 -> + case happyOut14 happy_x_2 of { happy_var_2 -> + happyIn12 + (happy_var_2 : happy_var_1 + )}} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_16 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_16 = happySpecReduce_0 8# happyReduction_16 +happyReduction_16 = happyIn12 + ([] + ) + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_17 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_17 = happySpecReduce_1 9# happyReduction_17 +happyReduction_17 happy_x_1 + = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn13 + (Just happy_var_1 + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_18 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_18 = happySpecReduce_1 9# happyReduction_18 +happyReduction_18 happy_x_1 + = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn13 + (Just happy_var_1 + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_19 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_19 = happySpecReduce_0 9# happyReduction_19 +happyReduction_19 = happyIn13 + (Nothing + ) + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_20 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_20 = happySpecReduce_1 10# happyReduction_20 +happyReduction_20 happy_x_1 + = case happyOut15 happy_x_1 of { happy_var_1 -> + happyIn14 + (happy_var_1 + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_21 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_21 = happySpecReduce_1 10# happyReduction_21 +happyReduction_21 happy_x_1 + = case happyOut21 happy_x_1 of { happy_var_1 -> + happyIn14 + (happy_var_1 + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_22 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_22 = happySpecReduce_1 10# happyReduction_22 +happyReduction_22 happy_x_1 + = case happyOut19 happy_x_1 of { happy_var_1 -> + happyIn14 + (happy_var_1 + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_23 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_23 = happySpecReduce_3 10# happyReduction_23 +happyReduction_23 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut8 happy_x_1 of { happy_var_1 -> + case happyOut8 happy_x_3 of { happy_var_3 -> + happyIn14 + (AttributeStatement ( happy_var_1, happy_var_3) + )}} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_24 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_24 = happySpecReduce_1 10# happyReduction_24 +happyReduction_24 happy_x_1 + = case happyOut24 happy_x_1 of { happy_var_1 -> + happyIn14 + (SubgraphStatement happy_var_1 + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_25 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_25 = happySpecReduce_2 11# happyReduction_25 +happyReduction_25 happy_x_2 + happy_x_1 + = case happyOut16 happy_x_2 of { happy_var_2 -> + happyIn15 + (NodeAttribute happy_var_2 + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_26 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_26 = happySpecReduce_2 11# happyReduction_26 +happyReduction_26 happy_x_2 + happy_x_1 + = case happyOut16 happy_x_2 of { happy_var_2 -> + happyIn15 + (EdgeAttribute happy_var_2 + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_27 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_27 = happySpecReduce_2 11# happyReduction_27 +happyReduction_27 happy_x_2 + happy_x_1 + = case happyOut16 happy_x_2 of { happy_var_2 -> + happyIn15 + (GraphAttribute happy_var_2 + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_28 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_28 = happySpecReduce_1 12# happyReduction_28 +happyReduction_28 happy_x_1 + = case happyOut17 happy_x_1 of { happy_var_1 -> + happyIn16 + (reverse happy_var_1 + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_29 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_29 = happyReduce 4# 13# happyReduction_29 +happyReduction_29 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut17 happy_x_1 of { happy_var_1 -> + case happyOut18 happy_x_3 of { happy_var_3 -> + happyIn17 + (happy_var_3 ++ happy_var_1 + ) `HappyStk` happyRest}} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_30 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_30 = happySpecReduce_0 13# happyReduction_30 +happyReduction_30 = happyIn17 + ([] + ) + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_31 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_31 = happyReduce 5# 14# happyReduction_31 +happyReduction_31 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut18 happy_x_1 of { happy_var_1 -> + case happyOut8 happy_x_3 of { happy_var_3 -> + case happyOut8 happy_x_5 of { happy_var_5 -> + happyIn18 + (( happy_var_3, happy_var_5) : happy_var_1 + ) `HappyStk` happyRest}}} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_32 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_32 = happySpecReduce_0 14# happyReduction_32 +happyReduction_32 = happyIn18 + ([] + ) + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_33 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_33 = happySpecReduce_3 15# happyReduction_33 +happyReduction_33 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut22 happy_x_1 of { happy_var_1 -> + case happyOut20 happy_x_2 of { happy_var_2 -> + case happyOut16 happy_x_3 of { happy_var_3 -> + happyIn19 + (EdgeStatement ((uncurry NodeRef happy_var_1):(reverse happy_var_2)) happy_var_3 + )}}} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_34 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_34 = happySpecReduce_3 15# happyReduction_34 +happyReduction_34 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut24 happy_x_1 of { happy_var_1 -> + case happyOut20 happy_x_2 of { happy_var_2 -> + case happyOut16 happy_x_3 of { happy_var_3 -> + happyIn19 + (EdgeStatement (happy_var_1:(reverse happy_var_2)) happy_var_3 + )}}} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_35 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_35 = happySpecReduce_3 16# happyReduction_35 +happyReduction_35 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut20 happy_x_1 of { happy_var_1 -> + case happyOut22 happy_x_3 of { happy_var_3 -> + happyIn20 + ((uncurry NodeRef happy_var_3) : happy_var_1 + )}} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_36 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_36 = happySpecReduce_3 16# happyReduction_36 +happyReduction_36 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut20 happy_x_1 of { happy_var_1 -> + case happyOut24 happy_x_3 of { happy_var_3 -> + happyIn20 + (happy_var_3 : happy_var_1 + )}} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_37 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_37 = happySpecReduce_2 16# happyReduction_37 +happyReduction_37 happy_x_2 + happy_x_1 + = case happyOut22 happy_x_2 of { happy_var_2 -> + happyIn20 + ([uncurry NodeRef happy_var_2] + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_38 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_38 = happySpecReduce_2 16# happyReduction_38 +happyReduction_38 happy_x_2 + happy_x_1 + = case happyOut24 happy_x_2 of { happy_var_2 -> + happyIn20 + ([happy_var_2] + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_39 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_39 = happyMonadReduce 2# 16# happyReduction_39 +happyReduction_39 (happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen ((( getLineNumber `thenE` \line -> failE $ "Unfinished edge statement.")) + ) (\r -> happyReturn (happyIn20 r)) + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_40 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_40 = happyMonadReduce 2# 16# happyReduction_40 +happyReduction_40 (happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen ((( getLineNumber `thenE` \line -> failE $ "Unfinished edge statement.")) + ) (\r -> happyReturn (happyIn20 r)) + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_41 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_41 = happySpecReduce_2 17# happyReduction_41 +happyReduction_41 happy_x_2 + happy_x_1 + = case happyOut22 happy_x_1 of { happy_var_1 -> + case happyOut16 happy_x_2 of { happy_var_2 -> + happyIn21 + ((uncurry NodeStatement) happy_var_1 happy_var_2 + )}} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_42 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_42 = happySpecReduce_1 18# happyReduction_42 +happyReduction_42 happy_x_1 + = case happyOut8 happy_x_1 of { happy_var_1 -> + happyIn22 + ((happy_var_1, Nothing) + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_43 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_43 = happySpecReduce_2 18# happyReduction_43 +happyReduction_43 happy_x_2 + happy_x_1 + = case happyOut8 happy_x_1 of { happy_var_1 -> + case happyOut23 happy_x_2 of { happy_var_2 -> + happyIn22 + ((happy_var_1, (Just happy_var_2)) + )}} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_44 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_44 = happySpecReduce_2 19# happyReduction_44 +happyReduction_44 happy_x_2 + happy_x_1 + = case happyOut8 happy_x_2 of { happy_var_2 -> + happyIn23 + (case toCompass $ show happy_var_2 of + Just c -> Port Nothing (Just c) + Nothing -> Port (if show happy_var_2 == "_" then Nothing else (Just happy_var_2)) Nothing + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_45 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_45 = happyReduce 4# 19# happyReduction_45 +happyReduction_45 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut8 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_4 of { (TokenLabel happy_var_4) -> + happyIn23 + (Port (Just happy_var_2) (toCompass happy_var_4) + ) `HappyStk` happyRest}} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_46 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_46 = happySpecReduce_3 20# happyReduction_46 +happyReduction_46 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut7 happy_x_2 of { happy_var_2 -> + case happyOut11 happy_x_3 of { happy_var_3 -> + happyIn24 + (Subgraph happy_var_2 happy_var_3 + )}} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_47 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_47 = happySpecReduce_1 20# happyReduction_47 +happyReduction_47 happy_x_1 + = case happyOut11 happy_x_1 of { happy_var_1 -> + happyIn24 + (Subgraph Nothing happy_var_1 + )} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_48 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_48 = happySpecReduce_3 21# happyReduction_48 +happyReduction_48 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { (TokenOT happy_var_1) -> + case happyOut26 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { (TokenCT happy_var_3) -> + happyIn25 + (show happy_var_1 ++ (concat $ reverse happy_var_2) ++ show happy_var_3 + )}}} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_49 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_49 = happySpecReduce_2 22# happyReduction_49 +happyReduction_49 happy_x_2 + happy_x_1 + = case happyOut26 happy_x_1 of { happy_var_1 -> + case happyOut27 happy_x_2 of { happy_var_2 -> + happyIn26 + (happy_var_2 : happy_var_1 + )}} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_50 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_50 = happySpecReduce_0 22# happyReduction_50 +happyReduction_50 = happyIn26 + ([] + ) + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_51 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_51 = happySpecReduce_3 23# happyReduction_51 +happyReduction_51 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { (TokenOT happy_var_1) -> + case happyOut26 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { (TokenCT happy_var_3) -> + happyIn27 + (show happy_var_1 ++ (concat $ reverse happy_var_2) ++ show happy_var_3 + )}}} + +#if __GLASGOW_HASKELL__ >= 710 +happyReduce_52 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) +#endif +happyReduce_52 = happySpecReduce_1 23# happyReduction_52 +happyReduction_52 happy_x_1 + = case happyOutTok happy_x_1 of { (TokenProc happy_var_1) -> + happyIn27 + (show happy_var_1 + )} + +happyNewToken action sts stk + = lexer(\tk -> + let cont i = happyDoAction i tk action sts stk in + case tk of { + TokenEOF -> happyDoAction 22# tk action sts stk; + TokenGraph -> cont 1#; + TokenDigraph -> cont 2#; + TokenNode -> cont 3#; + TokenEdge -> cont 4#; + TokenSubgraph -> cont 5#; + TokenLabel happy_dollar_dollar -> cont 6#; + TokenQuotedLabel happy_dollar_dollar -> cont 7#; + TokenStrict -> cont 8#; + TokenArrow happy_dollar_dollar -> cont 9#; + TokenEQ -> cont 10#; + TokenOCB -> cont 11#; + TokenCCB -> cont 12#; + TokenOSB -> cont 13#; + TokenCSB -> cont 14#; + TokenCo -> cont 15#; + TokenSemiCo -> cont 16#; + TokenComma -> cont 17#; + TokenPlus -> cont 18#; + TokenCT happy_dollar_dollar -> cont 19#; + TokenOT happy_dollar_dollar -> cont 20#; + TokenProc happy_dollar_dollar -> cont 21#; + _ -> happyError' (tk, []) + }) + +happyError_ explist 22# tk = happyError' (tk, explist) +happyError_ explist _ tk = happyError' (tk, explist) + +happyThen :: () => P a -> (a -> P b) -> P b +happyThen = (thenE) +happyReturn :: () => a -> P a +happyReturn = (returnE) +#if __GLASGOW_HASKELL__ >= 710 +happyParse :: () => Happy_GHC_Exts.Int# -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) + +happyNewToken :: () => Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) + +happyDoAction :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) + +happyReduceArr :: () => Happy_Data_Array.Array Int (Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) -> P (HappyAbsSyn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _)) + +#endif +happyThen1 :: () => P a -> (a -> P b) -> P b +happyThen1 = happyThen +happyReturn1 :: () => a -> P a +happyReturn1 = happyReturn +happyError' :: () => ((Token), [String]) -> P a +happyError' tk = (\(tokens, _) -> parseError tokens) tk +dot = happySomeParser where + happySomeParser = happyThen (happyParse 0#) (\x -> happyReturn (let {x' = happyOut4 x} in x')) + +happySeq = happyDontSeq + + +data Except a = Success a | Failure String +type P a = String -> Int -> Except a + +thenE :: P a -> (a -> P b) -> P b +thenE m k s l = + case m s l of + Success a -> k a s l + Failure e -> Failure e + +returnE :: a -> P a +returnE a s l = Success a + +failE :: String -> P a +failE e s l = Failure $ "Error on line " ++ show l ++ ": " ++ e + +catchE :: P a -> (String -> P a) -> P a +catchE m k s l = case m s l of + Success a -> Success a + Failure e -> k e s l +getLineNumber s l = Success l +parseError :: Token -> P a +parseError t = getLineNumber `thenE` \line -> failE $ "Parse error on line " ++ show line ++ "." + +data Token = + TokenGraph + | TokenDigraph + | TokenNode + | TokenEdge + | TokenSubgraph + | TokenStrict + | TokenLabel String + | TokenQuotedLabel String + | TokenXML String + | TokenCompass Compass + | TokenArrow Char + | TokenEQ + | TokenOCB + | TokenCCB + | TokenOSB + | TokenCSB + | TokenCo + | TokenSemiCo + | TokenComma + | TokenCT String + | TokenOT String + | TokenProc String + | TokenPlus + | TokenEOF + deriving (Eq) + +instance Show Token where + show tk = case tk of + TokenGraph -> "graph" + TokenDigraph -> "digraph" + TokenNode -> "node" + TokenEdge -> "edge" + TokenSubgraph -> "subgraph" + TokenStrict -> "strict" + TokenLabel label -> label + TokenQuotedLabel label -> label + TokenXML xml -> xml + TokenCompass compass -> show compass + TokenArrow c -> [c] + TokenEQ -> "=" + TokenOCB -> "{" + TokenCCB -> "]" + TokenOSB -> "[" + TokenCSB -> "]" + TokenCo -> ":" + TokenSemiCo -> ";" + TokenComma -> "," + TokenCT tag -> "" + TokenOT tag -> "<" ++ tag ++ ">" + TokenProc xml -> "" + TokenPlus -> "+" + TokenEOF -> "" + +-- | Parse a graph written in the DOT language. +parse s = case dot ('\n':s) 0 of -- A newline is added to treat '#' in the beginning of a line properly. + Success ast -> Right ast + Failure msg -> Left msg + +toCompass l = + case map toLower l of + "n" -> Just $ North + "ne" -> Just $ NorthEast + "e" -> Just $ East + "se" -> Just $ SouthEast + "s" -> Just $ South + "sw" -> Just $ SouthWest + "w" -> Just $ West + "nw" -> Just $ NorthWest + "c" -> Just $ Center + "_" -> Nothing + _ -> Nothing + +lexer :: (Token -> (P a)) -> (P a) +lexer cont str line = case dropWhile (\c -> c /= '\n' && isSpace c) str of + '\n':'#':s' -> let s'' = dropWhile (/= '\n') s' in lexer cont s'' (line + 1) + '\n':s' -> lexer cont s' (line +1) + ',':s' -> cont TokenComma s' line + ';':s' -> cont TokenSemiCo s' line + 's':'u':'b':'g':'r':'a':'p':'h':s' -> cont TokenSubgraph s' line + 'g':'r':'a':'p':'h':s' -> cont TokenGraph s' line + 'd':'i':'g':'r':'a':'p':'h':s' -> cont TokenDigraph s' line + 'e':'d':'g':'e':s' -> cont TokenEdge s' line + 'n':'o':'d':'e':s' -> cont TokenNode s' line + 's':'t':'r':'i':'c':'t':s' -> cont TokenStrict s' line + '{':s' -> cont TokenOCB s' line + '}':s' -> cont TokenCCB s' line + '[':s' -> cont TokenOSB s' line + ']':s' -> cont TokenCSB s' line + '+':s' -> cont TokenPlus s' line + '=':s' -> cont TokenEQ s' line + ':':s' -> cont TokenCo s' line + '-':'-':s' -> cont (TokenArrow '-') s' line + '-':'>':s' -> cont (TokenArrow '>') s' line + '/':'/':s' -> let s'' = dropWhile (/= '\n') s' in lexer cont s'' line + '/':'*':s' -> let (s'', line') = execState consumeComment (s', line) + in lexer cont s'' (line') + '"':s' -> let (qs, (s'', line')) = runState consumeQuotedString (s', line) + in case qs of + Right string -> cont (TokenQuotedLabel string) s'' line' + Left msg -> failE msg s' line' + '<':'/':s' -> let (tag, (s'', line')) = runState consumeTag (s', line) + in cont (TokenCT tag) (tail s'') line' + '<':'!':'-':'-':s' -> let (s'', line') = execState consumeXMLComment (s', line) + in lexer cont s'' line' + '<':'?':s' -> let (proc, (s'', line')) = runState consumeProcessing (s', line) + in cont (TokenProc proc) s'' line' + [] -> cont TokenEOF [] line + s' -> let (label, s'') = span (\x -> not $ isSpace x || x `elem` ";,{}[]=\"") s' + in if null label then failE ("Unexpected character: " ++ [head s'']) s' line + else cont (TokenLabel label) s'' line +{-# LINE 1 "templates/GenericTemplate.hs" #-} +-- $Id: GenericTemplate.hs,v 1.26 2005/01/14 14:47:22 simonmar Exp $ + + + + + + + + + + + + + +-- Do not remove this comment. Required to fix CPP parsing when using GCC and a clang-compiled alex. +#if __GLASGOW_HASKELL__ > 706 +#define LT(n,m) ((Happy_GHC_Exts.tagToEnum# (n Happy_GHC_Exts.<# m)) :: Bool) +#define GTE(n,m) ((Happy_GHC_Exts.tagToEnum# (n Happy_GHC_Exts.>=# m)) :: Bool) +#define EQ(n,m) ((Happy_GHC_Exts.tagToEnum# (n Happy_GHC_Exts.==# m)) :: Bool) +#else +#define LT(n,m) (n Happy_GHC_Exts.<# m) +#define GTE(n,m) (n Happy_GHC_Exts.>=# m) +#define EQ(n,m) (n Happy_GHC_Exts.==# m) +#endif + + + + + + + + + + + + + + + + + + + +data Happy_IntList = HappyCons Happy_GHC_Exts.Int# Happy_IntList + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +infixr 9 `HappyStk` +data HappyStk a = HappyStk a (HappyStk a) + +----------------------------------------------------------------------------- +-- starting the parse + +happyParse start_state = happyNewToken start_state notHappyAtAll notHappyAtAll + +----------------------------------------------------------------------------- +-- Accepting the parse + +-- If the current token is ERROR_TOK, it means we've just accepted a partial +-- parse (a %partial parser). We must ignore the saved token on the top of +-- the stack in this case. +happyAccept 0# tk st sts (_ `HappyStk` ans `HappyStk` _) = + happyReturn1 ans +happyAccept j tk st sts (HappyStk ans _) = + (happyTcHack j (happyTcHack st)) (happyReturn1 ans) + +----------------------------------------------------------------------------- +-- Arrays only: do the next action + + + +happyDoAction i tk st + = {- nothing -} + case action of + 0# -> {- nothing -} + happyFail (happyExpListPerState ((Happy_GHC_Exts.I# (st)) :: Int)) i tk st + -1# -> {- nothing -} + happyAccept i tk st + n | LT(n,(0# :: Happy_GHC_Exts.Int#)) -> {- nothing -} + (happyReduceArr Happy_Data_Array.! rule) i tk st + where rule = (Happy_GHC_Exts.I# ((Happy_GHC_Exts.negateInt# ((n Happy_GHC_Exts.+# (1# :: Happy_GHC_Exts.Int#)))))) + n -> {- nothing -} + happyShift new_state i tk st + where new_state = (n Happy_GHC_Exts.-# (1# :: Happy_GHC_Exts.Int#)) + where off = happyAdjustOffset (indexShortOffAddr happyActOffsets st) + off_i = (off Happy_GHC_Exts.+# i) + check = if GTE(off_i,(0# :: Happy_GHC_Exts.Int#)) + then EQ(indexShortOffAddr happyCheck off_i, i) + else False + action + | check = indexShortOffAddr happyTable off_i + | otherwise = indexShortOffAddr happyDefActions st + + + + +indexShortOffAddr (HappyA# arr) off = + Happy_GHC_Exts.narrow16Int# i + where + i = Happy_GHC_Exts.word2Int# (Happy_GHC_Exts.or# (Happy_GHC_Exts.uncheckedShiftL# high 8#) low) + high = Happy_GHC_Exts.int2Word# (Happy_GHC_Exts.ord# (Happy_GHC_Exts.indexCharOffAddr# arr (off' Happy_GHC_Exts.+# 1#))) + low = Happy_GHC_Exts.int2Word# (Happy_GHC_Exts.ord# (Happy_GHC_Exts.indexCharOffAddr# arr off')) + off' = off Happy_GHC_Exts.*# 2# + + + + +{-# INLINE happyLt #-} +happyLt x y = LT(x,y) + + +readArrayBit arr bit = + Bits.testBit (Happy_GHC_Exts.I# (indexShortOffAddr arr ((unbox_int bit) `Happy_GHC_Exts.iShiftRA#` 4#))) (bit `mod` 16) + where unbox_int (Happy_GHC_Exts.I# x) = x + + + + + + +data HappyAddr = HappyA# Happy_GHC_Exts.Addr# + + +----------------------------------------------------------------------------- +-- HappyState data type (not arrays) + + + + + + + + + + + + + +----------------------------------------------------------------------------- +-- Shifting a token + +happyShift new_state 0# tk st sts stk@(x `HappyStk` _) = + let i = (case Happy_GHC_Exts.unsafeCoerce# x of { (Happy_GHC_Exts.I# (i)) -> i }) in +-- trace "shifting the error token" $ + happyDoAction i tk new_state (HappyCons (st) (sts)) (stk) + +happyShift new_state i tk st sts stk = + happyNewToken new_state (HappyCons (st) (sts)) ((happyInTok (tk))`HappyStk`stk) + +-- happyReduce is specialised for the common cases. + +happySpecReduce_0 i fn 0# tk st sts stk + = happyFail [] 0# tk st sts stk +happySpecReduce_0 nt fn j tk st@((action)) sts stk + = happyGoto nt j tk st (HappyCons (st) (sts)) (fn `HappyStk` stk) + +happySpecReduce_1 i fn 0# tk st sts stk + = happyFail [] 0# tk st sts stk +happySpecReduce_1 nt fn j tk _ sts@((HappyCons (st@(action)) (_))) (v1`HappyStk`stk') + = let r = fn v1 in + happySeq r (happyGoto nt j tk st sts (r `HappyStk` stk')) + +happySpecReduce_2 i fn 0# tk st sts stk + = happyFail [] 0# tk st sts stk +happySpecReduce_2 nt fn j tk _ (HappyCons (_) (sts@((HappyCons (st@(action)) (_))))) (v1`HappyStk`v2`HappyStk`stk') + = let r = fn v1 v2 in + happySeq r (happyGoto nt j tk st sts (r `HappyStk` stk')) + +happySpecReduce_3 i fn 0# tk st sts stk + = happyFail [] 0# tk st sts stk +happySpecReduce_3 nt fn j tk _ (HappyCons (_) ((HappyCons (_) (sts@((HappyCons (st@(action)) (_))))))) (v1`HappyStk`v2`HappyStk`v3`HappyStk`stk') + = let r = fn v1 v2 v3 in + happySeq r (happyGoto nt j tk st sts (r `HappyStk` stk')) + +happyReduce k i fn 0# tk st sts stk + = happyFail [] 0# tk st sts stk +happyReduce k nt fn j tk st sts stk + = case happyDrop (k Happy_GHC_Exts.-# (1# :: Happy_GHC_Exts.Int#)) sts of + sts1@((HappyCons (st1@(action)) (_))) -> + let r = fn stk in -- it doesn't hurt to always seq here... + happyDoSeq r (happyGoto nt j tk st1 sts1 r) + +happyMonadReduce k nt fn 0# tk st sts stk + = happyFail [] 0# tk st sts stk +happyMonadReduce k nt fn j tk st sts stk = + case happyDrop k (HappyCons (st) (sts)) of + sts1@((HappyCons (st1@(action)) (_))) -> + let drop_stk = happyDropStk k stk in + happyThen1 (fn stk tk) (\r -> happyGoto nt j tk st1 sts1 (r `HappyStk` drop_stk)) + +happyMonad2Reduce k nt fn 0# tk st sts stk + = happyFail [] 0# tk st sts stk +happyMonad2Reduce k nt fn j tk st sts stk = + case happyDrop k (HappyCons (st) (sts)) of + sts1@((HappyCons (st1@(action)) (_))) -> + let drop_stk = happyDropStk k stk + + off = happyAdjustOffset (indexShortOffAddr happyGotoOffsets st1) + off_i = (off Happy_GHC_Exts.+# nt) + new_state = indexShortOffAddr happyTable off_i + + + + + in + happyThen1 (fn stk tk) (\r -> happyNewToken new_state sts1 (r `HappyStk` drop_stk)) + +happyDrop 0# l = l +happyDrop n (HappyCons (_) (t)) = happyDrop (n Happy_GHC_Exts.-# (1# :: Happy_GHC_Exts.Int#)) t + +happyDropStk 0# l = l +happyDropStk n (x `HappyStk` xs) = happyDropStk (n Happy_GHC_Exts.-# (1#::Happy_GHC_Exts.Int#)) xs + +----------------------------------------------------------------------------- +-- Moving to a new state after a reduction + + +happyGoto nt j tk st = + {- nothing -} + happyDoAction j tk new_state + where off = happyAdjustOffset (indexShortOffAddr happyGotoOffsets st) + off_i = (off Happy_GHC_Exts.+# nt) + new_state = indexShortOffAddr happyTable off_i + + + + +----------------------------------------------------------------------------- +-- Error recovery (ERROR_TOK is the error token) + +-- parse error if we are in recovery and we fail again +happyFail explist 0# tk old_st _ stk@(x `HappyStk` _) = + let i = (case Happy_GHC_Exts.unsafeCoerce# x of { (Happy_GHC_Exts.I# (i)) -> i }) in +-- trace "failing" $ + happyError_ explist i tk + +{- We don't need state discarding for our restricted implementation of + "error". In fact, it can cause some bogus parses, so I've disabled it + for now --SDM + +-- discard a state +happyFail ERROR_TOK tk old_st CONS(HAPPYSTATE(action),sts) + (saved_tok `HappyStk` _ `HappyStk` stk) = +-- trace ("discarding state, depth " ++ show (length stk)) $ + DO_ACTION(action,ERROR_TOK,tk,sts,(saved_tok`HappyStk`stk)) +-} + +-- Enter error recovery: generate an error token, +-- save the old token and carry on. +happyFail explist i tk (action) sts stk = +-- trace "entering error recovery" $ + happyDoAction 0# tk action sts ((Happy_GHC_Exts.unsafeCoerce# (Happy_GHC_Exts.I# (i))) `HappyStk` stk) + +-- Internal happy errors: + +notHappyAtAll :: a +notHappyAtAll = error "Internal Happy error\n" + +----------------------------------------------------------------------------- +-- Hack to get the typechecker to accept our action functions + + +happyTcHack :: Happy_GHC_Exts.Int# -> a -> a +happyTcHack x y = y +{-# INLINE happyTcHack #-} + + +----------------------------------------------------------------------------- +-- Seq-ing. If the --strict flag is given, then Happy emits +-- happySeq = happyDoSeq +-- otherwise it emits +-- happySeq = happyDontSeq + +happyDoSeq, happyDontSeq :: a -> b -> b +happyDoSeq a b = a `seq` b +happyDontSeq a b = b + +----------------------------------------------------------------------------- +-- Don't inline any functions from the template. GHC has a nasty habit +-- of deciding to inline happyGoto everywhere, which increases the size of +-- the generated parser quite a bit. + + +{-# NOINLINE happyDoAction #-} +{-# NOINLINE happyTable #-} +{-# NOINLINE happyCheck #-} +{-# NOINLINE happyActOffsets #-} +{-# NOINLINE happyGotoOffsets #-} +{-# NOINLINE happyDefActions #-} + +{-# NOINLINE happyShift #-} +{-# NOINLINE happySpecReduce_0 #-} +{-# NOINLINE happySpecReduce_1 #-} +{-# NOINLINE happySpecReduce_2 #-} +{-# NOINLINE happySpecReduce_3 #-} +{-# NOINLINE happyReduce #-} +{-# NOINLINE happyMonadReduce #-} +{-# NOINLINE happyGoto #-} +{-# NOINLINE happyFail #-} + +-- end of Happy Template. diff --git a/happy-dot.cabal b/happy-dot.cabal new file mode 100644 --- /dev/null +++ b/happy-dot.cabal @@ -0,0 +1,72 @@ +-- Initial happy-dot.cabal generated by cabal init. For further +-- documentation, see http://haskell.org/cabal/users-guide/ + +name: happy-dot +version: 1.0.0.0 +synopsis: Parser for dot made with happy. +description: A parser for the [DOT language](https://www.graphviz.org/doc/info/lang.html). + The parser is quite fast as it uses happy. + . + This library also includes some convenience functions for + outputing DOT files and for converting DOT files into + graphs. +license: GPL-3 +license-file: LICENSE +author: Marcelo Garlet Millani +maintainer: marcelogmillani@gmail.com +-- copyright: +category: Language +build-type: Simple +extra-source-files: CHANGELOG.md +cabal-version: >=1.10 + +library + exposed-modules: Language.Dot.Parser, Language.Dot.Graph, Language.Dot.Utils, Language.Dot.Pretty + -- other-modules: + -- other-extensions: + build-depends: base >=4.8 && <5, transformers >= 0.5, array >= 0.5, pretty >= 1.1 + other-modules: HappyDot.Parser + hs-source-dirs: src + default-language: Haskell2010 + build-tools: happy + +test-suite test-ast + main-is: TestAST.hs + other-modules: Language.Dot.Parser, HappyDot.Parser, Language.Dot.Graph + hs-source-dirs: src, tests/AST + type: exitcode-stdio-1.0 + build-depends: base >=4.8 && <5, xml >= 1.3, transformers >= 0.5, array >= 0.5, HUnit >= 1.6 + default-language: Haskell2010 +test-suite test-pretty + main-is: TestPretty.hs + other-modules: Language.Dot.Parser, HappyDot.Parser, Language.Dot.Pretty, Language.Dot.Graph + hs-source-dirs: src, tests/Pretty + type: exitcode-stdio-1.0 + build-depends: base >=4.8 && <5, xml >= 1.3, transformers >= 0.5, array >= 0.5, HUnit >= 1.6, pretty >= 1.1 + default-language: Haskell2010 +test-suite test-utils + main-is: TestUtils.hs + other-modules: Language.Dot.Parser, HappyDot.Parser, Language.Dot.Utils, Language.Dot.Graph + hs-source-dirs: src, tests/Utils + type: exitcode-stdio-1.0 + build-depends: base >=4.8 && <5, xml >= 1.3, transformers >= 0.5, array >= 0.5, HUnit >= 1.6 + default-language: Haskell2010 + +Benchmark bench-happy-dot + type: exitcode-stdio-1.0 + main-is: HappyDotBench.hs + other-modules: Language.Dot.Parser, Language.Dot.Utils, HappyDot.Parser, Language.Dot.Graph, GraphGenerator + hs-source-dirs: src, benchmarks + build-depends: base >=4.8 && <5, xml >= 1.3, transformers >= 0.5, array >= 0.5, clock >= 0.7 + default-language: Haskell2010 +Benchmark bench-language-dot + type: exitcode-stdio-1.0 + main-is: LanguageDotBench.hs + other-modules: GraphGenerator + hs-source-dirs: benchmarks + build-depends: base >=4.8 && <5, xml >= 1.3, transformers >= 0.5, array >= 0.5, clock >= 0.7, language-dot + default-language: Haskell2010 + +source-repository head + type: git + location: https://gitlab.com/mgmillani/happy-dot diff --git a/src/HappyDot/Parser.hs b/src/HappyDot/Parser.hs new file mode 100644 --- /dev/null +++ b/src/HappyDot/Parser.hs @@ -0,0 +1,109 @@ +module HappyDot.Parser where + +import Control.Monad.Trans.State +import Data.Char +import Data.Maybe + +consumeWhile :: (Char -> Bool) -> State (String, Int) String +consumeWhile f = do + (str, ln) <- get + let (x,r) = span f str + ln' = ln + (length $ filter (=='\n') x) + put $ (r, ln') + return x + +consumeOnce :: (Char -> Bool) -> State (String, Int) String +consumeOnce f = do + (str, ln) <- get + case str of + (c:cs) -> if f c then put (cs, ln + if c == '\n' then 1 else 0) >> return [c] else return "" + [] -> return "" + +-- | Consumes a quoted string. Quotes can be escaped with '\'. +-- It is assumed the opening quote was already consumed. +-- | Returns the quoted string without the quotes and the number of lines read. +consumeQuotedString :: State (String, Int) (Either String String) +consumeQuotedString = do + str <- consumeWhile (\c -> not $ c `elem` "\\\"\n") + (cs, ln) <- get + case cs of + '\\':'\n':ss -> do + put (ss, ln+1) + str1 <- consumeQuotedString + return $ fmap (str ++) str1 + '\\':'"':ss -> do + put (ss, ln) + str1 <- consumeQuotedString + return $ str1 >>= \s1 -> return (str ++ ('"':s1)) + '\"':ss -> do + put (ss, ln) + return $ Right str + '\n':ss -> do + put (ss, ln+1) + return $ Left "String was open when newline was found. Either close the string with a \" or add a \\ to the end of the line to continue the string on the next line." + '\\':c:ss -> do + put (ss, ln) + str1 <- consumeQuotedString + return $ str1 >>= \s1 -> return (str ++ ('\\':c:s1)) + [] -> return $ Right str + +consumeProcessing = do + (s0, ln) <- get + case s0 of + '<':'?':cs -> do + put (cs, ln) + consumeProcessing' + _ -> return [] + +consumeProcessing' = do + t <- consumeWhile (/='?') + (s1, ln) <- get + case s1 of + '?':'>':cs -> do + put (cs, ln) + return $ '<':'?':(t ++ "?>") + c:cs -> do + put (cs, ln) + consumeProcessing' + [] -> do + return [] + +consumeComment = do + consumeWhile (/='*') + (str, ln) <- get + case str of + ('*':'/':str') -> put (str', ln) + (_:str') -> do + put (str', ln) + consumeComment + +consumeXMLComment = do + consumeWhile (/='-') + (str, ln) <- get + case str of + ('-':'-':'>':str') -> put (str', ln) + (_:str') -> do + put (str', ln) + consumeXMLComment + +consumeSomeString strings = do + str <- get + let ss = filter isJust $ map + (\(s,r) -> + do + str' <- spanStr s str + return (r, str')) + strings + if null ss then return Nothing + else let Just (r, str') = head ss in put str' >> return (Just r) + +consumeTag = do + tag <- consumeWhile (/='>') + consumeOnce (=='>') + return tag + +spanStr [] str = Just str +spanStr _ [] = Nothing +spanStr (p:pattern) (s:str) + | p == s = spanStr pattern str + | otherwise = Nothing diff --git a/src/Language/Dot/Graph.hs b/src/Language/Dot/Graph.hs new file mode 100644 --- /dev/null +++ b/src/Language/Dot/Graph.hs @@ -0,0 +1,35 @@ + +-------------------------------------------------------------------- +-- | +-- Module : Language.Dot.Graph +-- License : GPL-3 +-- +-- Maintainer : Marcelo Garlet Millani +-- Stability : experimental +-- Portability : portable +-- +-- Basic data structures for representing DOT files. +-------------------------------------------------------------------- + +module Language.Dot.Graph where + +data GraphType = Graph | Digraph deriving (Show, Eq) +data Name = StringID String | XMLID String deriving (Eq) +instance Show Name where + show (StringID str) = str + show (XMLID str) = str +data Statement = + EdgeStatement [Subgraph] [(Name, Name)] + | NodeStatement Name (Maybe Port) [(Name, Name)] + | SubgraphStatement Subgraph + | AttributeStatement (Name, Name) + | EdgeAttribute [(Name, Name)] + | NodeAttribute [(Name, Name)] + | GraphAttribute [(Name, Name)] + deriving (Show, Eq) +data Subgraph = NodeRef Name (Maybe Port) | Subgraph (Maybe Name) [Statement] deriving (Show, Eq) +data Port = Port (Maybe Name) (Maybe Compass) deriving (Show, Eq) +data Compass = North | NorthEast | East | SouthEast | South | SouthWest | West | NorthWest | Center deriving (Show, Eq) + +-- | Simple representation of a graph considering only the adjacency of nodes. +data GraphElement = Node String [(Name, Name)] | Edge String String [(Name, Name)] deriving (Eq, Show) diff --git a/src/Language/Dot/Parser.hs b/src/Language/Dot/Parser.hs new file mode 100644 --- /dev/null +++ b/src/Language/Dot/Parser.hs @@ -0,0 +1,1344 @@ +{-# OPTIONS_GHC -w #-} +module Language.Dot.Parser + (parse + , GraphType(..) + , Name(..) + , Stmt(..) + , Subgraph(..) + , Port(..) + , Compass(..) + ) where + +import HappyDot.Parser +import Language.Dot.Graph + +import Data.Char +import Control.Monad.Trans.State + +import qualified Debug.Trace as D +import qualified Data.Array as Happy_Data_Array +import qualified Data.Bits as Bits +import Control.Applicative(Applicative(..)) +import Control.Monad (ap) + +-- parser produced by Happy Version 1.19.12 + +data HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 t27 + = HappyTerminal (Token) + | HappyErrorToken Int + | HappyAbsSyn4 t4 + | HappyAbsSyn5 t5 + | HappyAbsSyn6 t6 + | HappyAbsSyn7 t7 + | HappyAbsSyn8 t8 + | HappyAbsSyn9 t9 + | HappyAbsSyn10 t10 + | HappyAbsSyn11 t11 + | HappyAbsSyn12 t12 + | HappyAbsSyn13 t13 + | HappyAbsSyn14 t14 + | HappyAbsSyn15 t15 + | HappyAbsSyn16 t16 + | HappyAbsSyn17 t17 + | HappyAbsSyn18 t18 + | HappyAbsSyn19 t19 + | HappyAbsSyn20 t20 + | HappyAbsSyn21 t21 + | HappyAbsSyn22 t22 + | HappyAbsSyn23 t23 + | HappyAbsSyn24 t24 + | HappyAbsSyn25 t25 + | HappyAbsSyn26 t26 + | HappyAbsSyn27 t27 + +happyExpList :: Happy_Data_Array.Array Int Int +happyExpList = Happy_Data_Array.listArray (0,147) ([0,0,4,0,0,8,0,24576,0,0,0,0,0,0,0,0,0,96,8,0,0,0,0,0,0,0,8192,0,0,0,0,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,0,0,0,0,57344,0,0,4,0,0,0,0,0,0,0,32768,1598,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,896,0,32768,16,0,0,0,0,0,384,0,0,0,0,0,0,0,0,0,0,0,16,0,0,32,0,0,0,0,0,0,0,0,0,0,0,192,16,0,0,0,0,8192,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,1,0,57344,4872,0,0,0,0,0,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,8,0,192,16,0,0,0,0,0,2,0,0,0,0,0,0,0,7168,513,0,0,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,53248,0,0,0,0,0,0,0,0,128,0,0,0,0,0,1536,128,0,0,0,0,32768,0,0,12288,1024,0,0,0,0 + ]) + +{-# NOINLINE happyExpListPerState #-} +happyExpListPerState st = + token_strs_expected + where token_strs = ["error","%dummy","%start_dot","Graph","Strictness","GraphType","Name_empty","Name","Quoted_string","Quoted_sum","Stmt_list","Stmt_list_aux","Stmt_sep","Stmt","Attr_stmt","Attr_list","Attr_list_aux","A_list","Edge_stmt","EdgeRHS","Node_stmt","Node","Port","Subgraph","Xml","XmlList","XmlElement","graph","digraph","node","edge","subgraph","label","qlabel","strict","arrow","'='","'{'","'}'","'['","']'","':'","';'","','","'+'","xmlClose","xmlOpen","xmlProc","%eof"] + bit_start = st * 49 + bit_end = (st + 1) * 49 + read_bit = readArrayBit happyExpList + bits = map read_bit [bit_start..bit_end - 1] + bits_indexed = zip bits [0..48] + token_strs_expected = concatMap f bits_indexed + f (False, _) = [] + f (True, nr) = [token_strs !! nr] + +action_0 (35) = happyShift action_3 +action_0 (4) = happyGoto action_4 +action_0 (5) = happyGoto action_2 +action_0 _ = happyReduce_3 + +action_1 (35) = happyShift action_3 +action_1 (5) = happyGoto action_2 +action_1 _ = happyFail (happyExpListPerState 1) + +action_2 (28) = happyShift action_6 +action_2 (29) = happyShift action_7 +action_2 (6) = happyGoto action_5 +action_2 _ = happyFail (happyExpListPerState 2) + +action_3 _ = happyReduce_2 + +action_4 (49) = happyAccept +action_4 _ = happyFail (happyExpListPerState 4) + +action_5 (33) = happyShift action_13 +action_5 (34) = happyShift action_14 +action_5 (47) = happyShift action_15 +action_5 (7) = happyGoto action_8 +action_5 (8) = happyGoto action_9 +action_5 (9) = happyGoto action_10 +action_5 (10) = happyGoto action_11 +action_5 (25) = happyGoto action_12 +action_5 _ = happyReduce_7 + +action_6 _ = happyReduce_4 + +action_7 _ = happyReduce_5 + +action_8 (38) = happyShift action_19 +action_8 (11) = happyGoto action_18 +action_8 _ = happyFail (happyExpListPerState 8) + +action_9 _ = happyReduce_6 + +action_10 _ = happyReduce_9 + +action_11 (45) = happyShift action_17 +action_11 _ = happyReduce_11 + +action_12 _ = happyReduce_10 + +action_13 _ = happyReduce_8 + +action_14 _ = happyReduce_12 + +action_15 (26) = happyGoto action_16 +action_15 _ = happyReduce_50 + +action_16 (46) = happyShift action_23 +action_16 (47) = happyShift action_24 +action_16 (48) = happyShift action_25 +action_16 (27) = happyGoto action_22 +action_16 _ = happyFail (happyExpListPerState 16) + +action_17 (34) = happyShift action_21 +action_17 _ = happyFail (happyExpListPerState 17) + +action_18 _ = happyReduce_1 + +action_19 (12) = happyGoto action_20 +action_19 _ = happyReduce_16 + +action_20 (28) = happyShift action_35 +action_20 (30) = happyShift action_36 +action_20 (31) = happyShift action_37 +action_20 (32) = happyShift action_38 +action_20 (33) = happyShift action_13 +action_20 (34) = happyShift action_14 +action_20 (38) = happyShift action_19 +action_20 (39) = happyShift action_39 +action_20 (47) = happyShift action_15 +action_20 (8) = happyGoto action_27 +action_20 (9) = happyGoto action_10 +action_20 (10) = happyGoto action_11 +action_20 (11) = happyGoto action_28 +action_20 (14) = happyGoto action_29 +action_20 (15) = happyGoto action_30 +action_20 (19) = happyGoto action_31 +action_20 (21) = happyGoto action_32 +action_20 (22) = happyGoto action_33 +action_20 (24) = happyGoto action_34 +action_20 (25) = happyGoto action_12 +action_20 _ = happyFail (happyExpListPerState 20) + +action_21 _ = happyReduce_13 + +action_22 _ = happyReduce_49 + +action_23 _ = happyReduce_48 + +action_24 (26) = happyGoto action_26 +action_24 _ = happyReduce_50 + +action_25 _ = happyReduce_52 + +action_26 (46) = happyShift action_55 +action_26 (47) = happyShift action_24 +action_26 (48) = happyShift action_25 +action_26 (27) = happyGoto action_22 +action_26 _ = happyFail (happyExpListPerState 26) + +action_27 (37) = happyShift action_53 +action_27 (42) = happyShift action_54 +action_27 (23) = happyGoto action_52 +action_27 _ = happyReduce_42 + +action_28 _ = happyReduce_47 + +action_29 (43) = happyShift action_50 +action_29 (44) = happyShift action_51 +action_29 (13) = happyGoto action_49 +action_29 _ = happyReduce_19 + +action_30 _ = happyReduce_20 + +action_31 _ = happyReduce_22 + +action_32 _ = happyReduce_21 + +action_33 (36) = happyShift action_46 +action_33 (16) = happyGoto action_47 +action_33 (17) = happyGoto action_42 +action_33 (20) = happyGoto action_48 +action_33 _ = happyReduce_30 + +action_34 (36) = happyShift action_46 +action_34 (20) = happyGoto action_45 +action_34 _ = happyReduce_24 + +action_35 (16) = happyGoto action_44 +action_35 (17) = happyGoto action_42 +action_35 _ = happyReduce_30 + +action_36 (16) = happyGoto action_43 +action_36 (17) = happyGoto action_42 +action_36 _ = happyReduce_30 + +action_37 (16) = happyGoto action_41 +action_37 (17) = happyGoto action_42 +action_37 _ = happyReduce_30 + +action_38 (33) = happyShift action_13 +action_38 (34) = happyShift action_14 +action_38 (47) = happyShift action_15 +action_38 (7) = happyGoto action_40 +action_38 (8) = happyGoto action_9 +action_38 (9) = happyGoto action_10 +action_38 (10) = happyGoto action_11 +action_38 (25) = happyGoto action_12 +action_38 _ = happyReduce_7 + +action_39 _ = happyReduce_14 + +action_40 (38) = happyShift action_19 +action_40 (11) = happyGoto action_67 +action_40 _ = happyFail (happyExpListPerState 40) + +action_41 _ = happyReduce_26 + +action_42 (40) = happyShift action_66 +action_42 _ = happyReduce_28 + +action_43 _ = happyReduce_25 + +action_44 _ = happyReduce_27 + +action_45 (36) = happyShift action_59 +action_45 (16) = happyGoto action_65 +action_45 (17) = happyGoto action_42 +action_45 _ = happyReduce_30 + +action_46 (32) = happyShift action_38 +action_46 (33) = happyShift action_13 +action_46 (34) = happyShift action_14 +action_46 (38) = happyShift action_19 +action_46 (43) = happyShift action_63 +action_46 (44) = happyShift action_64 +action_46 (47) = happyShift action_15 +action_46 (8) = happyGoto action_60 +action_46 (9) = happyGoto action_10 +action_46 (10) = happyGoto action_11 +action_46 (11) = happyGoto action_28 +action_46 (22) = happyGoto action_61 +action_46 (24) = happyGoto action_62 +action_46 (25) = happyGoto action_12 +action_46 _ = happyFail (happyExpListPerState 46) + +action_47 _ = happyReduce_41 + +action_48 (36) = happyShift action_59 +action_48 (16) = happyGoto action_58 +action_48 (17) = happyGoto action_42 +action_48 _ = happyReduce_30 + +action_49 _ = happyReduce_15 + +action_50 _ = happyReduce_17 + +action_51 _ = happyReduce_18 + +action_52 _ = happyReduce_43 + +action_53 (33) = happyShift action_13 +action_53 (34) = happyShift action_14 +action_53 (47) = happyShift action_15 +action_53 (8) = happyGoto action_57 +action_53 (9) = happyGoto action_10 +action_53 (10) = happyGoto action_11 +action_53 (25) = happyGoto action_12 +action_53 _ = happyFail (happyExpListPerState 53) + +action_54 (33) = happyShift action_13 +action_54 (34) = happyShift action_14 +action_54 (47) = happyShift action_15 +action_54 (8) = happyGoto action_56 +action_54 (9) = happyGoto action_10 +action_54 (10) = happyGoto action_11 +action_54 (25) = happyGoto action_12 +action_54 _ = happyFail (happyExpListPerState 54) + +action_55 _ = happyReduce_51 + +action_56 (42) = happyShift action_71 +action_56 _ = happyReduce_44 + +action_57 _ = happyReduce_23 + +action_58 _ = happyReduce_33 + +action_59 (32) = happyShift action_38 +action_59 (33) = happyShift action_13 +action_59 (34) = happyShift action_14 +action_59 (38) = happyShift action_19 +action_59 (47) = happyShift action_15 +action_59 (8) = happyGoto action_60 +action_59 (9) = happyGoto action_10 +action_59 (10) = happyGoto action_11 +action_59 (11) = happyGoto action_28 +action_59 (22) = happyGoto action_69 +action_59 (24) = happyGoto action_70 +action_59 (25) = happyGoto action_12 +action_59 _ = happyFail (happyExpListPerState 59) + +action_60 (42) = happyShift action_54 +action_60 (23) = happyGoto action_52 +action_60 _ = happyReduce_42 + +action_61 _ = happyReduce_37 + +action_62 _ = happyReduce_38 + +action_63 _ = happyReduce_39 + +action_64 _ = happyReduce_40 + +action_65 _ = happyReduce_34 + +action_66 (18) = happyGoto action_68 +action_66 _ = happyReduce_32 + +action_67 _ = happyReduce_46 + +action_68 (41) = happyShift action_74 +action_68 (43) = happyShift action_50 +action_68 (44) = happyShift action_51 +action_68 (13) = happyGoto action_73 +action_68 _ = happyReduce_19 + +action_69 _ = happyReduce_35 + +action_70 _ = happyReduce_36 + +action_71 (33) = happyShift action_72 +action_71 _ = happyFail (happyExpListPerState 71) + +action_72 _ = happyReduce_45 + +action_73 (33) = happyShift action_13 +action_73 (34) = happyShift action_14 +action_73 (47) = happyShift action_15 +action_73 (8) = happyGoto action_75 +action_73 (9) = happyGoto action_10 +action_73 (10) = happyGoto action_11 +action_73 (25) = happyGoto action_12 +action_73 _ = happyFail (happyExpListPerState 73) + +action_74 _ = happyReduce_29 + +action_75 (37) = happyShift action_76 +action_75 _ = happyFail (happyExpListPerState 75) + +action_76 (33) = happyShift action_13 +action_76 (34) = happyShift action_14 +action_76 (47) = happyShift action_15 +action_76 (8) = happyGoto action_77 +action_76 (9) = happyGoto action_10 +action_76 (10) = happyGoto action_11 +action_76 (25) = happyGoto action_12 +action_76 _ = happyFail (happyExpListPerState 76) + +action_77 _ = happyReduce_31 + +happyReduce_1 = happyReduce 4 4 happyReduction_1 +happyReduction_1 ((HappyAbsSyn11 happy_var_4) `HappyStk` + (HappyAbsSyn7 happy_var_3) `HappyStk` + (HappyAbsSyn6 happy_var_2) `HappyStk` + (HappyAbsSyn5 happy_var_1) `HappyStk` + happyRest) + = HappyAbsSyn4 + ((happy_var_1, happy_var_2, happy_var_3, happy_var_4) + ) `HappyStk` happyRest + +happyReduce_2 = happySpecReduce_1 5 happyReduction_2 +happyReduction_2 _ + = HappyAbsSyn5 + (True + ) + +happyReduce_3 = happySpecReduce_0 5 happyReduction_3 +happyReduction_3 = HappyAbsSyn5 + (False + ) + +happyReduce_4 = happySpecReduce_1 6 happyReduction_4 +happyReduction_4 _ + = HappyAbsSyn6 + (Graph + ) + +happyReduce_5 = happySpecReduce_1 6 happyReduction_5 +happyReduction_5 _ + = HappyAbsSyn6 + (Digraph + ) + +happyReduce_6 = happySpecReduce_1 7 happyReduction_6 +happyReduction_6 (HappyAbsSyn8 happy_var_1) + = HappyAbsSyn7 + (happy_var_1 + ) +happyReduction_6 _ = notHappyAtAll + +happyReduce_7 = happySpecReduce_0 7 happyReduction_7 +happyReduction_7 = HappyAbsSyn7 + (StringID "" + ) + +happyReduce_8 = happySpecReduce_1 8 happyReduction_8 +happyReduction_8 (HappyTerminal (TokenLabel happy_var_1)) + = HappyAbsSyn8 + (StringID happy_var_1 + ) +happyReduction_8 _ = notHappyAtAll + +happyReduce_9 = happySpecReduce_1 8 happyReduction_9 +happyReduction_9 (HappyAbsSyn9 happy_var_1) + = HappyAbsSyn8 + (StringID happy_var_1 + ) +happyReduction_9 _ = notHappyAtAll + +happyReduce_10 = happySpecReduce_1 8 happyReduction_10 +happyReduction_10 (HappyAbsSyn25 happy_var_1) + = HappyAbsSyn8 + (XMLID happy_var_1 + ) +happyReduction_10 _ = notHappyAtAll + +happyReduce_11 = happySpecReduce_1 9 happyReduction_11 +happyReduction_11 (HappyAbsSyn10 happy_var_1) + = HappyAbsSyn9 + (concat $ reverse happy_var_1 + ) +happyReduction_11 _ = notHappyAtAll + +happyReduce_12 = happySpecReduce_1 10 happyReduction_12 +happyReduction_12 (HappyTerminal (TokenQuotedLabel happy_var_1)) + = HappyAbsSyn10 + ([happy_var_1] + ) +happyReduction_12 _ = notHappyAtAll + +happyReduce_13 = happySpecReduce_3 10 happyReduction_13 +happyReduction_13 (HappyTerminal (TokenQuotedLabel happy_var_3)) + _ + (HappyAbsSyn10 happy_var_1) + = HappyAbsSyn10 + (happy_var_3 : happy_var_1 + ) +happyReduction_13 _ _ _ = notHappyAtAll + +happyReduce_14 = happySpecReduce_3 11 happyReduction_14 +happyReduction_14 _ + (HappyAbsSyn12 happy_var_2) + _ + = HappyAbsSyn11 + (reverse happy_var_2 + ) +happyReduction_14 _ _ _ = notHappyAtAll + +happyReduce_15 = happySpecReduce_3 12 happyReduction_15 +happyReduction_15 _ + (HappyAbsSyn14 happy_var_2) + (HappyAbsSyn12 happy_var_1) + = HappyAbsSyn12 + (happy_var_2 : happy_var_1 + ) +happyReduction_15 _ _ _ = notHappyAtAll + +happyReduce_16 = happySpecReduce_0 12 happyReduction_16 +happyReduction_16 = HappyAbsSyn12 + ([] + ) + +happyReduce_17 = happySpecReduce_1 13 happyReduction_17 +happyReduction_17 (HappyTerminal happy_var_1) + = HappyAbsSyn13 + (Just happy_var_1 + ) +happyReduction_17 _ = notHappyAtAll + +happyReduce_18 = happySpecReduce_1 13 happyReduction_18 +happyReduction_18 (HappyTerminal happy_var_1) + = HappyAbsSyn13 + (Just happy_var_1 + ) +happyReduction_18 _ = notHappyAtAll + +happyReduce_19 = happySpecReduce_0 13 happyReduction_19 +happyReduction_19 = HappyAbsSyn13 + (Nothing + ) + +happyReduce_20 = happySpecReduce_1 14 happyReduction_20 +happyReduction_20 (HappyAbsSyn15 happy_var_1) + = HappyAbsSyn14 + (happy_var_1 + ) +happyReduction_20 _ = notHappyAtAll + +happyReduce_21 = happySpecReduce_1 14 happyReduction_21 +happyReduction_21 (HappyAbsSyn21 happy_var_1) + = HappyAbsSyn14 + (happy_var_1 + ) +happyReduction_21 _ = notHappyAtAll + +happyReduce_22 = happySpecReduce_1 14 happyReduction_22 +happyReduction_22 (HappyAbsSyn19 happy_var_1) + = HappyAbsSyn14 + (happy_var_1 + ) +happyReduction_22 _ = notHappyAtAll + +happyReduce_23 = happySpecReduce_3 14 happyReduction_23 +happyReduction_23 (HappyAbsSyn8 happy_var_3) + _ + (HappyAbsSyn8 happy_var_1) + = HappyAbsSyn14 + (AttributeStatement (show happy_var_1, show happy_var_3) + ) +happyReduction_23 _ _ _ = notHappyAtAll + +happyReduce_24 = happySpecReduce_1 14 happyReduction_24 +happyReduction_24 (HappyAbsSyn24 happy_var_1) + = HappyAbsSyn14 + (SubgraphStatement happy_var_1 + ) +happyReduction_24 _ = notHappyAtAll + +happyReduce_25 = happySpecReduce_2 15 happyReduction_25 +happyReduction_25 (HappyAbsSyn16 happy_var_2) + _ + = HappyAbsSyn15 + (NodeAttribute happy_var_2 + ) +happyReduction_25 _ _ = notHappyAtAll + +happyReduce_26 = happySpecReduce_2 15 happyReduction_26 +happyReduction_26 (HappyAbsSyn16 happy_var_2) + _ + = HappyAbsSyn15 + (EdgeAttribute happy_var_2 + ) +happyReduction_26 _ _ = notHappyAtAll + +happyReduce_27 = happySpecReduce_2 15 happyReduction_27 +happyReduction_27 (HappyAbsSyn16 happy_var_2) + _ + = HappyAbsSyn15 + (GraphAttribute happy_var_2 + ) +happyReduction_27 _ _ = notHappyAtAll + +happyReduce_28 = happySpecReduce_1 16 happyReduction_28 +happyReduction_28 (HappyAbsSyn17 happy_var_1) + = HappyAbsSyn16 + (reverse happy_var_1 + ) +happyReduction_28 _ = notHappyAtAll + +happyReduce_29 = happyReduce 4 17 happyReduction_29 +happyReduction_29 (_ `HappyStk` + (HappyAbsSyn18 happy_var_3) `HappyStk` + _ `HappyStk` + (HappyAbsSyn17 happy_var_1) `HappyStk` + happyRest) + = HappyAbsSyn17 + (happy_var_3 ++ happy_var_1 + ) `HappyStk` happyRest + +happyReduce_30 = happySpecReduce_0 17 happyReduction_30 +happyReduction_30 = HappyAbsSyn17 + ([] + ) + +happyReduce_31 = happyReduce 5 18 happyReduction_31 +happyReduction_31 ((HappyAbsSyn8 happy_var_5) `HappyStk` + _ `HappyStk` + (HappyAbsSyn8 happy_var_3) `HappyStk` + _ `HappyStk` + (HappyAbsSyn18 happy_var_1) `HappyStk` + happyRest) + = HappyAbsSyn18 + (( happy_var_3, happy_var_5) : happy_var_1 + ) `HappyStk` happyRest + +happyReduce_32 = happySpecReduce_0 18 happyReduction_32 +happyReduction_32 = HappyAbsSyn18 + ([] + ) + +happyReduce_33 = happySpecReduce_3 19 happyReduction_33 +happyReduction_33 (HappyAbsSyn16 happy_var_3) + (HappyAbsSyn20 happy_var_2) + (HappyAbsSyn22 happy_var_1) + = HappyAbsSyn19 + (EdgeStatement ((uncurry NodeRef happy_var_1):(reverse happy_var_2)) happy_var_3 + ) +happyReduction_33 _ _ _ = notHappyAtAll + +happyReduce_34 = happySpecReduce_3 19 happyReduction_34 +happyReduction_34 (HappyAbsSyn16 happy_var_3) + (HappyAbsSyn20 happy_var_2) + (HappyAbsSyn24 happy_var_1) + = HappyAbsSyn19 + (EdgeStatement (happy_var_1:(reverse happy_var_2)) happy_var_3 + ) +happyReduction_34 _ _ _ = notHappyAtAll + +happyReduce_35 = happySpecReduce_3 20 happyReduction_35 +happyReduction_35 (HappyAbsSyn22 happy_var_3) + _ + (HappyAbsSyn20 happy_var_1) + = HappyAbsSyn20 + ((uncurry NodeRef happy_var_3) : happy_var_1 + ) +happyReduction_35 _ _ _ = notHappyAtAll + +happyReduce_36 = happySpecReduce_3 20 happyReduction_36 +happyReduction_36 (HappyAbsSyn24 happy_var_3) + _ + (HappyAbsSyn20 happy_var_1) + = HappyAbsSyn20 + (happy_var_3 : happy_var_1 + ) +happyReduction_36 _ _ _ = notHappyAtAll + +happyReduce_37 = happySpecReduce_2 20 happyReduction_37 +happyReduction_37 (HappyAbsSyn22 happy_var_2) + _ + = HappyAbsSyn20 + ([uncurry NodeRef happy_var_2] + ) +happyReduction_37 _ _ = notHappyAtAll + +happyReduce_38 = happySpecReduce_2 20 happyReduction_38 +happyReduction_38 (HappyAbsSyn24 happy_var_2) + _ + = HappyAbsSyn20 + ([happy_var_2] + ) +happyReduction_38 _ _ = notHappyAtAll + +happyReduce_39 = happyMonadReduce 2 20 happyReduction_39 +happyReduction_39 (_ `HappyStk` + _ `HappyStk` + happyRest) tk + = happyThen ((( getLineNumber `thenE` \line -> failE $ "Unfinished edge statement.")) + ) (\r -> happyReturn (HappyAbsSyn20 r)) + +happyReduce_40 = happyMonadReduce 2 20 happyReduction_40 +happyReduction_40 (_ `HappyStk` + _ `HappyStk` + happyRest) tk + = happyThen ((( getLineNumber `thenE` \line -> failE $ "Unfinished edge statement.")) + ) (\r -> happyReturn (HappyAbsSyn20 r)) + +happyReduce_41 = happySpecReduce_2 21 happyReduction_41 +happyReduction_41 (HappyAbsSyn16 happy_var_2) + (HappyAbsSyn22 happy_var_1) + = HappyAbsSyn21 + ((uncurry NodeStatement) happy_var_1 happy_var_2 + ) +happyReduction_41 _ _ = notHappyAtAll + +happyReduce_42 = happySpecReduce_1 22 happyReduction_42 +happyReduction_42 (HappyAbsSyn8 happy_var_1) + = HappyAbsSyn22 + ((happy_var_1, Nothing) + ) +happyReduction_42 _ = notHappyAtAll + +happyReduce_43 = happySpecReduce_2 22 happyReduction_43 +happyReduction_43 (HappyAbsSyn23 happy_var_2) + (HappyAbsSyn8 happy_var_1) + = HappyAbsSyn22 + ((happy_var_1, (Just happy_var_2)) + ) +happyReduction_43 _ _ = notHappyAtAll + +happyReduce_44 = happySpecReduce_2 23 happyReduction_44 +happyReduction_44 (HappyAbsSyn8 happy_var_2) + _ + = HappyAbsSyn23 + (case toCompass $ show happy_var_2 of + Just c -> Port Nothing (Just c) + Nothing -> Port (if show happy_var_2 == "_" then Nothing else (Just happy_var_2)) Nothing + ) +happyReduction_44 _ _ = notHappyAtAll + +happyReduce_45 = happyReduce 4 23 happyReduction_45 +happyReduction_45 ((HappyTerminal (TokenLabel happy_var_4)) `HappyStk` + _ `HappyStk` + (HappyAbsSyn8 happy_var_2) `HappyStk` + _ `HappyStk` + happyRest) + = HappyAbsSyn23 + (Port (Just happy_var_2) (toCompass happy_var_4) + ) `HappyStk` happyRest + +happyReduce_46 = happySpecReduce_3 24 happyReduction_46 +happyReduction_46 (HappyAbsSyn11 happy_var_3) + (HappyAbsSyn7 happy_var_2) + _ + = HappyAbsSyn24 + (Subgraph happy_var_2 happy_var_3 + ) +happyReduction_46 _ _ _ = notHappyAtAll + +happyReduce_47 = happySpecReduce_1 24 happyReduction_47 +happyReduction_47 (HappyAbsSyn11 happy_var_1) + = HappyAbsSyn24 + (Subgraph (StringID "") happy_var_1 + ) +happyReduction_47 _ = notHappyAtAll + +happyReduce_48 = happySpecReduce_3 25 happyReduction_48 +happyReduction_48 (HappyTerminal (TokenCT happy_var_3)) + (HappyAbsSyn26 happy_var_2) + (HappyTerminal (TokenOT happy_var_1)) + = HappyAbsSyn25 + (show happy_var_1 ++ (concat $ reverse happy_var_2) ++ show happy_var_3 + ) +happyReduction_48 _ _ _ = notHappyAtAll + +happyReduce_49 = happySpecReduce_2 26 happyReduction_49 +happyReduction_49 (HappyAbsSyn27 happy_var_2) + (HappyAbsSyn26 happy_var_1) + = HappyAbsSyn26 + (happy_var_2 : happy_var_1 + ) +happyReduction_49 _ _ = notHappyAtAll + +happyReduce_50 = happySpecReduce_0 26 happyReduction_50 +happyReduction_50 = HappyAbsSyn26 + ([] + ) + +happyReduce_51 = happySpecReduce_3 27 happyReduction_51 +happyReduction_51 (HappyTerminal (TokenCT happy_var_3)) + (HappyAbsSyn26 happy_var_2) + (HappyTerminal (TokenOT happy_var_1)) + = HappyAbsSyn27 + (show happy_var_1 ++ (concat $ reverse happy_var_2) ++ show happy_var_3 + ) +happyReduction_51 _ _ _ = notHappyAtAll + +happyReduce_52 = happySpecReduce_1 27 happyReduction_52 +happyReduction_52 (HappyTerminal (TokenProc happy_var_1)) + = HappyAbsSyn27 + (show happy_var_1 + ) +happyReduction_52 _ = notHappyAtAll + +happyNewToken action sts stk + = lexer(\tk -> + let cont i = action i i tk (HappyState action) sts stk in + case tk of { + TokenEOF -> action 49 49 tk (HappyState action) sts stk; + TokenGraph -> cont 28; + TokenDigraph -> cont 29; + TokenNode -> cont 30; + TokenEdge -> cont 31; + TokenSubgraph -> cont 32; + TokenLabel happy_dollar_dollar -> cont 33; + TokenQuotedLabel happy_dollar_dollar -> cont 34; + TokenStrict -> cont 35; + TokenArrow happy_dollar_dollar -> cont 36; + TokenEQ -> cont 37; + TokenOCB -> cont 38; + TokenCCB -> cont 39; + TokenOSB -> cont 40; + TokenCSB -> cont 41; + TokenCo -> cont 42; + TokenSemiCo -> cont 43; + TokenComma -> cont 44; + TokenPlus -> cont 45; + TokenCT happy_dollar_dollar -> cont 46; + TokenOT happy_dollar_dollar -> cont 47; + TokenProc happy_dollar_dollar -> cont 48; + _ -> happyError' (tk, []) + }) + +happyError_ explist 49 tk = happyError' (tk, explist) +happyError_ explist _ tk = happyError' (tk, explist) + +happyThen :: () => P a -> (a -> P b) -> P b +happyThen = (thenE) +happyReturn :: () => a -> P a +happyReturn = (returnE) +happyThen1 :: () => P a -> (a -> P b) -> P b +happyThen1 = happyThen +happyReturn1 :: () => a -> P a +happyReturn1 = happyReturn +happyError' :: () => ((Token), [String]) -> P a +happyError' tk = (\(tokens, _) -> parseError tokens) tk +dot = happySomeParser where + happySomeParser = happyThen (happyParse action_0) (\x -> case x of {HappyAbsSyn4 z -> happyReturn z; _other -> notHappyAtAll }) + +happySeq = happyDontSeq + + +data Except a = Success a | Failure String +type P a = String -> Int -> Except a + +thenE :: P a -> (a -> P b) -> P b +thenE m k s l = + case m s l of + Success a -> k a s l + Failure e -> Failure e + +returnE :: a -> P a +returnE a s l = Success a + +failE :: String -> P a +failE e s l = Failure $ "Error on line " ++ show l ++ ": " ++ e + +catchE :: P a -> (String -> P a) -> P a +catchE m k s l = case m s l of + Success a -> Success a + Failure e -> k e s l +getLineNumber s l = Success l +parseError :: Token -> P a +parseError t = getLineNumber `thenE` \line -> failE $ "Parse error on line " ++ show line ++ "." + +data Token = + TokenGraph + | TokenDigraph + | TokenNode + | TokenEdge + | TokenSubgraph + | TokenStrict + | TokenLabel String + | TokenQuotedLabel String + | TokenXML String + | TokenCompass Compass + | TokenArrow Char + | TokenEQ + | TokenOCB + | TokenCCB + | TokenOSB + | TokenCSB + | TokenCo + | TokenSemiCo + | TokenComma + | TokenCT String + | TokenOT String + | TokenProc String + | TokenPlus + | TokenEOF + deriving (Eq) + +instance Show Token where + show tk = case tk of + TokenGraph -> "graph" + TokenDigraph -> "digraph" + TokenNode -> "node" + TokenEdge -> "edge" + TokenSubgraph -> "subgraph" + TokenStrict -> "strict" + TokenLabel label -> label + TokenQuotedLabel label -> label + TokenXML xml -> xml + TokenCompass compass -> show compass + TokenArrow c -> [c] + TokenEQ -> "=" + TokenOCB -> "{" + TokenCCB -> "]" + TokenOSB -> "[" + TokenCSB -> "]" + TokenCo -> ":" + TokenSemiCo -> ";" + TokenComma -> "," + TokenCT tag -> "" + TokenOT tag -> "<" ++ tag ++ ">" + TokenProc xml -> "" + TokenPlus -> "+" + TokenEOF -> "" + +parse s = case dot ('\n':s) 0 of -- A newline is added to treat '#' in the beginning of a line properly. + Success ast -> Right ast + Failure msg -> Left msg + +toCompass l = + case map toLower l of + "n" -> Just $ North + "ne" -> Just $ NorthEast + "e" -> Just $ East + "se" -> Just $ SouthEast + "s" -> Just $ South + "sw" -> Just $ SouthWest + "w" -> Just $ West + "nw" -> Just $ NorthWest + "c" -> Just $ Center + "_" -> Nothing + _ -> Nothing + +lexer :: (Token -> (P a)) -> (P a) +lexer cont str line = case dropWhile (\c -> c /= '\n' && isSpace c) str of + '\n':'#':s' -> let s'' = dropWhile (/= '\n') s' in lexer cont s'' (line + 1) + '\n':s' -> lexer cont s' (line +1) + ',':s' -> cont TokenComma s' line + ';':s' -> cont TokenSemiCo s' line + 's':'u':'b':'g':'r':'a':'p':'h':s' -> cont TokenSubgraph s' line + 'g':'r':'a':'p':'h':s' -> cont TokenGraph s' line + 'd':'i':'g':'r':'a':'p':'h':s' -> cont TokenDigraph s' line + 'e':'d':'g':'e':s' -> cont TokenEdge s' line + 'n':'o':'d':'e':s' -> cont TokenNode s' line + 's':'t':'r':'i':'c':'t':s' -> cont TokenStrict s' line + '{':s' -> cont TokenOCB s' line + '}':s' -> cont TokenCCB s' line + '[':s' -> cont TokenOSB s' line + ']':s' -> cont TokenCSB s' line + '+':s' -> cont TokenPlus s' line + '=':s' -> cont TokenEQ s' line + ':':s' -> cont TokenCo s' line + '-':'-':s' -> cont (TokenArrow '-') s' line + '-':'>':s' -> cont (TokenArrow '>') s' line + '/':'/':s' -> let s'' = dropWhile (/= '\n') s' in lexer cont s'' line + '/':'*':s' -> let (s'', line') = execState consumeComment (s', line) + in lexer cont s'' (line') + '"':s' -> let (qs, (s'', line')) = runState consumeQuotedString (s', line) + in case qs of + Right string -> cont (TokenQuotedLabel string) s'' line' + Left msg -> failE msg s' line' + '<':'/':s' -> let (tag, (s'', line')) = runState consumeTag (s', line) + in cont (TokenCT tag) (tail s'') line' + '<':'!':'-':'-':s' -> let (s'', line') = execState consumeXMLComment (s', line) + in lexer cont s'' line' + '<':'?':s' -> let (proc, (s'', line')) = runState consumeProcessing (s', line) + in cont (TokenProc proc) s'' line' + [] -> cont TokenEOF [] line + s' -> let (label, s'') = span (\x -> not $ isSpace x || x `elem` ";,{}[]=\"") s' + in if null label then failE ("Unexpected character: " ++ [head s'']) s' line + else cont (TokenLabel label) s'' line + +--consumeToken = do +-- consumeWhile (\c -> isSpace c || c `elem` ";,") +-- t <- consumeSomeString -- TODO: This can be made faster by using a trie +-- [ ("subgraph", TokenSubgraph) +-- , ("graph", TokenGraph) +-- , ("digraph", TokenDigraph) +-- , ("edge", TokenEdge) +-- , ("node", TokenNode) +-- , ("strict", TokenStrict) +-- , ("{", TokenOCB) +-- , ("}", TokenCCB) +-- , ("[", TokenOSB) +-- , ("]", TokenCSB) +-- , ("+", TokenPlus) +-- , ("=", TokenEQ) +-- , (":", TokenCo) +-- , ("--", TokenArrow '-') +-- , ("->", TokenArrow '>')] +-- case t of +-- Just t' -> return t +-- Nothing -> do +-- action <- consumeSomeString +-- [ ('/':"/", consumeWhile (/= '\n') >> consumeToken) +-- , ('#', consumeWhile (/= '\n') >> consumeToken) +-- , ('/':"*", consumeComment >> consumeToken) +-- , ("\"", consumeQuotedString >>= (\s -> return (Just $ TokenLabel s))) +-- , (" x /= '>') +-- consumeOnce (=='>') +-- return $ Just $ TokenCT) +-- , ("