commit fa84ba406e4043f67069b8d059c63b92b1adf591 Author: xolatile Date: Sun Apr 27 02:32:20 2025 +0200 Nopping... diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..95a2355 --- /dev/null +++ b/.gitignore @@ -0,0 +1,2 @@ +xop + diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..e142a52 --- /dev/null +++ b/LICENSE @@ -0,0 +1,625 @@ +GNU GENERAL PUBLIC LICENSE + +Version 3, 29 June 2007 + +Copyright © 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/README.md b/README.md new file mode 100644 index 0000000..a5a8e38 --- /dev/null +++ b/README.md @@ -0,0 +1,21 @@ +# xop + +## xop -- Please don't use this program unless you're manually decoding machine code. + +Compile: `$ sh compile.sh` + +Install: `$ sudo sh install.sh` + +License: GNU/GPLv3 + +This library depends on (these libraries are included in static version of the program): +- xtandard: https://gitlab.com/xolatile/xtandard + +About this program: +- It is extremely slow, it's written to be generic and extensible, not language specific or optimized. +- Everything related to my libraries is clean of all warning options on GCC and Valgrind (hopefully). + +Use: +```bash +# xop this_or_that.bin +``` diff --git a/compile.sh b/compile.sh new file mode 100644 index 0000000..25070f9 --- /dev/null +++ b/compile.sh @@ -0,0 +1,7 @@ +#!/bin/bash + +set -xe + +gcc -std=gnu17 -w -Ofast -o xop xop.c + +exit diff --git a/install.sh b/install.sh new file mode 100644 index 0000000..88489cf --- /dev/null +++ b/install.sh @@ -0,0 +1,11 @@ +#!/bin/bash + +set -xe + +if [ -f xop ]; then + cp -f xop /usr/local/bin/xop +else + echo "Please run 'sh compile.sh' beforehand." +fi + +exit diff --git a/xop b/xop new file mode 100755 index 0000000..2ae5c2c Binary files /dev/null and b/xop differ diff --git a/xop.c b/xop.c new file mode 100755 index 0000000..f2b6748 --- /dev/null +++ b/xop.c @@ -0,0 +1,58 @@ +/// __ _____ _ __ +/// \ \/ / _ \| '_ \ +/// > < (_) | |_) | +/// /_/\_\___/| .__/ +/// |_| +/// +/// Copyright (c) 1997 - Ognjen 'xolatile' Milan Robovic +/// +/// xolatile@chud.cyou - xop - The evil within... +/// +/// This program is free software, free as in freedom and as in free beer, 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 any later version if you wish... +/// +/// This program is distributed in the hope that it will be useful, but it is probably not, and without any warranty, without even the implied +/// warranty of merchantability or fitness for a particular purpose, because it is pointless. Please see the GNU (Geenoo) General Public License +/// for more details, if you dare, it is a lot of text that nobody wants to read... + +#include "xtandard.h" + +static procedure echo_byte (natural_8 byte) { + output ("0123456789ABCDEF" + byte / 16, 1); + output ("0123456789ABCDEF" + byte % 16, 1); + + output (" ", 1); +} + +integer main (integer argc, character * * argv) { + integer file = 0; + natural_64 size = 0; + natural_8 * buffer = null; + + if (argc != 2) { + return (log_failure); + } + + file = file_open (argv [1], file_flag_read); + size = file_size (argv [1]); + + buffer = allocate (size * sizeof (* buffer)); + + file_read (file, buffer, size); + + file = file_close (file); + + for (natural_64 offset = 0; offset < size; ++offset) { + conditional_print (buffer [offset] == 0x90, "\n/B/1"); + + echo_byte (buffer [offset]); + + conditional_print (buffer [offset] == 0x90, "/-"); + } + + print ("\n"); + + buffer = deallocate (buffer); + + return (log_success); +} diff --git a/xtandard.h b/xtandard.h new file mode 100755 index 0000000..b4d592c --- /dev/null +++ b/xtandard.h @@ -0,0 +1,1238 @@ +/// _ _ _ +/// | | | | | | +/// __ _| |_ __ _ _ __ __| | __ _ _ __ __| | +/// \ \/ / __/ _` | '_ \ / _` |/ _` | '__/ _` | +/// > <| || (_| | | | | (_| | (_| | | | (_| | +/// /_/\_\\__\__,_|_| |_|\__,_|\__,_|_| \__,_| +/// +/// Copyright (c) 1997 - Ognjen 'xolatile' Milan Robovic +/// +/// xolatile@chud.cyou - xtandard - Tiny, safe and somewhat sane unity header for what GNU/Linux already provides. +/// +/// This program is free software, free as in freedom and as in free beer, 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 any later version if you wish... +/// +/// This program is distributed in the hope that it will be useful, but it is probably not, and without any warranty, without even the implied +/// warranty of merchantability or fitness for a particular purpose, because it is pointless. Please see the GNU (Geenoo) General Public License +/// for more details, if you dare, it is a lot of text that nobody wants to read... + +#define _GNU_SOURCE + +#include +#include +#include +#include +#include +#include +#include + +#define null ((generic *) 0) + +#define standard_input (STDIN_FILENO) +#define standard_output (STDOUT_FILENO) +#define standard_error (STDERR_FILENO) + +#define file_flag_read (O_RDONLY) +#define file_flag_write (O_WRONLY) +#define file_flag_edit (O_RDWR) +#define file_flag_create (O_CREAT) +#define file_flag_append (O_APPEND) +#define file_flag_truncate (O_TRUNC) + +#define file_seek_current (SEEK_CUR) +#define file_seek_set (SEEK_SET) +#define file_seek_end (SEEK_END) + +#define pstring_length (256) + +#define echo(text) output ((text), sizeof ((text)) - 1) + +#define maximum(x, y) (((x) > (y)) ? (x) : (y)) +#define minimum(x, y) (((x) < (y)) ? (x) : (y)) + +#define array_length(array) (sizeof ((array)) / sizeof (* (array))) + +typedef void procedure; +typedef void none; +typedef void generic; +typedef char character; +typedef float real; + +typedef signed int integer; +typedef unsigned int natural; + +typedef float real_32; +typedef double real_64; + +typedef signed char integer_8; +typedef signed short integer_16; +typedef signed int integer_32; +typedef signed long integer_64; + +typedef unsigned char natural_8; +typedef unsigned short natural_16; +typedef unsigned int natural_32; +typedef unsigned long natural_64; + +typedef char pstring [pstring_length]; + +typedef enum { + false, + true +} boolean; + +typedef enum { + log_success, log_warning, log_failure, log_comment, + log_count +} log_enumeration; + +typedef enum { + file_type_c_source, file_type_c_header, file_type_ada_sexy_body, file_type_ada_specification, + file_type_cpp_source, file_type_cpp_header, file_type_fortran_90_source, file_type_fortran_90_module, + file_type_pascal_source, file_type_d_source, file_type_go_source, file_type_jai_source, + file_type_assembly, file_type_eax_assembly, file_type_gnu_assembly, file_type_flat_assembly, + file_type_haskell_script, file_type_perl_script, file_type_cube_script, file_type_lua_script, + file_type_shell_script, file_type_python_script, file_type_tcl_script, file_type_forth_source, + file_type_text, file_type_markdown, file_type_html, file_type_glsl, + file_type_xrocessor, file_type_xhla, file_type_xcript, file_type_xocument, + file_type_xiri, file_type_xofya, file_type_xienna, file_type_xenka, + file_type_xiyagi, file_type_xoule, file_type_xikoku, file_type_xdo, + file_type_png_image, file_type_jxl_image, file_type_jpg_image, file_type_tga_image, + file_type_wav_sound, file_type_ogg_sound, file_type_flac_sound, file_type_mp3_sound, + file_type_obj_model, file_type_iqm_model, file_type_md5_model, file_type_ply_model, + file_type_elf_object, file_type_spir_v_bytecode, + file_type_count +} file_type_enumeration; + +typedef enum { + effect_normal, effect_bold, effect_italic, effect_undefined_code, + effect_underline, effect_blink, effect_reverse, effect_invisible_text, + effect_count +} effect_enumeration; + +typedef enum { + colour_grey, colour_red, colour_green, colour_yellow, + colour_blue, colour_pink, colour_cyan, colour_white, + colour_count +} colour_enumeration; + +typedef enum { + character_null, character_start_header, character_start_text, character_end_text, + character_end_transmission, character_enquiry, character_acknowledge, character_bell, + character_backspace, character_tab_horizontal, character_line_feed, character_tab_vertical, + character_form_feed, character_carriage_return, character_shift_out, character_shift_in, + character_data_link_escape, character_device_control_1, character_device_control_2, character_device_control_3, + character_device_control_4, character_not_acknowledge, character_synchronous_idle, character_end_transmission_block, + character_cancel, character_end_medium, character_substitute, character_escape, + character_file_separator, character_group_separator, character_record_separator, character_unit_separator +} character_enumeration; + +typedef enum { + cursor_none, + cursor_left, cursor_middle, cursor_right, + cursor_wheel_up, cursor_wheel_down, + cursor_count +} cursor_enumeration; + +typedef enum { + signal_none, + signal_a, signal_b, signal_c, signal_d, + signal_e, signal_f, signal_g, signal_h, + signal_i, signal_j, signal_k, signal_l, + signal_m, signal_n, signal_o, signal_p, + signal_q, signal_r, signal_s, signal_t, + signal_u, signal_v, signal_w, signal_x, + signal_y, signal_z, signal_0, signal_1, + signal_2, signal_3, signal_4, signal_5, + signal_6, signal_7, signal_8, signal_9, + signal_escape, signal_tabulator, signal_return, signal_new_line, + signal_slash, signal_backslash, signal_semicolon, signal_backquote, + signal_space, signal_backspace, signal_dot, signal_comma, + signal_cite, signal_caps_lock, signal_minus, signal_equal, + signal_left_bracket, signal_right_bracket, signal_left_control, signal_right_control, + signal_left_shift, signal_right_shift, signal_left_alt, signal_right_alt, + signal_f1, signal_f2, signal_f3, signal_f4, + signal_f5, signal_f6, signal_f7, signal_f8, + signal_f9, signal_f10, signal_f11, signal_f12, + signal_arrow_up, signal_arrow_down, signal_arrow_left, signal_arrow_right, + signal_num_lock, signal_pause_break, signal_insert, signal_home, + signal_page_up, signal_delete, signal_end, signal_page_down, + signal_key_add, signal_key_subtract, signal_key_multiply, signal_key_divide, + signal_key_enter, signal_key_dot, signal_key_0, signal_key_1, + signal_key_2, signal_key_3, signal_key_4, signal_key_5, + signal_key_6, signal_key_7, signal_key_8, signal_key_9, + signal_count +} signal_enumeration; + +static character * cursor_name [cursor_count] = { + "---", + "Left button", "Middle button", "Right button", + "Scroll up", "Scroll down" + +}; + +static character * signal_name [signal_count] = { + "---", + "A", "B", "C", "D", + "E", "F", "G", "H", + "I", "J", "K", "L", + "M", "N", "O", "P", + "Q", "R", "S", "T", + "U", "V", "W", "X", + "Y", "Z", "0", "1", + "2", "3", "4", "5", + "6", "7", "8", "9", + "Escape", "Tabulator", "Return", "New line", + "Slash", "Backslash", "Semicolon", "Backquote", + "Space", "Backspace", "Dot", "Comma", + "Cite", "Caps lock", "Minus", "Equal", + "Left bracket", "Right bracket", "Left control", "Right control", + "Left shift", "Right shift", "Left alt", "Right alt", + "F1", "F2", "F3", "F4", + "F5", "F6", "F7", "F8", + "F9", "F10", "F11", "F12", + "Arrow up", "Arrow down", "Arrow left", "Arrow right", + "Num lock", "Pause break", "Insert", "Home", + "Page up", "Delete", "End", "Page down", + "Key add", "Key subtract", "Key multiply", "Key divide", + "Key enter", "Key dot", "Key 0", "Key 1", + "Key 2", "Key 3", "Key 4", "Key 5", + "Key 6", "Key 7", "Key 8", "Key 9" +}; + +static procedure random_integer_seed_by_time (none) { + srand ((natural) time (null)); +} + +static integer random_integer (integer from, integer to) { + return (rand () % (to - from + 1) + from); +} + +static natural random_natural (natural from, natural to) { + return ((natural) rand () % (to - from + 1) + from); +} + +static real random_real (real from, real to) { + return (((real) rand () / (real) RAND_MAX) * (to - from) + from); +} + +static procedure input (generic * data, natural_64 size) { + read (standard_input, data, size); +} + +static procedure output (generic * data, natural_64 size) { + write (standard_output, data, size); +} + +static procedure clean_up (procedure (* procedure_pointer) (none)) { + atexit (procedure_pointer); +} + +#ifdef use_fatal_failure +static procedure fatal_failure (boolean condition, character * message) { + if (condition == true) { + echo ("[\x1b[1;31m FATAL \x1b[0m] "); + + for (integer index = 0; message [index] != '\0'; ++index) { + output (& message [index], 1); + } + + echo ("\n"); + + exit (log_failure); + } +} +#else +#define fatal_failure(...) +#endif + +static procedure execute (character * command) { + integer status = 0; + + system (command); + + fatal_failure (status != 0, "execute: System returned an error code."); +} + +static natural tick_tock (none) { + return ((natural) clock ()); +} + +static natural_64 nano_time (none) { + struct timespec time = { 0 }; + + natural_64 result = 0; + + clock_gettime (CLOCK_MONOTONIC, & time); + + result = 1000000000ul * (natural_64) time.tv_sec + (natural_64) time.tv_nsec; + + return (result); +} + +static procedure nano_wait (natural_64 time) { + struct timespec wait = { + time / 1000000000, + time % 1000000000 + }; + + while (nanosleep (& wait, null)) continue; +} + +static procedure exchange_integer (integer * a, integer * b) { integer c = * a; * a = * b; * b = c; } +static procedure exchange_natural (natural * a, natural * b) { natural c = * a; * a = * b; * b = c; } +static procedure exchange_real (real * a, real * b) { real c = * a; * a = * b; * b = c; } + +static procedure clamp_integer (integer * x, integer lower, integer upper) { if (* x < lower) * x = lower; if (* x > upper) * x = upper; } +static procedure clamp_natural (natural * x, natural lower, natural upper) { if (* x < lower) * x = lower; if (* x > upper) * x = upper; } +static procedure clamp_real (real * x, real lower, real upper) { if (* x < lower) * x = lower; if (* x > upper) * x = upper; } + +static real normal_r (natural colour) { return ((real) ((colour >> 24) & 0xff) / 255.0f); } +static real normal_g (natural colour) { return ((real) ((colour >> 16) & 0xff) / 255.0f); } +static real normal_b (natural colour) { return ((real) ((colour >> 8) & 0xff) / 255.0f); } +static real normal_a (natural colour) { return ((real) ((colour >> 0) & 0xff) / 255.0f); } + +static natural channel_r (natural colour) { return ((colour >> 24) & 0xff); } +static natural channel_g (natural colour) { return ((colour >> 16) & 0xff); } +static natural channel_b (natural colour) { return ((colour >> 8) & 0xff); } +static natural channel_a (natural colour) { return ((colour >> 0) & 0xff); } + +static natural colour_channel_reverse (natural colour) { + natural r = channel_r (colour); + natural g = channel_g (colour); + natural b = channel_b (colour); + natural a = channel_a (colour); + + return ((a << 24) | (b << 16) | (g << 8) | (r << 0)); +} + +static natural colour_linear_interpolation (natural colour_a, natural colour_b, real scale) { + if (scale <= 0.0f) { + return (colour_a); + } + + if (scale >= 1.0f) { + return (colour_b); + } + + natural r = (natural) ((1.0f - scale) * channel_r (colour_a) + scale * channel_r (colour_b)); + natural g = (natural) ((1.0f - scale) * channel_g (colour_a) + scale * channel_g (colour_b)); + natural b = (natural) ((1.0f - scale) * channel_b (colour_a) + scale * channel_b (colour_b)); + natural a = (natural) ((1.0f - scale) * channel_a (colour_a) + scale * channel_a (colour_b)); + + return ((r << 24) | (g << 16) | (b << 8) | (a << 0)); +} + +static generic * allocate (natural_64 size) { + character * data = null; + + fatal_failure (size <= 0, "allocate: Size is equal or below zero."); + + data = calloc (size, sizeof (* data)); + + fatal_failure (data == null, "allocate: Function 'calloc' returned null pointer."); + + return (data); +} + +static generic * reallocate (generic * data, natural_64 size) { + fatal_failure (size <= 0, "reallocate: Size is equal or below zero."); + + data = realloc (data, size); + + fatal_failure (data == null, "reallocate: Function 'realloc' returned null pointer."); + + return (data); +} + +static generic * deallocate (generic * data) { + fatal_failure (data == null, "deallocate: Data is null pointer."); + + free (data); + + return (null); +} + +static generic * record (none) { + character * buffer = null; + natural_64 offset = 0; + natural_64 memory = 64 * 1024; + + buffer = reallocate (buffer, memory); + + do { + if ((offset + 1) % memory == 0) { + buffer = reallocate (buffer, ((offset + 1) / memory + 1) * memory); + } + + buffer [offset] = '\0'; + + input (& buffer [offset], sizeof (* buffer)); + + ++offset; + } while (buffer [offset - 1] != '\0'); + + buffer [offset - 1] = '\0'; + + return (buffer); +} + +static boolean character_compare_array (character c, character * character_array) { + for (natural_64 index = 0; character_array [index] != '\0'; ++index) { + if (c == character_array [index]) { + return (true); + } + } + + return (false); +} + +static boolean character_is_uppercase (character c) { + return ((c >= 'A') && (c <= 'Z')); +} + +static boolean character_is_lowercase (character c) { + return ((c >= 'a') && (c <= 'z')); +} + +static boolean character_is_digit (character c) { + return ((c >= '0') && (c <= '9')); +} + +static boolean character_is_letter (character c) { + return (((c >= 'A') && (c <= 'Z')) || ((c >= 'a') && (c <= 'z'))); +} + +static boolean character_is_blank (character c) { + return ((c == ' ') || (c == '\t') || (c == '\r') || (c == '\n')); +} + +static boolean character_is_symbol (character c) { + return (((c >= '!') && (c <= '/')) || ((c >= ':') && (c <= '@')) || ((c >= '[') && (c <= '`')) || ((c >= '{') && (c <= '~'))); +} + +static boolean character_is_separator (character c) { + return ((c != '_') && ((character_is_blank (c) == true) || (character_is_symbol (c) == true))); +} + +static boolean character_is_identifier (character c) { + return ((c == '_') || (character_is_letter (c) == true) || (character_is_digit (c) == true)); +} + +static boolean character_is_visible (character c) { + return ((c >= '!') && (c <= '~')); +} + +static boolean character_is_invisible (character c) { + return (character_is_visible (c) == false); +} + +static character * capitalize (character * string) { + fatal_failure (string == null, "capitalize: String is null pointer."); + + string [0] -= (character_is_lowercase (string [0]) == true) ? ' ' : '\0'; + + return (string); +} + +static character * uppercase (character * string) { + fatal_failure (string == null, "uppercase: String is null pointer."); + + for (natural index = 0; string [index] != '\0'; ++index) { + string [index] += (character_is_lowercase (string [index]) == true) ? ' ' : '\0'; + } + + return (string); +} + +static character * lowercase (character * string) { + fatal_failure (string == null, "lowercase: String is null pointer."); + + for (natural index = 0; string [index] != '\0'; ++index) { + string [index] -= (character_is_uppercase (string [index]) == true) ? ' ' : '\0'; + } + + return (string); +} + +static natural_64 string_length (character * string) { + natural_64 length = 0; + + fatal_failure (string == null, "string_length: String is null pointer."); + + for (length = 0; string [length] != '\0'; ++length); + + return (length); +} + +static character * string_nullify (character * destination, natural_64 length) { + fatal_failure (destination == null, "string_reverse_limit: Destination string is null pointer."); + fatal_failure (length <= 0, "string_reverse_limit: Length is equal or below zero."); + + for (natural_64 index = 0; index < length; ++index) { + destination [index] = '\0'; + } + + return (destination); +} + +static character * string_reverse_limit (character * destination, natural_64 limit) { + fatal_failure (destination == null, "string_reverse_limit: Destination string is null pointer."); + fatal_failure (limit <= 0, "string_reverse_limit: Limit is equal or below zero."); + + for (natural_64 index = 0; index < limit / 2; ++index) { + character temporary = destination [index]; + + destination [index] = destination [limit - 1 - index]; + destination [limit - 1 - index] = temporary; + } + + return (destination); +} + +static character * string_reverse (character * destination) { + return (string_reverse_limit (destination, string_length (destination))); +} + +static boolean string_compare_limit (character * string_a, character * string_b, natural_64 limit) { + fatal_failure (string_a == null, "string_compare_limit: First source string is null pointer."); + fatal_failure (string_b == null, "string_compare_limit: Second source string is null pointer."); + fatal_failure (limit <= 0, "string_compare_limit: Limit is equal or below zero."); + + for (natural_64 index = 0; index < limit; ++index) { + if (string_a [index] != string_b [index]) { + return (false); + } + } + + return (true); +} + +static boolean string_compare (character * string_a, character * string_b) { + return (string_compare_limit (string_a, string_b, string_length (string_a) + 1)); +} + +static character * string_copy_limit (character * destination, character * source, natural_64 limit) { + fatal_failure (destination == null, "string_copy_limit: Destination string is null pointer."); + fatal_failure (source == null, "string_copy_limit: Source string is null pointer."); + fatal_failure (limit <= 0, "string_copy_limit: Limit is equal or below zero."); + + for (natural_64 index = 0; index < limit; ++index) { + destination [index] = source [index]; + } + + return (destination); +} + +static character * string_copy (character * destination, character * source) { + return (string_copy_limit (destination, source, string_length (source) + 1)); +} + +static character * string_concatenate_limit (character * destination, character * source, natural_64 limit) { + natural_64 offset = string_length (destination); + + fatal_failure (destination == null, "string_concatenate_limit: Destination string is null pointer."); + fatal_failure (source == null, "string_concatenate_limit: Source string is null pointer."); + fatal_failure (limit <= 0, "string_concatenate_limit: Limit is equal or below zero."); + + for (natural_64 index = 0; index < limit; ++index) { + destination [offset + index] = source [index]; + } + + return (destination); +} + +static character * string_concatenate (character * destination, character * source) { + return (string_concatenate_limit (destination, source, string_length (source) + 1)); +} + +static character * string_duplicate (character * source) { + character * duplicate = allocate ((string_length (source) + 1) * sizeof (* duplicate)); + + string_copy (duplicate, source); + + return (duplicate); +} + +static character * string_duplicate_limit (character * source, natural limit) { + character * duplicate = allocate ((limit + 1) * sizeof (* duplicate)); + + string_copy_limit (duplicate, source, limit); + + return (duplicate); +} + +static character * string_align_left (character * destination, natural_64 amount, character with) { + for (natural_64 offset = string_length (destination); offset < amount; ++offset) { + destination [offset] = with; + } + + destination [amount] = '\0'; + + return (destination); +} + +static character * string_remove_extension (character * destination) { + natural_64 length = string_length (destination); + + for (--length; destination [length] != '.'; --length); + + destination [length] = '\0'; + + return (destination); +} + +static procedure memory_nullify (generic * memory, natural_64 size) { + character * cast = (character *) memory; + + fatal_failure (memory == null, "memory_nullify: Memory is null pointer."); + + for (natural_64 offset = 0; offset < size; ++offset) { + cast [offset] = (character) 0; + } +} + +static integer memory_compare (generic * memory_0, generic * memory_1, natural_64 size) { + character * cast_0 = (character *) memory_0; + character * cast_1 = (character *) memory_1; + + fatal_failure (memory_0 == null, "memory_compare: Memory is null pointer."); + fatal_failure (memory_1 == null, "memory_compare: Source is null pointer."); + + for (natural_64 offset = 0; offset < size; ++offset) { + if (cast_0 [offset] != cast_1 [offset]) { + return (false); + } + } + + return (true); +} + +static procedure memory_copy (generic * destination, generic * source, natural_64 size) { + character * cast_0 = ( character *) destination; + character * cast_1 = (character *) source; + + fatal_failure (destination == null, "memory_copy: Destination is null pointer."); + fatal_failure (source == null, "memory_copy: Source is null pointer."); + + for (natural_64 offset = 0; offset < size; ++offset) { + cast_0 [offset] = cast_1 [offset]; + } +} + +static procedure echo_clear (none) { + echo ("\033[2J\033[H"); +} + +static procedure echo_colour (colour_enumeration colour, effect_enumeration effect) { + character format [8] = "\033[ ;3 m"; + + format [2] = (character) (effect % effect_count) + '0'; + format [5] = (character) (colour % colour_count) + '0'; + + echo (format); +} + +static procedure echo_cancel (none) { + echo ("\033[0m"); +} + +static procedure show_cursor (boolean show) { + if (show == true) { + echo ("\033[?25h"); + } else { + echo ("\033[?25l"); + } +} + +static integer file_open (character * path, integer mode) { + fatal_failure (path == null, "file_open: File path is null pointer."); + + return (open (path, mode, 0777)); +} + +static integer file_close (integer file) { + fatal_failure (file == -1, "file_close: Invalid file descriptor."); + + close (file); + + return (-1); +} + +static procedure file_read (integer file, generic * data, natural_64 size) { + fatal_failure (file <= -1, "file_read: File descriptor is closed or invalid."); + fatal_failure (data == null, "file_read: Data is null pointer."); + fatal_failure (size == 0, "file_read: Size is zero."); + + read (file, data, size); +} + +static procedure file_write (integer file, generic * data, natural_64 size) { + fatal_failure (file <= -1, "file_write: File descriptor is closed or invalid."); + fatal_failure (data == null, "file_write: Data is null pointer."); + fatal_failure (size == 0, "file_write: Size is zero."); + + write (file, data, size); +} + +static procedure file_echo (integer file, character * data) { + file_write (file, data, string_length (data)); +} + +static natural_64 file_seek (integer file, integer whence) { + fatal_failure (file == -1, "file_seek: Invalid file descriptor."); + + return ((natural_64) lseek (file, 0, whence)); +} + +static natural_64 file_size (character * path) { + struct stat data = { 0 }; + + fatal_failure (path == null, "file_size: File path is null pointer."); + + lstat (path, & data); + + return ((natural_64) data.st_size); +} + +static boolean file_exists (character * path) { + fatal_failure (path == null, "file_record: File path is null pointer."); + + return ((access (path, F_OK) == 0) ? true : false); +} + +static file_type_enumeration file_type (character * path) { + character * extensions [file_type_count] = { + ".c", ".h", ".adb", ".ads", ".cpp", ".hpp", ".f90", ".mod", + ".pas", ".d", ".go", ".jai", ".asm", ".eax", ".gas", ".fasm", + ".hs", ".el", ".cfg", ".lua", ".sh", ".py", ".tcl", ".4th", + ".txt", ".md", ".html", ".glsl", ".x", ".xhla", ".xs", ".xd", + ".xiri", ".xofya", ".xienna", ".xenka", ".xiyagi", ".xoule", ".xikoku", ".xdo", + ".png", ".jxl", ".jpg", ".tga", ".wav", ".ogg", ".flac", ".mp3", + ".obj", ".iqm", ".md5", ".ply", ".o", ".spv" + }; + + natural cut_at = 0; + + fatal_failure ((path == null) || (* path == '\0'), "file_type: File path is null pointer."); + + for (cut_at = string_length (path) - 1; cut_at != 0; --cut_at) { + if (path [cut_at] == '.') break; + } + + for (file_type_enumeration type = 0; type != file_type_count; ++type) { + if (string_compare (& path [cut_at], extensions [type])) { + return (type); + } + } + + return (file_type_count); +} + +static procedure file_remove (character * path) { + unlink (path); +} + +static generic * file_record (character * path) { + integer file = -1; + natural_64 size = 0; + character * data = null; + + fatal_failure (path == null, "file_record: File path is null pointer."); + + file = file_open (path, file_flag_read); + size = file_size (path); + data = allocate (size); + + file_read (file, data, size); + + file = file_close (file); + + return (data); +} + +static character * file_import (character * path) { + integer file = -1; + natural_64 size = 0; + character * data = null; + + fatal_failure (path == null, "file_import: File path is null pointer."); + + file = file_open (path, file_flag_edit); + size = file_size (path) + 1; + data = allocate (size); + + file_read (file, data, size - 1); + + data [size - 1] = '\0'; + + file = file_close (file); + + return (data); +} + +static procedure file_export (character * path, character * data) { + integer file = -1; + + fatal_failure (path == null, "file_export: File path is null pointer."); + fatal_failure (data == null, "file_export: Data is null pointer."); + + file = file_open (path, file_flag_write | file_flag_create | file_flag_truncate); + + file_write (file, data, string_length (data)); + + file = file_close (file); +} + +static generic * folder_open (character * path) { + DIR * folder = null; + + fatal_failure (path == null, "folder_open: Folder path is null pointer."); + + folder = opendir (path); + + return ((generic *) folder); +} + +static character * folder_read (generic * handle) { + struct dirent * file = null; + + DIR * folder = (DIR *) handle; + + fatal_failure (handle == null, "folder_read: Folder handle is null pointer."); + + file = readdir (folder); + + if (file == null) { + return (null); + } else { + return (file->d_name); + } +} + +static generic * folder_close (generic * handle) { + DIR * folder = (DIR *) handle; + + fatal_failure (handle == null, "folder_read: Folder handle is null pointer."); + + closedir (folder); + + return (null); +} + +static character * * folder_create_path_list (character * folder, natural * path_count, boolean sort) { + procedure * handle = null; + character * * path_array = 0; + + (none) sort; + + fatal_failure (folder == null, "folder_create_path_list: Folder handle is null pointer."); + fatal_failure (path_count == null, "folder_create_path_list: Path count address is null pointer."); + + handle = folder_open (folder); + + for (character * path = folder_read (handle); path != null; path = folder_read (handle)) { + if (path [0] != '.') { + (* path_count) += 1; + + path_array = reallocate (path_array, (* path_count) * sizeof (* path_array)); + + path_array [(* path_count) - 1] = allocate ((string_length (path) + 1) * sizeof (* * path_array)); + + string_copy (path_array [(* path_count) - 1], path); + } + } + + handle = folder_close (handle); + + return (path_array); +} + +static character * * folder_remove_path_list (character * * path_array, natural path_count) { + for (natural index = 0; index < path_count; ++index) { + path_array [index] = deallocate (path_array [index]); + } + + return (deallocate (path_array)); +} + +static character * configuration_format (character * path) { + static character buffer [512] = ""; + + string_copy (buffer, getenv ("HOME")); + string_concatenate (buffer, "/.config/xolatile/"); + string_concatenate (buffer, path); + + return (buffer); +} + +static boolean configuration_exists (character * path) { + return (file_exists (configuration_format (path))); +} + +static procedure configuration_remove (character * path) { + file_remove (configuration_format (path)); +} + +static character * configuration_import (character * path) { + return (file_import (configuration_format (path))); +} + +static procedure configuration_export (character * path, character * data) { + file_export (configuration_format (path), data); +} + +static boolean argument_compare (character * argument, character * short_option, character * long_option) { + return ((string_compare (argument, short_option) == true) || (string_compare (argument, long_option) == true)); +} + +static natural string_full_width (character * string, natural tab_width) { + natural width = 0; + natural count = 0; + + do { + if (* string == '\t') { + count += tab_width; + } else if (* string == '\n') { + width = (++count > width) ? count : width; + count = 0; + } else { + ++count; + } + } while (* (++string) != '\0'); + + return (width - 1); +} + +static natural string_full_height (character * string) { + natural height = 0; + + do { + if (* string == '\n') { + ++height; + } + } while (* (++string) != '\0'); + + return (height + 1); +} + +static natural string_limit_to_number (character * string, natural limit) { + natural number = 0; + + for (natural index = 0; (string [index] != '\0') && (index < limit); ++index) { + number *= 10; + number += (natural) (string [index] - '0'); + } + + return (number); +} + +static natural string_to_number (character * string) { + return (string_limit_to_number (string, string_length (string))); +} + +static character * number_to_string (integer number) { + static character string [34] = ""; + + natural index = 0; + boolean sign = false; + + string_nullify (string, sizeof (string)); + + if (number == 0) { + string [0] = '0'; + string [1] = '\0'; + return (string); + } + + if (number < 0) { + number *= -1; + sign = true; + } else { + sign = false; + } + + for (index = 0; (number != 0) && (index < (natural) sizeof (string) - 1); ++index) { + string [index] = (character) (number % 10) + '0'; + number /= 10; + } + + if (sign == true) { + string [index] = '-'; + ++index; + } + + string [index] = '\0'; + + string_reverse (string); + + return (string); +} + +static character * format_to_string (integer number, boolean sign, natural base, natural_64 amount, character with) { + static character string [36]; + + integer i; + + string_nullify (string, sizeof (string)); + + if (number == 0) { + string [0] = '0'; + string [1] = '\0'; + + string_align_left (string, amount, with); + + return (string); + } + + if (number < 0) { + number *= -1; + } + + for (i = (string [0] == '-'); number != 0; ++i) { + string [i] = "0123456789ABCDEF" [number % base]; + number /= base; + } + + if (sign == true) { + string [i] = '-'; + ++i; + } + + string [i] = '\0'; + + string_reverse (string); + + string_align_left (string, amount, with); + + return (string); +} + +static character * format (character * base, ...) { + static character string [1024]; + + va_list list; + + string_nullify (string, 1024); + + va_start (list, base); + + for (; * base != character_null; ++base) { + switch (* base) { + case ('%'): { + ++base; + switch (* base) { + case ('%'): string_concatenate (string, "%"); break; + case ('i'): string_concatenate (string, number_to_string (va_arg (list, integer))); break; + case ('s'): string_concatenate (string, va_arg (list, character *)); break; + default: string_concatenate (string, "?"); break; + } + } break; + default: { + string_concatenate_limit (string, base, 1); + } break; + } + } + + va_end (list); + + return (string); +} + +static procedure print (character * format, ...) { + va_list list; + + va_start (list, format); + + for (; * format != character_null; ++format) { + switch (* format) { + case ('%'): { + ++format; + switch (* format) { + case ('%'): { + output ("%", 1); + } break; + case ('i'): { + character * string = number_to_string (va_arg (list, integer)); + output (string, string_length (string)); + } break; + case ('f'): { + real data = (real) va_arg (list, real_64); + character * upper = number_to_string ((integer) data); + character * lower = number_to_string ((integer) (data * 1000.0f) % 1000); + output (upper, string_length (upper)); + output (".", 1); + output (lower, string_length (lower)); + } break; + case ('t'): { + integer data = (va_arg (list, integer)); + echo_colour ((data == true) ? colour_green : colour_red, effect_normal); + output ((data == true) ? "+" : "-", 1); + echo_cancel (); + } break; + case ('b'): { + integer data = (va_arg (list, integer)); + output ((data == true) ? "true" : "false", (data == true) ? 4 : 5); + } break; + case ('c'): { + character data = (character) va_arg (list, integer); + output (& data, 1); + } break; + case ('s'): { + character * data = va_arg (list, character *); + output (data, string_length (data)); + } break; + default: { + output ("?", 1); + } break; + } + } break; + case ('/'): { + ++format; + switch (* format) { + case ('/'): echo ("/"); break; + case ('s'): echo ("[\x1b[1;32mSuccess\x1b[0m]"); break; + case ('f'): echo ("[\x1b[1;31mFailure\x1b[0m]"); break; + case ('w'): echo ("[\x1b[1;33mWarning\x1b[0m]"); break; + case ('c'): echo ("[\x1b[1;30mComment\x1b[0m]"); break; + case ('A'): echo ("\x1b[0m"); break; + case ('B'): echo ("\x1b[1m"); break; + case ('C'): echo ("\x1b[2m"); break; + case ('D'): echo ("\x1b[3m"); break; + case ('E'): echo ("\x1b[4m"); break; + case ('F'): echo ("\x1b[5m"); break; + case ('G'): echo ("\x1b[6m"); break; + case ('H'): echo ("\x1b[7m"); break; + case ('0'): echo ("\x1b[30m"); break; + case ('1'): echo ("\x1b[31m"); break; + case ('2'): echo ("\x1b[32m"); break; + case ('3'): echo ("\x1b[33m"); break; + case ('4'): echo ("\x1b[34m"); break; + case ('5'): echo ("\x1b[35m"); break; + case ('6'): echo ("\x1b[36m"); break; + case ('7'): echo ("\x1b[37m"); break; + case ('-'): echo ("\x1b[0m"); break; + default: echo ("?"); break; + } + } break; + default: { + output (format, 1); + } break; + } + } + + va_end (list); +} + +static procedure conditional_print (boolean condition, character * format, ...) { + va_list list; + + if (condition == false) return; + + va_start (list, format); + + for (; * format != character_null; ++format) { + switch (* format) { + case ('%'): { + ++format; + switch (* format) { + case ('%'): { + output ("%", 1); + } break; + case ('i'): { + character * string = number_to_string (va_arg (list, integer)); + output (string, string_length (string)); + } break; + case ('f'): { + real data = (real) va_arg (list, real_64); + character * upper = number_to_string ((integer) data); + character * lower = number_to_string ((integer) (data * 1000.0f) % 1000); + output (upper, string_length (upper)); + output (".", 1); + output (lower, string_length (lower)); + } break; + case ('t'): { + integer data = (va_arg (list, integer)); + echo_colour ((data == true) ? colour_green : colour_red, effect_normal); + output ((data == true) ? "+" : "-", 1); + echo_cancel (); + } break; + case ('b'): { + integer data = (va_arg (list, integer)); + output ((data == true) ? "true" : "false", (data == true) ? 4 : 5); + } break; + case ('c'): { + character data = (character) va_arg (list, integer); + output (& data, 1); + } break; + case ('s'): { + character * data = va_arg (list, character *); + output (data, string_length (data)); + } break; + default: { + output ("?", 1); + } break; + } + } break; + case ('/'): { + ++format; + switch (* format) { + case ('/'): echo ("/"); break; + case ('s'): echo ("[\x1b[1;32mSuccess\x1b[0m]"); break; + case ('f'): echo ("[\x1b[1;31mFailure\x1b[0m]"); break; + case ('w'): echo ("[\x1b[1;33mWarning\x1b[0m]"); break; + case ('c'): echo ("[\x1b[1;30mComment\x1b[0m]"); break; + case ('A'): echo ("\x1b[0m"); break; + case ('B'): echo ("\x1b[1m"); break; + case ('C'): echo ("\x1b[2m"); break; + case ('D'): echo ("\x1b[3m"); break; + case ('E'): echo ("\x1b[4m"); break; + case ('F'): echo ("\x1b[5m"); break; + case ('G'): echo ("\x1b[6m"); break; + case ('H'): echo ("\x1b[7m"); break; + case ('0'): echo ("\x1b[30m"); break; + case ('1'): echo ("\x1b[31m"); break; + case ('2'): echo ("\x1b[32m"); break; + case ('3'): echo ("\x1b[33m"); break; + case ('4'): echo ("\x1b[34m"); break; + case ('5'): echo ("\x1b[35m"); break; + case ('6'): echo ("\x1b[36m"); break; + case ('7'): echo ("\x1b[37m"); break; + case ('-'): echo ("\x1b[0m"); break; + default: echo ("?"); break; + } + } break; + default: { + output (format, 1); + } break; + } + } + + va_end (list); +} + +#ifdef use_mathematics + +#include + +#define pi (3.14159265f) + +static real sign (real x) { return ((x > 0.0f) ? + 1.0f : - 1.0f); } +static real binary_sign (natural x) { return ((x > 0) ? + 1.0f : - 1.0f); } + +static real square_root (real x) { return (sqrtf (x)); } +static real cube_root (real x) { return (cbrtf (x)); } + +static real sine (real x) { return (sinf (x)); } +static real cosine (real x) { return (cosf (x)); } +static real tangent (real x) { return (tanf (x)); } + +static real arc_sine (real x) { return (asinf (x)); } +static real arc_cosine (real x) { return (acosf (x)); } +static real arc_tangent (real x) { return (atanf (x)); } + +static real cosecant (real x) { return (1.0f / sinf (x)); } +static real secant (real x) { return (1.0f / cosf (x)); } +static real cotangent (real x) { return (1.0f / tanf (x)); } + +#endif