commit 016ed8ff6cc00641fdea455c1d4a9281d4f0c481 Author: Lukas Wurzinger Date: Mon Feb 8 17:07:25 2021 +0100 initial commit diff --git a/.clang-format b/.clang-format new file mode 100644 index 0000000..fc8de88 --- /dev/null +++ b/.clang-format @@ -0,0 +1,37 @@ +AlignConsecutiveMacros: true +AlignEscapedNewlines: Left +AllowShortBlocksOnASingleLine: false +AllowShortCaseLabelsOnASingleLine: false +AllowShortFunctionsOnASingleLine: All +AllowShortIfStatementsOnASingleLine: false +AllowShortLoopsOnASingleLine: false +AlwaysBreakAfterDefinitionReturnType: All +AlwaysBreakAfterReturnType: None +BasedOnStyle: LLVM +BreakBeforeBinaryOperators: None +BreakBeforeBraces: Linux +BreakBeforeInheritanceComma: false +BreakBeforeTernaryOperators: true +BreakStringLiterals: false +ColumnLimit: 0 +IncludeBlocks: Regroup +IncludeCategories: + - Regex: '^<.*>$' + Priority: 1 + - Regex: '^".*"$' + Priority: 2 +IndentCaseLabels: false +IndentWidth: 8 +PointerAlignment: Right +ReflowComments: true +SortIncludes: true +SortUsingDeclarations: true +SpaceBeforeParens: ControlStatements +SpaceInEmptyParentheses: false +SpacesBeforeTrailingComments: 1 +SpacesInContainerLiterals: true +SpacesInCStyleCastParentheses: false +SpacesInParentheses: false +SpacesInSquareBrackets: false +TabWidth: 8 +UseTab: ForIndentation diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..64c24d3 --- /dev/null +++ b/.gitignore @@ -0,0 +1,9 @@ +*.o +libreadopt.a +libreadopt.so +test/test +test/*.o +.ninja_deps +.ninja_log +test/.ninja_deps +test/.ninja_log diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..f288702 --- /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/Makefile b/Makefile new file mode 100644 index 0000000..77408a3 --- /dev/null +++ b/Makefile @@ -0,0 +1,52 @@ +CC = cc +MACROS = -DNDEBUG +CFLAGS = $(MACROS) --std=c99 -O2 -g -Wall -Wextra -Wpedantic -fPIC + +PREFIX = /usr/local/ +LIB = $(PREFIX)/lib/ +INCLUDE = $(PREFIX)/include/ + +SOURCES = $(wildcard ./*.c) +OBJECTS = $(SOURCES:.c=.o) +HEADERS = $(wildcard ./*.h) + +STATICTARGET = libreadopt.a +SHAREDTARGET = libreadopt.so + +AR = ar -rcs -- +RM = rm -f -- +CP = cp -- +MKDIR = mkdir -p -- + +all: $(STATICTARGET) $(SHAREDTARGET) + +%.o: %.c + $(CC) -c $(CFLAGS) $< + +$(STATICTARGET): $(OBJECTS) + $(AR) $@ $^ + +$(SHAREDTARGET): $(OBJECTS) + $(CC) --shared $^ -o $@ + +install: staticinstall sharedinstall + +staticinstall: $(STATICTARGET) + $(MKDIR) $(DESTDIR)$(LIB) + $(CP) $^ $(DESTDIR)$(LIB) + $(MKDIR) $(DESTDIR)$(INCLUDE) + $(CP) $(HEADERS) $(DESTDIR)$(INCLUDE) + +sharedinstall: $(SHAREDTARGET) + $(MKDIR) $(DESTDIR)$(LIB) + $(CP) $^ $(DESTDIR)$(LIB) + $(MKDIR) $(DESTDIR)$(INCLUDE) + $(CP) $(HEADERS) $(DESTDIR)$(INCLUDE) + +clean: + $(RM) $(OBJECTS) $(STATICTARGET) $(SHAREDTARGET) + +format: + clang-format -i -- $(SOURCES) $(HEADERS) + +.PHONY: clean install staticinstall sharedinstall format diff --git a/README.md b/README.md new file mode 100644 index 0000000..8c73e53 --- /dev/null +++ b/README.md @@ -0,0 +1,46 @@ +# readopt + +## Overview + +This is an option parsing library. + +The following option formats are recognized: +* `-f` +* `-fvalue` +* `-f value` +* `-asdf` (grouped short options) +* `-asdfvalue` +* `-asdf value` +* `--file` +* `--file value` +* `--file=value` +* `-f value1 -f value2 ...` (multiple values are represented in an array) +* `-f value1 operand1 -f value2 operand2` (operands intermixed with options) + +It permutes `argv` to handle multiple values for each option and to assign +values to operands. + +`mdoc(7)` `SYNOPSIS` sections and plaintext usage messages can be generated as +well (via `readoptPutUsage`). + +An example can be found in `test/test.c`. + +## Building + +Build and install the library by either using + +``` +$ ninja +# ninja install +``` + +or + +``` +$ make +# make install +``` + +By default, the library will be installed to `/usr/local/lib`, which may not be +in your library path. You can change this by modifying the `$prefix` in the +`config.ninja` or by overriding the `$(PREFIX)` variable for the `Makefile`. diff --git a/build.ninja b/build.ninja new file mode 100644 index 0000000..e27c4e9 --- /dev/null +++ b/build.ninja @@ -0,0 +1,28 @@ +# vim: set tabstop=2 shiftwidth=2 expandtab : + +include config.ninja + +rule compile + command = $cc $cflags -c -o $out $in + +rule static + command = ar $arflags -- $out $in + +rule shared + command = $cc --shared -o $out $in + +rule install + command = cp -- $in $out + +build ./readopt.o: compile ./readopt.c +build $static: static ./readopt.o +build $shared: shared ./readopt.o + +build $destdir/$lib/$static: install $static +build $destdir/$lib/$shared: install $shared +build $destdir/$incl/$header: install $header + +build install: phony $destdir/$lib/$static $destdir/$lib/$shared $destdir/$incl/$header +build all: phony $static $shared + +default all diff --git a/config.ninja b/config.ninja new file mode 100644 index 0000000..0b36692 --- /dev/null +++ b/config.ninja @@ -0,0 +1,15 @@ +# vim: set tabstop=2 shiftwidth=2 expandtab : + +destdir = +prefix = /usr/local/ +lib = $prefix/lib/ +incl = $prefix/include/ + +cc = cc +macros = -D _POSIX_C_SOURCE=200809L -D NDEBUG +cflags = --std=c99 -Wall -Wextra -Wpedantic -g $macros -O2 +arflags = -rcs + +header = ./readopt.h +static = ./libreadopt.a +shared = ./libreadopt.so diff --git a/readopt.c b/readopt.c new file mode 100644 index 0000000..a04bbac --- /dev/null +++ b/readopt.c @@ -0,0 +1,650 @@ +#include +#include + +#include "readopt.h" + +static enum readopt_status parse_arg(struct readopt_parser *rp, char *arg); + +static enum readopt_status parse_opt(struct readopt_parser *rp, enum readopt_form form, char **pos); + +static struct readopt_opt *match_opt(struct readopt_parser *rp, enum readopt_form form, char **needle); +static struct readopt_opt *match_finish(struct readopt_parser *rp, char **needle, char *cmp, struct readopt_opt *opt); + +static enum readopt_status update_opt(struct readopt_parser *rp, char *attach, struct readopt_opt *opt); +static enum readopt_status update_oper(struct readopt_parser *rp, struct readopt_view_strings val); + +static enum readopt_status assign_opers(struct readopt_parser *rp); + +static enum readopt_status add_val(struct readopt_parser *rp, struct readopt_oper *oper, char *str, int end); + +static char *skip_incl(const char *inner, char *outer); + +static enum readopt_status occ_opt(struct readopt_parser *rp, struct readopt_opt *opt); + +/* permutes the argument list to store a value for an option or operand */ +static void permute_val(struct readopt_parser *rp, struct readopt_view_strings *target, char *val, int end); +static void incr_between(char **start, char **stop, struct readopt_view_strings *curr, struct readopt_view_strings *exclude); +static void permute_rest(char **target, struct readopt_view_strings start); + +static void format_usage_opts(struct readopt_format_context *ctx, struct readopt_opt *opts); +static void format_usage_opers(struct readopt_format_context *ctx, struct readopt_oper *opers); + +struct readopt_answer +readopt_parse_all(struct readopt_parser *rp) +{ + struct readopt_answer answer; + + do + answer = readopt_parse(rp); + while (!answer.end && answer.status == READOPT_STATUS_SUCCESS); + + return answer; +} + +struct readopt_answer +readopt_parse(struct readopt_parser *rp) +{ + /* check whether the current offset is at the end of argv */ + size_t off = rp->state.curr.arg - rp->args.strings; + if (off >= rp->args.len) { + if (rp->state.pending) + /* the last specified option required an argument, but has been ignored */ + return (struct readopt_answer){1, READOPT_STATUS_NOVAL}; + + for (size_t i = 0; readopt_validate_opt(rp->opts + i); i++) + if (!readopt_validate_within(&rp->opts[i].cont.oper)) + return (struct readopt_answer){1, READOPT_STATUS_RANGEOPT}; + + return (struct readopt_answer){1, assign_opers(rp)}; + } + + if (rp->state.pending) { + enum readopt_status status = add_val(rp, &rp->state.curr.opt->cont.oper, *rp->state.curr.arg, 0); + ++rp->state.curr.arg; + return (struct readopt_answer){0, status}; + } + + enum readopt_status status = parse_arg(rp, *rp->state.curr.arg); + + /* if grouped options are still being parsed, they should not be discarded */ + if (!rp->state.grppos) + ++rp->state.curr.arg; + + return (struct readopt_answer){0, status}; +} + +static enum readopt_status +parse_arg(struct readopt_parser *rp, char *arg) +{ + /* parse the next option in the grouped option string, which automatically advances it */ + if (rp->state.grppos) { + enum readopt_status s = parse_opt(rp, READOPT_FORM_SHORT, &rp->state.grppos); + if (!*rp->state.grppos) { + rp->state.grppos = NULL; + } + return s; + } + + char *pos = arg; + + switch (*pos) { + case '-': + ++pos; + switch (*pos) { + case '-': + ++pos; + switch (*pos) { + size_t off; + case '\0': + /* "--" denotes the end of options */ + off = rp->args.len - (rp->state.curr.arg - rp->args.strings); + assert(off); + if (off == 1) { + /* no operands after the "--" */ + return READOPT_STATUS_SUCCESS; + } else { + enum readopt_status s = update_oper(rp, (struct readopt_view_strings){ + .len = off - 1, + .strings = rp->state.curr.arg + 1 + }); + rp->state.curr.arg = rp->args.strings + rp->args.len - 1; + + return s; + } + default: + return parse_opt(rp, READOPT_FORM_LONG, &pos); + } + case '\0': + return update_oper(rp, (struct readopt_view_strings){.len = 1, .strings = (char *[]){arg}}); + default: + return parse_opt(rp, READOPT_FORM_SHORT, &pos); + } + default: + return update_oper(rp, (struct readopt_view_strings){.len = 1, .strings = (char *[]){arg}}); + } +} + +static enum readopt_status +parse_opt(struct readopt_parser *rp, enum readopt_form form, char **pos) +{ + struct readopt_opt *match; + assert(form == READOPT_FORM_SHORT || form == READOPT_FORM_LONG); + + if (form == READOPT_FORM_SHORT) { + match = match_opt(rp, form, pos); + if (match) { + char *strpos = *pos; + + if (!match->cont.req && *strpos) { + rp->state.grppos = strpos; + return update_opt(rp, NULL, match); + } + + return update_opt(rp, *strpos ? strpos : NULL, match); + } else { + return READOPT_STATUS_NOTOPT; + } + } else { + /* match and advance pos to the end of the match */ + match = match_opt(rp, form, pos); + + if (match) { + switch (**pos) { + case '\0': + return update_opt(rp, NULL, match); + case '=': + ++(*pos); + return update_opt(rp, *pos, match); + default: + return READOPT_STATUS_NOTOPT; + } + } else { + return READOPT_STATUS_NOTOPT; + } + } +} + +static struct readopt_opt * +match_opt(struct readopt_parser *rp, enum readopt_form form, char **needle) +{ + /* structure representing the last, inexact match */ + struct { + /* the current advanced string */ + char *adv; + /* current option */ + struct readopt_opt *opt; + } loose = {0}; + + struct readopt_opt *haystack = rp->opts; + for (size_t i = 0; readopt_validate_opt(haystack + i); i++) { + /* iterate through all names (null-terminated) of the current option with the correct form */ + char **names = haystack[i].names[form]; + + if (!names) + /* ignore the option as it does not have names in the required form */ + continue; + + char *cmp = loose.adv; + + for (size_t j = 0; names[j]; j++) { + char *name = names[j]; + cmp = skip_incl(name, *needle); + + if (!cmp) + continue; + + if (!*cmp) + /* a guaranteed match */ + return match_finish(rp, needle, cmp, haystack + i); + else if ((cmp - *needle) > (loose.adv - *needle)) + /* maybe a match */ + loose.adv = cmp, loose.opt = haystack + i; + } + } + + return match_finish(rp, needle, loose.adv, loose.opt); +} + +static struct readopt_opt * +match_finish(struct readopt_parser *rp, char **needle, char *adv, struct readopt_opt *opt) +{ + if (adv) + *needle = adv; + + if (opt) + rp->state.curr.opt = opt; + + return opt; +} + +static enum readopt_status +update_opt(struct readopt_parser *rp, char *attach, struct readopt_opt *opt) +{ + if (opt->cont.req) { + if (attach) { + /* --opt=value, --opt=, -ovalue */ + struct readopt_oper *curr = &rp->state.curr.opt->cont.oper; + return occ_opt(rp, opt) == READOPT_STATUS_SUCCESS ? add_val(rp, curr, attach, 0) : READOPT_STATUS_SUCCESS; + } else { + /* --opt value, -o value */ + rp->state.pending = 1; + return occ_opt(rp, opt); + } + } else { + enum readopt_status s = occ_opt(rp, opt); + return attach ? READOPT_STATUS_NOTREQ : s; + } +} + +static enum readopt_status +update_oper(struct readopt_parser *rp, struct readopt_view_strings val) +{ + assert(val.len && val.strings); + + if (val.len == 1) { + ++rp->state.curr.ioper.len; + permute_val(rp, &rp->state.curr.ioper, val.strings[0], 1); + } else { + permute_rest(rp->state.curr.eoval, val); + rp->state.curr.ioper.len += val.len; + } + + return READOPT_STATUS_SUCCESS; +} + +static enum readopt_status +assign_opers(struct readopt_parser *rp) +{ + size_t count = rp->state.curr.ioper.len; + + size_t nlower = 0; + size_t nupper = 0; + for (size_t i = 0; readopt_validate_oper(rp->opers + i); i++) { + nlower += readopt_select_lower(rp->opers[i].bounds); + nupper += readopt_select_upper(rp->opers[i].bounds); + } + + if (count < nlower) + return READOPT_STATUS_RANGEOPER; + + struct { + size_t extra; + size_t req; + } rest = { + count - nlower, + nlower + }; + + for (size_t i = 0; readopt_validate_oper(rp->opers + i); i++) { + if (count == 0 || !rp->opers[i].val.strings) { + size_t off = count - (rest.extra + rest.req); + rp->opers[i].val.strings = rp->state.curr.ioper.strings + off; + } + + size_t lower = readopt_select_lower(rp->opers[i].bounds); + size_t upper = readopt_select_upper(rp->opers[i].bounds); + int inf = rp->opers[i].bounds.inf; + + size_t add; + + /* add required elements */ + add = rest.req > lower ? lower : rest.req; + rp->opers[i].val.len += add, rest.req -= add; + + /* add optional elements */ + add = inf ? rest.extra : rest.extra > upper ? upper : rest.extra; + rp->opers[i].val.len += add, rest.extra -= add; + } + + return rest.extra || rest.req ? READOPT_STATUS_RANGEOPER : READOPT_STATUS_SUCCESS; +} + +static enum readopt_status +add_val(struct readopt_parser *rp, struct readopt_oper *oper, char *string, int end) +{ + rp->state.pending = 0; + + if (!readopt_validate_within(oper)) + return READOPT_STATUS_RANGEOPT; + + permute_val(rp, &oper->val, string, end); + return READOPT_STATUS_SUCCESS; +} + +static char * +skip_incl(const char *inner, char *outer) +{ + while (*inner == *outer) { + if (!*inner) + return outer; + ++inner, ++outer; + } + return !*inner ? outer : NULL; +} + +static enum readopt_status +occ_opt(struct readopt_parser *rp, struct readopt_opt *opt) +{ + assert(opt); + rp->state.curr.opt = opt; + ++rp->state.curr.opt->cont.oper.val.len; + return READOPT_STATUS_SUCCESS; +} + +static void +permute_val(struct readopt_parser *rp, struct readopt_view_strings *target, char *val, int end) +{ + if (!target->strings) + /* fallback position when no value has been set yet */ + target->strings = rp->state.curr.eoval - (end ? 0 : rp->state.curr.ioper.len); + + char **pos = target->strings + (target->len - 1); + + assert(rp->state.curr.arg >= rp->state.curr.eoval); + + memmove(pos + 1, pos, (rp->state.curr.eoval - pos) * sizeof *pos); + + *pos = val; + ++rp->state.curr.eoval; + + char **start = pos, **stop = rp->state.curr.eoval; + + /* increment all value pointers in the operands and options which are between start and stop, inclusive */ + for (size_t i = 0; readopt_validate_opt(rp->opts + i); i++) + incr_between(start, stop, &rp->opts[i].cont.oper.val, target); + + incr_between(start, stop, &rp->state.curr.ioper, target); +} + +static void +incr_between(char **start, char **stop, struct readopt_view_strings *curr, struct readopt_view_strings *exclude) +{ + if (curr->strings >= start && curr->strings <= stop && curr != exclude) + ++curr->strings; +} + +static void +permute_rest(char **target, struct readopt_view_strings start) +{ + memmove(target, start.strings, start.len * sizeof *start.strings); +} + +void +readopt_parser_init(struct readopt_parser *rp, struct readopt_opt *opts, struct readopt_oper *opers, struct readopt_view_strings args) +{ + *rp = (struct readopt_parser){ + .args = args, + .opts = opts, + .opers = opers, + .state.curr = { + .arg = args.strings, + .eoval = args.strings + } + }; +} + +struct readopt_parser +readopt_parser_create(struct readopt_opt *opts, struct readopt_oper *opers, struct readopt_view_strings args) +{ + struct readopt_parser rp = {0}; + readopt_parser_init(&rp, opts, opers, args); + return rp; +} + +int +readopt_validate_opt(struct readopt_opt *opt) +{ + assert(opt); + return opt->names[0] || opt->names[1]; +} + +int +readopt_validate_oper(struct readopt_oper *oper) +{ + assert(oper); + return !!oper->name; +} + +int +readopt_validate_within(struct readopt_oper *oper) +{ + size_t occ = oper->val.len; + size_t upper = readopt_select_upper(oper->bounds); + size_t lower = readopt_select_lower(oper->bounds); + return occ >= lower && (occ <= upper || oper->bounds.inf); +} + +size_t +readopt_select_upper(struct readopt_bounds bounds) +{ + return bounds.val[0] > bounds.val[1] ? bounds.val[0] : bounds.val[1]; +} + +size_t +readopt_select_lower(struct readopt_bounds bounds) +{ + return bounds.inf ? readopt_select_upper(bounds) : bounds.val[0] < bounds.val[1] ? bounds.val[0] : bounds.val[1]; +} + +char * +readopt_keyval(char *s) +{ + while (*s != '=') ++s; + *s = '\0'; + return ++s; +} + +int +readopt_put_status(enum readopt_status status, struct readopt_write_context *ctx) +{ + const char *s; + switch (status) { + case READOPT_STATUS_SUCCESS: s = "Success"; break; + case READOPT_STATUS_NOVAL: s = "Option did not receive its required value"; break; + case READOPT_STATUS_NOTREQ: s = "No value required for option"; break; + case READOPT_STATUS_NOTOPT: s = "Specified option does not exist"; break; + case READOPT_STATUS_RANGEOPT: s = "Option(s) are not within the defined limits"; break; + case READOPT_STATUS_RANGEOPER: s = "Operand(s) are not within the defined limits"; break; + default: return 0; + } + + readopt_write_string(ctx, s); + return 1; +} + +void +readopt_put_usage(struct readopt_parser *rp, struct readopt_format_context *ctx) +{ + assert(ctx->fmt == READOPT_FORMAT_MDOC || ctx->fmt == READOPT_FORMAT_PLAIN); + ctx->esc.needles = "-"; + ctx->esc.pre = '\\'; + format_usage_opts(ctx, rp->opts); + format_usage_opers(ctx, rp->opers); +} + +static void +format_usage_opts(struct readopt_format_context *ctx, struct readopt_opt *opts) +{ + int nxvalid = readopt_validate_opt(opts); + for (size_t i = 0; nxvalid; i++) { + nxvalid = readopt_validate_opt(opts + i + 1); + size_t lower = readopt_select_lower(opts[i].cont.oper.bounds); + size_t upper = readopt_select_upper(opts[i].cont.oper.bounds); + int inf = opts[i].cont.oper.bounds.inf; + size_t nforms = sizeof opts[i].names / sizeof *opts[i].names; + + for (size_t j = 0; j < (upper ? upper : !!inf); j++) { + readopt_cond_write_char(READOPT_FORMAT_MDOC, ctx, '.'); + if (j >= lower) { + readopt_cond_write_string(READOPT_FORMAT_MDOC, ctx, "Op "); + readopt_cond_write_char(READOPT_FORMAT_PLAIN, ctx, '['); + } + + for (size_t k = 0; k < nforms; k++) { + int grp = 0; + if (opts[i].names[k]) { + for (size_t l = 0; opts[i].names[k][l]; l++) { + if (!grp) { + readopt_cond_write_string(READOPT_FORMAT_MDOC, ctx, "Fl \\&"); + + if (k == READOPT_FORM_SHORT) { + readopt_cond_write_char(READOPT_FORMAT_PLAIN, ctx, '-'); + } + + if (k == READOPT_FORM_LONG) { + readopt_cond_write_string(READOPT_FORMAT_MDOC, ctx, "\\-"); + readopt_cond_write_string(READOPT_FORMAT_PLAIN, ctx, "--"); + } + } + + readopt_cond_write_esc_string(READOPT_FORMAT_MDOC, ctx, opts[i].names[k][l]); + readopt_cond_write_string(READOPT_FORMAT_PLAIN, ctx, opts[i].names[k][l]); + + if (k == READOPT_FORM_SHORT) { + grp = 1; + if (!opts[i].names[k][l + 1]) { + readopt_cond_write_char(READOPT_FORMAT_MDOC, ctx, ' '); + readopt_write_string(ctx->wr, ", "); + } + continue; + } else if (k + 1 < nforms || opts[i].names[k][l + 1]) { + readopt_cond_write_char(READOPT_FORMAT_MDOC, ctx, ' '); + readopt_write_string(ctx->wr, ", "); + } else { + if (opts[i].cont.req){ + readopt_write_char(ctx->wr, ' '); + readopt_cond_write_string(READOPT_FORMAT_MDOC, ctx, "Ar "); + if (opts[i].cont.oper.name) { + readopt_cond_write_esc_string(READOPT_FORMAT_MDOC, ctx, opts[i].cont.oper.name); + readopt_cond_write_string(READOPT_FORMAT_PLAIN, ctx, opts[i].cont.oper.name); + } else { + readopt_write_string(ctx->wr, "value"); + } + + if (inf) { + readopt_cond_write_char(READOPT_FORMAT_MDOC, ctx, ' '); + readopt_write_string(ctx->wr, "..."); + } + } + } + } + } + } + + if (j >= lower) { + readopt_cond_write_char(READOPT_FORMAT_PLAIN, ctx, ']'); + } + + readopt_cond_write_char(READOPT_FORMAT_MDOC, ctx, '\n'); + readopt_cond_write_char(READOPT_FORMAT_PLAIN, ctx, ' '); + } + } +} + +static void +format_usage_opers(struct readopt_format_context *ctx, struct readopt_oper *opers) +{ + int nxvalid = readopt_validate_oper(opers); + for (size_t i = 0; nxvalid; i++) { + nxvalid = readopt_validate_oper(opers + i + 1); + size_t lower = readopt_select_lower(opers[i].bounds); + size_t upper = readopt_select_upper(opers[i].bounds); + int inf = opers[i].bounds.inf; + + for (size_t j = 0; j < lower; j++) { + readopt_cond_write_string(READOPT_FORMAT_MDOC, ctx, ".Ar \\&"); + + readopt_cond_write_esc_string(READOPT_FORMAT_MDOC, ctx, opers[i].name); + readopt_cond_write_string(READOPT_FORMAT_PLAIN, ctx, opers[i].name); + + if (inf && j + 1 == lower) { + readopt_cond_write_char(READOPT_FORMAT_MDOC, ctx, ' '); + readopt_write_string(ctx->wr, "..."); + } + + if (nxvalid) { + readopt_cond_write_char(READOPT_FORMAT_PLAIN, ctx, ' '); + } + + readopt_cond_write_char(READOPT_FORMAT_MDOC, ctx, '\n'); + } + + size_t amt = upper ? upper : inf ? lower + 1 : 0; + for (size_t j = lower; j < amt; j++) { + readopt_cond_write_string(READOPT_FORMAT_MDOC, ctx, ".Op Ar \\&"); + readopt_cond_write_char(READOPT_FORMAT_PLAIN, ctx, '['); + + readopt_cond_write_esc_string(READOPT_FORMAT_MDOC, ctx, opers[i].name); + readopt_cond_write_string(READOPT_FORMAT_PLAIN, ctx, opers[i].name); + + if (inf && j + 1 == amt) { + readopt_cond_write_char(READOPT_FORMAT_MDOC, ctx, ' '); + readopt_write_string(ctx->wr, "..."); + } + + readopt_cond_write_char(READOPT_FORMAT_PLAIN, ctx, ']'); + + if (nxvalid) { + readopt_cond_write_char(READOPT_FORMAT_PLAIN, ctx, ' '); + } + + readopt_cond_write_char(READOPT_FORMAT_MDOC, ctx, '\n'); + } + } +} + +void +readopt_cond_write_esc_string(enum readopt_format desired, struct readopt_format_context *ctx, const char *string) +{ + if (ctx->fmt == desired) readopt_write_esc_string(ctx, string); +} + +void +readopt_cond_write_string(enum readopt_format desired, struct readopt_format_context *ctx, const char *string) +{ + if (ctx->fmt == desired) readopt_write_string(ctx->wr, string); +} + +void +readopt_cond_write_char(enum readopt_format desired, struct readopt_format_context *ctx, char ch) +{ + if (ctx->fmt == desired) readopt_write_char(ctx->wr, ch); +} + +void +readopt_write_esc_string(struct readopt_format_context *ctx, const char *string) +{ + char *s = (char *)string; + for (; *s; ++s) { + if (strchr(ctx->esc.needles, *s) && *s) { + readopt_write_char(ctx->wr, ctx->esc.pre); + } + readopt_write_char(ctx->wr, *s); + } +} + +void +readopt_write_string(struct readopt_write_context *ctx, const char *string) +{ + ctx->src.len = strlen(string); + ctx->src.payload = string; + readopt_write_stream(ctx); +} + +void +readopt_write_char(struct readopt_write_context *ctx, char ch) +{ + ctx->src.len = sizeof (ch); + ctx->src.payload = &ch; + readopt_write_stream(ctx); +} + +void +readopt_write_stream(struct readopt_write_context *ctx) +{ + while (ctx->callback && (ctx->src.len > ctx->dest.size || !ctx->dest.stream)) + if (!ctx->callback(ctx)) + return; + + ctx->written += fwrite(ctx->src.payload, ctx->src.len, 1, ctx->dest.stream); +} diff --git a/readopt.h b/readopt.h new file mode 100644 index 0000000..5efacc7 --- /dev/null +++ b/readopt.h @@ -0,0 +1,140 @@ +#pragma once + +#include + +#define READOPT_ALLOC_STRINGS(...) ((char *[]){__VA_ARGS__, NULL}) + +enum readopt_status { + READOPT_STATUS_SUCCESS, + READOPT_STATUS_NOVAL, + READOPT_STATUS_NOTREQ, + READOPT_STATUS_NOTOPT, + READOPT_STATUS_RANGEOPT, + READOPT_STATUS_RANGEOPER +}; + +enum readopt_form { + READOPT_FORM_SHORT, + READOPT_FORM_LONG +}; + +enum readopt_format { + READOPT_FORMAT_PLAIN, + READOPT_FORMAT_MDOC, +}; + +struct readopt_view_strings { + char **strings; + size_t len; +}; + +struct readopt_bounds { + /* upper val will be ignored if inf is non-zero */ + size_t val[2]; + int inf; +}; + +struct readopt_oper { + char *name; + struct readopt_bounds bounds; + struct readopt_view_strings val; +}; + +struct readopt_opt { + /* two null-terminated arrays of either long or short option names */ + char **names[2]; + + struct { + int req; + + /* oper.name is the name of the value itself (not the option), such as "file" in "--config=file" */ + struct readopt_oper oper; + } cont; +}; + +struct readopt_parser { + struct readopt_opt *opts; + struct readopt_oper *opers; + struct readopt_view_strings args; + struct { + int pending; + char *grppos; + struct { + struct readopt_opt *opt; + /* reference to the current argument being parsed */ + char **arg; + /* reference to the last element of the option/operand value view */ + char **eoval; + /* intermediate operands which have not yet been assigned */ + struct readopt_view_strings ioper; + } curr; + } state; +}; + +struct readopt_answer { + int end; + enum readopt_status status; +}; + +struct readopt_write_context { + size_t written; + void *additional; + + struct { + FILE *stream; + size_t size; + } dest; + + struct { + const char *payload; + size_t len; + } src; + + /* returning 0 means that the current string will not be written */ + int (*callback)(struct readopt_write_context *); +}; + +struct readopt_format_context { + enum readopt_format fmt; + + struct { + const char *needles; + char pre; + } esc; + + struct readopt_write_context *wr; +}; + +/* parse everything at once until either an error occurs or the parsing process was successful */ +struct readopt_answer readopt_parse_all(struct readopt_parser *rp); +/* iteratively parse the arguments */ +struct readopt_answer readopt_parse(struct readopt_parser *rp); +/* args should always exclude the first element, like this: {.strings = argv + 1, .len = argc - 1} */ +void readopt_parser_init(struct readopt_parser *rp, struct readopt_opt *opts, struct readopt_oper *opers, struct readopt_view_strings args); +/* args should always exclude the first element, like this: {.strings = argv + 1, .len = argc - 1} */ +struct readopt_parser readopt_parser_create(struct readopt_opt *opts, struct readopt_oper *opers, struct readopt_view_strings args); +/* check whether the argument is a valid option (can be used to check for the end of an array of options) */ +int readopt_validate_opt(struct readopt_opt *opt); +/* check whether the argument is a valid operand (can be used to check for the end of an array of operands) */ +int readopt_validate_oper(struct readopt_oper *oper); +/* check whether the operand's values are within the defined limits */ +int readopt_validate_within(struct readopt_oper *oper); +/* get the upper limit */ +size_t readopt_select_upper(struct readopt_bounds bounds); +/* get the lower limit (this does not always return the minimum, if e.g. .val is {0, 1} and inf != 0, then 1 will be considered the lower limit as well as the upper limit) */ +size_t readopt_select_lower(struct readopt_bounds bounds); +/* pass a string like "thing=value" and get "value" back */ +char *readopt_keyval(char *s); + +/* write the passed status as a string via ctx */ +int readopt_put_status(enum readopt_status status, struct readopt_write_context *ctx); +/* write the usage string, either as plaintext or mdoc format */ +void readopt_put_usage(struct readopt_parser *rp, struct readopt_format_context *ctx); + +void readopt_write_stream(struct readopt_write_context *ctx); +void readopt_write_string(struct readopt_write_context *ctx, const char *string); +void readopt_write_char(struct readopt_write_context *ctx, char ch); +void readopt_cond_write_string(enum readopt_format desired, struct readopt_format_context *ctx, const char *string); +void readopt_cond_write_char(enum readopt_format desired, struct readopt_format_context *ctx, char ch); +void readopt_write_esc_string(struct readopt_format_context *ctx, const char *string); +void readopt_cond_write_esc_string(enum readopt_format desired, struct readopt_format_context *ctx, const char *string); diff --git a/test/Makefile b/test/Makefile new file mode 100644 index 0000000..d75afe0 --- /dev/null +++ b/test/Makefile @@ -0,0 +1,23 @@ +CC = cc +LDFLAGS = -lreadopt +MACROS = -D_POSIX_C_SOURCE=200809L +CFLAGS = $(MACROS) --std=c99 -O2 -g -Wall -Wextra -Wpedantic + +SOURCES = test.c +OBJECTS = $(SOURCES:.c=.o) + +RM = rm -f -- +CP = cp -- + +all: test + +%.o: %.c + $(CC) $(CFLAGS) -c $< + +test: $(OBJECTS) + $(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS) + +clean: + $(RM) $(OBJECTS) + +.PHONY: clean diff --git a/test/build.ninja b/test/build.ninja new file mode 100644 index 0000000..55728cb --- /dev/null +++ b/test/build.ninja @@ -0,0 +1,16 @@ +# vim: set tabstop=2 shiftwidth=2 expandtab : + +include config.ninja + +rule compile + command = $cc $cflags -c -o $out $in + +rule link + command = $cc $cflags -o $out $in $ldflags $ldlibs + +build ./test.o: compile ./test.c +build $target: link ./test.o + +build all: phony $target + +default all diff --git a/test/config.ninja b/test/config.ninja new file mode 100644 index 0000000..0c81395 --- /dev/null +++ b/test/config.ninja @@ -0,0 +1,9 @@ +# vim: set tabstop=2 shiftwidth=2 expandtab : + +cc = cc +macros = -D _POSIX_C_SOURCE=200809L -D NDEBUG +cflags = --std=c99 -Wall -Wextra -Wpedantic -g $macros -O2 +ldflags = +ldlibs = -lreadopt + +target = ./test diff --git a/test/test.c b/test/test.c new file mode 100644 index 0000000..5ed0903 --- /dev/null +++ b/test/test.c @@ -0,0 +1,198 @@ +#include +#include +#include +#include + +#include + +int +main(int argc, char **argv) +{ + if (!*argv) + return EXIT_FAILURE; + + struct readopt_opt opts[] = { + { + .names = { + [READOPT_FORM_SHORT] = READOPT_ALLOC_STRINGS("e", "x"), + [READOPT_FORM_LONG] = READOPT_ALLOC_STRINGS("expr", "expression") + }, + .cont = { + .req = 1, + .oper.bounds.val = {1, 4} + } + }, + { + .names = { + [READOPT_FORM_SHORT] = READOPT_ALLOC_STRINGS("c"), + [READOPT_FORM_LONG] = READOPT_ALLOC_STRINGS("config") + }, + .cont = { + .req = 1, + .oper = { + .name = "file", + .bounds.val = {2}, + } + } + }, + { + .names = { + [READOPT_FORM_SHORT] = READOPT_ALLOC_STRINGS("i"), + [READOPT_FORM_LONG] = READOPT_ALLOC_STRINGS("uri") + }, + .cont = { + .req = 1, + .oper.bounds.inf = 1 + } + }, + { + .names = { + [READOPT_FORM_SHORT] = READOPT_ALLOC_STRINGS("b"), + [READOPT_FORM_LONG] = READOPT_ALLOC_STRINGS("backup", "backup-file") + }, + .cont = { + .req = 1, + .oper.bounds.inf = 1 + } + }, + { + .names = { + [READOPT_FORM_SHORT] = READOPT_ALLOC_STRINGS("v"), + [READOPT_FORM_LONG] = READOPT_ALLOC_STRINGS("verbose") + }, + .cont.oper.bounds.val = {3} + }, + { + .names = { + [READOPT_FORM_SHORT] = READOPT_ALLOC_STRINGS("s"), + [READOPT_FORM_LONG] = READOPT_ALLOC_STRINGS("sort") + }, + .cont.oper.bounds.inf = 1 + }, + { + .names = { + [READOPT_FORM_LONG] = READOPT_ALLOC_STRINGS("help") + }, + .cont.oper.bounds.val = {1} + }, + { + .names = { + [READOPT_FORM_SHORT] = READOPT_ALLOC_STRINGS("V"), + [READOPT_FORM_LONG] = READOPT_ALLOC_STRINGS("version") + }, + .cont.oper.bounds.val = {1} + }, + {0} + }; + + struct readopt_oper opers[] = { + { + .name = "pattern", + .bounds.inf = 1 + }, + { + .name = "file", + .bounds = { + .val = {1}, + .inf = 1 + } + }, + { + .name = "name", + .bounds = { + .val = {1}, + .inf = 1 + } + }, + {0} + }; + + struct readopt_parser rp = readopt_parser_create( + opts, + opers, + (struct readopt_view_strings){ + .strings = argv + 1, + .len = argc - 1 + } + ); + + struct readopt_answer answer = readopt_parse_all(&rp); + + fputs("status: ", stderr); + readopt_put_status(answer.status, &(struct readopt_write_context){ + .dest.stream = stderr + }); + fputc('\n', stderr); + if (answer.status != READOPT_STATUS_SUCCESS) { + return EXIT_FAILURE; + } + + printf("opt:\n"); + { + struct readopt_opt *curr = rp.opts; + for (size_t i = 0; readopt_validate_opt(curr + i); i++) { + for (size_t j = 0; j < sizeof curr[i].names / sizeof *curr[i].names; j++) { + if (curr[i].names[j]) { + for (size_t k = 0; curr[i].names[j][k]; k++) { + printf("%s ", curr[i].names[j][k]); + } + } + } + printf("{ [%zu] ", curr[i].cont.oper.val.len); + if (curr[i].cont.req) { + struct readopt_view_strings val = curr[i].cont.oper.val; + for (size_t j = 0; j < val.len; j++) { + printf("%s ", val.strings[j]); + } + } + printf("}\n"); + } + } + + printf("oper:\n"); + { + struct readopt_oper *curr = rp.opers; + for (size_t i = 0; readopt_validate_oper(curr + i); i++) { + printf("%s { [%zu] ", curr[i].name, curr[i].val.len); + for (size_t j = 0; j < curr[i].val.len; j++) { + printf("%s ", curr[i].val.strings[j]); + } + printf("}\n"); + } + } + + printf("usage (plain) (stream):\n"); + readopt_put_usage(&rp, &(struct readopt_format_context){ + .fmt = READOPT_FORMAT_PLAIN, + .wr = &(struct readopt_write_context){ + .dest.stream = stdout, + } + }); + printf("\nusage (mdoc) (stream):\n"); + readopt_put_usage(&rp, &(struct readopt_format_context){ + .fmt = READOPT_FORMAT_MDOC, + .wr = &(struct readopt_write_context){ + .dest.stream = stdout, + } + }); + + size_t sz = 0; + char *buf = NULL; + /* alternatively, use fmemopen and increase the buffer size via the callback */ + FILE *stream = open_memstream(&buf, &sz); + readopt_put_usage(&rp, &(struct readopt_format_context){ + .fmt = READOPT_FORMAT_MDOC, + .wr = &(struct readopt_write_context){ + .dest = { + .stream = stream, + .size = SIZE_MAX + } + } + }); + fflush(stream); + printf("usage (mdoc) (buffer):\n%s", buf); + fclose(stream); + free(buf); + + return 0; +} diff --git a/test/test.sh b/test/test.sh new file mode 100755 index 0000000..49c7642 --- /dev/null +++ b/test/test.sh @@ -0,0 +1,35 @@ +#!/bin/sh +./test \ + -e a \ + --expr b \ + c \ + -xd \ + e \ + --expression=f \ + g \ + -c h \ + --config=i \ + --uri j \ + k \ + -il \ + -b m \ + --backup n \ + --backup-file=o \ + p \ + q \ + -vv \ + r \ + -v \ + -s \ + s \ + t \ + --sort \ + u \ + v \ + --help \ + w \ + --version \ + -- \ + x \ + y \ + z