+++ /dev/null
- GNU GENERAL PUBLIC LICENSE
- Version 3, 29 June 2007
-
- copyright (c) 2009 by Bruce Korb - all rights reserved
- 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.
-
- <one line to give the program's name and a brief idea of what it does.>
- copyright (c) by Bruce Korb - all rights reserved
-
- 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 <http://www.gnu.org/licenses/>.
-
-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:
-
- <program> copyright (c) by Bruce Korb - all rights reserved
- 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
-<http://www.gnu.org/licenses/>.
-
- 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
-<http://www.gnu.org/philosophy/why-not-lgpl.html>.
+++ /dev/null
- GNU LESSER GENERAL PUBLIC LICENSE
- Version 3, 29 June 2007
-
- copyright (c) 2009 by Bruce Korb - all rights reserved
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-
- This version of the GNU Lesser General Public License incorporates
-the terms and conditions of version 3 of the GNU General Public
-License, supplemented by the additional permissions listed below.
-
- 0. Additional Definitions.
-
- As used herein, "this License" refers to version 3 of the GNU Lesser
-General Public License, and the "GNU GPL" refers to version 3 of the GNU
-General Public License.
-
- "The Library" refers to a covered work governed by this License,
-other than an Application or a Combined Work as defined below.
-
- An "Application" is any work that makes use of an interface provided
-by the Library, but which is not otherwise based on the Library.
-Defining a subclass of a class defined by the Library is deemed a mode
-of using an interface provided by the Library.
-
- A "Combined Work" is a work produced by combining or linking an
-Application with the Library. The particular version of the Library
-with which the Combined Work was made is also called the "Linked
-Version".
-
- The "Minimal Corresponding Source" for a Combined Work means the
-Corresponding Source for the Combined Work, excluding any source code
-for portions of the Combined Work that, considered in isolation, are
-based on the Application, and not on the Linked Version.
-
- The "Corresponding Application Code" for a Combined Work means the
-object code and/or source code for the Application, including any data
-and utility programs needed for reproducing the Combined Work from the
-Application, but excluding the System Libraries of the Combined Work.
-
- 1. Exception to Section 3 of the GNU GPL.
-
- You may convey a covered work under sections 3 and 4 of this License
-without being bound by section 3 of the GNU GPL.
-
- 2. Conveying Modified Versions.
-
- If you modify a copy of the Library, and, in your modifications, a
-facility refers to a function or data to be supplied by an Application
-that uses the facility (other than as an argument passed when the
-facility is invoked), then you may convey a copy of the modified
-version:
-
- a) under this License, provided that you make a good faith effort to
- ensure that, in the event an Application does not supply the
- function or data, the facility still operates, and performs
- whatever part of its purpose remains meaningful, or
-
- b) under the GNU GPL, with none of the additional permissions of
- this License applicable to that copy.
-
- 3. Object Code Incorporating Material from Library Header Files.
-
- The object code form of an Application may incorporate material from
-a header file that is part of the Library. You may convey such object
-code under terms of your choice, provided that, if the incorporated
-material is not limited to numerical parameters, data structure
-layouts and accessors, or small macros, inline functions and templates
-(ten or fewer lines in length), you do both of the following:
-
- a) Give prominent notice with each copy of the object code that the
- Library is used in it and that the Library and its use are
- covered by this License.
-
- b) Accompany the object code with a copy of the GNU GPL and this license
- document.
-
- 4. Combined Works.
-
- You may convey a Combined Work under terms of your choice that,
-taken together, effectively do not restrict modification of the
-portions of the Library contained in the Combined Work and reverse
-engineering for debugging such modifications, if you also do each of
-the following:
-
- a) Give prominent notice with each copy of the Combined Work that
- the Library is used in it and that the Library and its use are
- covered by this License.
-
- b) Accompany the Combined Work with a copy of the GNU GPL and this license
- document.
-
- c) For a Combined Work that displays copyright notices during
- execution, include the copyright notice for the Library among
- these notices, as well as a reference directing the user to the
- copies of the GNU GPL and this license document.
-
- d) Do one of the following:
-
- 0) Convey the Minimal Corresponding Source under the terms of this
- License, and the Corresponding Application Code in a form
- suitable for, and under terms that permit, the user to
- recombine or relink the Application with a modified version of
- the Linked Version to produce a modified Combined Work, in the
- manner specified by section 6 of the GNU GPL for conveying
- Corresponding Source.
-
- 1) Use a suitable shared library mechanism for linking with the
- Library. A suitable mechanism is one that (a) uses at run time
- a copy of the Library already present on the user's computer
- system, and (b) will operate properly with a modified version
- of the Library that is interface-compatible with the Linked
- Version.
-
- e) Provide Installation Information, but only if you would otherwise
- be required to provide such information under section 6 of the
- GNU GPL, and only to the extent that such information is
- necessary to install and execute a modified version of the
- Combined Work produced by recombining or relinking the
- Application with a modified version of the Linked Version. (If
- you use option 4d0, the Installation Information must accompany
- the Minimal Corresponding Source and Corresponding Application
- Code. If you use option 4d1, you must provide the Installation
- Information in the manner specified by section 6 of the GNU GPL
- for conveying Corresponding Source.)
-
- 5. Combined Libraries.
-
- You may place library facilities that are a work based on the
-Library side by side in a single library together with other library
-facilities that are not Applications and are not covered by this
-License, and convey such a combined library under terms of your
-choice, if you do both of the following:
-
- a) Accompany the combined library with a copy of the same work based
- on the Library, uncombined with any other library facilities,
- conveyed under the terms of this License.
-
- b) Give prominent notice with the combined library that part of it
- is a work based on the Library, and explaining where to find the
- accompanying uncombined form of the same work.
-
- 6. Revised Versions of the GNU Lesser General Public License.
-
- The Free Software Foundation may publish revised and/or new versions
-of the GNU Lesser 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
-Library as you received it specifies that a certain numbered version
-of the GNU Lesser General Public License "or any later version"
-applies to it, you have the option of following the terms and
-conditions either of that published version or of any later version
-published by the Free Software Foundation. If the Library as you
-received it does not specify a version number of the GNU Lesser
-General Public License, you may choose any version of the GNU Lesser
-General Public License ever published by the Free Software Foundation.
-
- If the Library as you received it specifies that a proxy can decide
-whether future versions of the GNU Lesser General Public License shall
-apply, that proxy's public statement of acceptance of any version is
-permanent authorization for you to choose that version for the
-Library.
+++ /dev/null
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright
- notice, this list of conditions and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above
- copyright notice, this list of conditions and the following
- disclaimer in the documentation and/or other materials provided
- with the distribution.
-
- 3. The name of the author may not be used to endorse or promote
- products derived from this software without specific prior
- written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
-IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
-INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
-HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
-STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
-IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-POSSIBILITY OF SUCH DAMAGE.
+++ /dev/null
-## LIBOPTS Makefile
-MAINTAINERCLEANFILES = Makefile.in
-if INSTALL_LIBOPTS
-lib_LTLIBRARIES = libopts.la
-else
-noinst_LTLIBRARIES = libopts.la
-endif
-libopts_la_SOURCES = libopts.c
-libopts_la_CPPFLAGS = -I$(top_srcdir)
-libopts_la_LDFLAGS = -version-info 33:0:8
-EXTRA_DIST = \
- COPYING.gplv3 COPYING.lgplv3 COPYING.mbsd \
- MakeDefs.inc README ag-char-map.h \
- autoopts/options.h autoopts/usage-txt.h autoopts.c \
- autoopts.h boolean.c compat/windows-config.h \
- compat/compat.h compat/pathfind.c compat/snprintf.c \
- compat/strdup.c compat/strchr.c configfile.c \
- cook.c enumeration.c environment.c \
- file.c genshell.c genshell.h \
- load.c m4/libopts.m4 m4/liboptschk.m4 \
- makeshell.c nested.c numeric.c \
- parse-duration.c parse-duration.h pgusage.c \
- proto.h putshell.c reset.c \
- restore.c save.c sort.c \
- stack.c streqvcmp.c text_mmap.c \
- time.c tokenize.c usage.c \
- value-type.c value-type.h version.c \
- xat-attribute.c xat-attribute.h
+++ /dev/null
- THIS TARBALL IS NOT A FULL DISTRIBUTION.
-
-The contents of this tarball is designed to be incorporated into
-software packages that utilize the AutoOpts option automation
-package and are intended to be installed on systems that may not
-have libopts installed. It is redistributable under the terms
-of either the LGPL (see COPYING.lgpl) or under the terms of
-the advertising clause free BSD license (see COPYING.mbsd).
-
-Usage Instructions for autoconf/automake/libtoolized projects:
-
-1. Install the unrolled tarball into your package source tree,
- copying ``libopts.m4'' to your autoconf macro directory.
-
- In your bootstrap (pre-configure) script, you can do this:
-
- rm -rf libopts libopts-*
- gunzip -c `autoopts-config libsrc` | tar -xvf -
- mv -f libopts-*.*.* libopts
- cp -fp libopts/m4/*.m4 m4/.
-
- I tend to put my configure auxiliary files in "m4".
- Whatever directory you choose, if it is not ".", then
- be sure to tell autoconf about it with:
-
- AC_CONFIG_AUX_DIR(m4)
-
- This is one macro where you *MUST* remember to *NOT* quote
- the argument. If you do, automake will get lost.
-
-2. Add the following to your ``configure.ac'' file:
-
- LIBOPTS_CHECK
-
- or:
-
- LIBOPTS_CHECK([relative/path/to/libopts])
-
- This macro will automatically invoke
-
- AC_CONFIG_FILES( [relative/path/to/libopts/Makefile] )
-
- The default ``relative/path/to/libopts'' is simply
- ``libopts''.
-
-3. Add the following to your top level ``Makefile.am'' file:
-
- if NEED_LIBOPTS
- SUBDIRS += $(LIBOPTS_DIR)
- endif
-
- where ``<...>'' can be whatever other files or directories
- you may need. The SUBDIRS must be properly ordered.
- *PLEASE NOTE* it is crucial that the SUBDIRS be set under the
- control of an automake conditional. To work correctly,
- automake has to know the range of possible values of SUBDIRS.
- It's a magical name with magical properties. ``NEED_LIBOPTS''
- will be correctly set by the ``LIBOPTS_CHECK'' macro, above.
-
-4. Add ``$(LIBOPTS_CFLAGS)'' to relevant compiler flags and
- ``$(LIBOPTS_LDADD)'' to relevant link options whereever
- you need them in your build tree.
-
-5. Make sure your object files explicitly depend upon the
- generated options header file. e.g.:
-
- $(prog_OBJECTS) : prog-opts.h
- prog-opts.h : prog-opts.c
- prog-opts.c : prog-opts.def
- autogen prog-opts.def
-
-6. *OPTIONAL* --
- If you are creating man pages and texi documentation from
- the program options, you will need these rules somewhere, too:
-
- man_MANS = prog.1
- prog.1 : prog-opts.def
- autogen -Tagman1.tpl -bprog prog-opts.def
-
- prog-invoke.texi : prog-opts.def
- autogen -Taginfo.tpl -bprog-invoke prog-opts.def
-
-If your package does not utilize the auto* tools, then you
-will need to hand craft the rules for building the library.
-
-LICENSING:
-
-This material is copyright (c) 1993-2009 by Bruce Korb.
-You are licensed to use this under the terms of either
-the GNU Lesser General Public License (see: COPYING.lgpl), or,
-at your option, the modified Berkeley Software Distribution
-License (see: COPYING.mbsd). Both of these files should be
-included with this tarball.
+++ /dev/null
-/*
- * Character mapping generated 11/08/09 08:41:19
- *
- * This file contains the character classifications
- * used by AutoGen and AutoOpts for identifying tokens.
- */
-#ifndef AG_CHAR_MAP_H_GUARD
-#define AG_CHAR_MAP_H_GUARD 1
-
-#ifdef HAVE_CONFIG_H
-# if defined(HAVE_INTTYPES_H)
-# include <inttypes.h>
-# elif defined(HAVE_STDINT_H)
-# include <stdint.h>
-
-# else
-# ifndef HAVE_INT8_T
- typedef signed char int8_t;
-# endif
-# ifndef HAVE_UINT8_T
- typedef unsigned char uint8_t;
-# endif
-# ifndef HAVE_INT16_T
- typedef signed short int16_t;
-# endif
-# ifndef HAVE_UINT16_T
- typedef unsigned short uint16_t;
-# endif
-# ifndef HAVE_UINT_T
- typedef unsigned int uint_t;
-# endif
-
-# ifndef HAVE_INT32_T
-# if SIZEOF_INT == 4
- typedef signed int int32_t;
-# elif SIZEOF_LONG == 4
- typedef signed long int32_t;
-# endif
-# endif
-
-# ifndef HAVE_UINT32_T
-# if SIZEOF_INT == 4
- typedef unsigned int uint32_t;
-# elif SIZEOF_LONG == 4
- typedef unsigned long uint32_t;
-# endif
-# endif
-# endif /* HAVE_*INT*_H header */
-
-#else /* not HAVE_CONFIG_H -- */
-# ifdef __sun
-# include <inttypes.h>
-# else
-# include <stdint.h>
-# endif
-#endif /* HAVE_CONFIG_H */
-
-#if 0 /* mapping specification source (from autogen.map) */
-//
-// %guard autoopts_internal
-// %file ag-char-map.h
-// %table opt-char-cat
-//
-// %comment
-// This file contains the character classifications
-// used by AutoGen and AutoOpts for identifying tokens.
-// %
-//
-// lower-case "a-z"
-// upper-case "A-Z"
-// alphabetic +lower-case +upper-case
-// oct-digit "0-7"
-// dec-digit "89" +oct-digit
-// hex-digit "a-fA-F" +dec-digit
-// alphanumeric +alphabetic +dec-digit
-// var-first "_" +alphabetic
-// variable-name +var-first +dec-digit
-// option-name "^-" +variable-name
-// value-name ":" +option-name
-// horiz-white "\t "
-// compound-name "[.]" +value-name +horiz-white
-// whitespace "\v\f\r\n\b" +horiz-white
-// unquotable "!-~" -"\"#(),;<=>[\\]`{}?*'"
-// end-xml-token "/>" +whitespace
-// graphic "!-~"
-// plus-n-space "+" +whitespace
-// punctuation "!-~" -alphanumeric -"_"
-// suffix "-._" +alphanumeric
-// suffix-fmt "%/" +suffix
-// false-type "nNfF0\x00"
-//
-#endif /* 0 -- mapping spec. source */
-
-typedef uint32_t opt_char_cat_mask_t;
-extern opt_char_cat_mask_t const opt_char_cat[128];
-
-static inline int is_opt_char_cat_char(char ch, opt_char_cat_mask_t mask) {
- unsigned int ix = (unsigned char)ch;
- return ((ix < 0x7F) && ((opt_char_cat[ix] & mask) != 0)); }
-
-#define IS_LOWER_CASE_CHAR(_c) is_opt_char_cat_char((_c), 0x00001)
-#define IS_UPPER_CASE_CHAR(_c) is_opt_char_cat_char((_c), 0x00002)
-#define IS_ALPHABETIC_CHAR(_c) is_opt_char_cat_char((_c), 0x00003)
-#define IS_OCT_DIGIT_CHAR(_c) is_opt_char_cat_char((_c), 0x00004)
-#define IS_DEC_DIGIT_CHAR(_c) is_opt_char_cat_char((_c), 0x0000C)
-#define IS_HEX_DIGIT_CHAR(_c) is_opt_char_cat_char((_c), 0x0001C)
-#define IS_ALPHANUMERIC_CHAR(_c) is_opt_char_cat_char((_c), 0x0000F)
-#define IS_VAR_FIRST_CHAR(_c) is_opt_char_cat_char((_c), 0x00023)
-#define IS_VARIABLE_NAME_CHAR(_c) is_opt_char_cat_char((_c), 0x0002F)
-#define IS_OPTION_NAME_CHAR(_c) is_opt_char_cat_char((_c), 0x0006F)
-#define IS_VALUE_NAME_CHAR(_c) is_opt_char_cat_char((_c), 0x000EF)
-#define IS_HORIZ_WHITE_CHAR(_c) is_opt_char_cat_char((_c), 0x00100)
-#define IS_COMPOUND_NAME_CHAR(_c) is_opt_char_cat_char((_c), 0x003EF)
-#define IS_WHITESPACE_CHAR(_c) is_opt_char_cat_char((_c), 0x00500)
-#define IS_UNQUOTABLE_CHAR(_c) is_opt_char_cat_char((_c), 0x00800)
-#define IS_END_XML_TOKEN_CHAR(_c) is_opt_char_cat_char((_c), 0x01500)
-#define IS_GRAPHIC_CHAR(_c) is_opt_char_cat_char((_c), 0x02000)
-#define IS_PLUS_N_SPACE_CHAR(_c) is_opt_char_cat_char((_c), 0x04500)
-#define IS_PUNCTUATION_CHAR(_c) is_opt_char_cat_char((_c), 0x08000)
-#define IS_SUFFIX_CHAR(_c) is_opt_char_cat_char((_c), 0x1000F)
-#define IS_SUFFIX_FMT_CHAR(_c) is_opt_char_cat_char((_c), 0x3000F)
-#define IS_FALSE_TYPE_CHAR(_c) is_opt_char_cat_char((_c), 0x40000)
-
-#ifdef AUTOOPTS_INTERNAL
-opt_char_cat_mask_t const opt_char_cat[128] = {
- /*x00*/ 0x40000, /*x01*/ 0x00000, /*x02*/ 0x00000, /*x03*/ 0x00000,
- /*x04*/ 0x00000, /*x05*/ 0x00000, /*x06*/ 0x00000, /*\a */ 0x00000,
- /*\b */ 0x00400, /*\t */ 0x00100, /*\n */ 0x00400, /*\v */ 0x00400,
- /*\f */ 0x00400, /*\r */ 0x00400, /*x0E*/ 0x00000, /*x0F*/ 0x00000,
- /*x10*/ 0x00000, /*x11*/ 0x00000, /*x12*/ 0x00000, /*x13*/ 0x00000,
- /*x14*/ 0x00000, /*x15*/ 0x00000, /*x16*/ 0x00000, /*x17*/ 0x00000,
- /*x18*/ 0x00000, /*x19*/ 0x00000, /*x1A*/ 0x00000, /*x1B*/ 0x00000,
- /*x1C*/ 0x00000, /*x1D*/ 0x00000, /*x1E*/ 0x00000, /*x1F*/ 0x00000,
- /* */ 0x00100, /* ! */ 0x0A800, /* " */ 0x0A000, /* # */ 0x0A000,
- /* $ */ 0x0A800, /* % */ 0x2A800, /* & */ 0x0A800, /* ' */ 0x0A000,
- /* ( */ 0x0A000, /* ) */ 0x0A000, /* * */ 0x0A000, /* + */ 0x0E800,
- /* , */ 0x0A000, /* - */ 0x1A840, /* . */ 0x1AA00, /* / */ 0x2B800,
- /* 0 */ 0x42804, /* 1 */ 0x02804, /* 2 */ 0x02804, /* 3 */ 0x02804,
- /* 4 */ 0x02804, /* 5 */ 0x02804, /* 6 */ 0x02804, /* 7 */ 0x02804,
- /* 8 */ 0x02808, /* 9 */ 0x02808, /* : */ 0x0A880, /* ; */ 0x0A000,
- /* < */ 0x0A000, /* = */ 0x0A000, /* > */ 0x0B000, /* ? */ 0x0A000,
- /* @ */ 0x0A800, /* A */ 0x02812, /* B */ 0x02812, /* C */ 0x02812,
- /* D */ 0x02812, /* E */ 0x02812, /* F */ 0x42812, /* G */ 0x02802,
- /* H */ 0x02802, /* I */ 0x02802, /* J */ 0x02802, /* K */ 0x02802,
- /* L */ 0x02802, /* M */ 0x02802, /* N */ 0x42802, /* O */ 0x02802,
- /* P */ 0x02802, /* Q */ 0x02802, /* R */ 0x02802, /* S */ 0x02802,
- /* T */ 0x02802, /* U */ 0x02802, /* V */ 0x02802, /* W */ 0x02802,
- /* X */ 0x02802, /* Y */ 0x02802, /* Z */ 0x02802, /* [ */ 0x0A200,
- /* \ */ 0x0A000, /* ] */ 0x0A200, /* ^ */ 0x0A840, /* _ */ 0x12820,
- /* ` */ 0x0A000, /* a */ 0x02811, /* b */ 0x02811, /* c */ 0x02811,
- /* d */ 0x02811, /* e */ 0x02811, /* f */ 0x42811, /* g */ 0x02801,
- /* h */ 0x02801, /* i */ 0x02801, /* j */ 0x02801, /* k */ 0x02801,
- /* l */ 0x02801, /* m */ 0x02801, /* n */ 0x42801, /* o */ 0x02801,
- /* p */ 0x02801, /* q */ 0x02801, /* r */ 0x02801, /* s */ 0x02801,
- /* t */ 0x02801, /* u */ 0x02801, /* v */ 0x02801, /* w */ 0x02801,
- /* x */ 0x02801, /* y */ 0x02801, /* z */ 0x02801, /* { */ 0x0A000,
- /* | */ 0x0A800, /* } */ 0x0A000, /* ~ */ 0x0A800, /*x7F*/ 0x00000
-};
-#endif /* AUTOOPTS_INTERNAL */
-#endif /* AG_CHAR_MAP_H_GUARD */
+++ /dev/null
-
-/*
- * $Id: 56abb301f50605ec5bae137ded730e330d8d7735 $
- * Time-stamp: "2009-11-01 10:50:34 bkorb"
- *
- * This file contains all of the routines that must be linked into
- * an executable to use the generated option processing. The optional
- * routines are in separately compiled modules so that they will not
- * necessarily be linked in.
- *
- * This file is part of AutoOpts, a companion to AutoGen.
- * AutoOpts is free software.
- * AutoOpts is copyright (c) 1992-2009 by Bruce Korb - all rights reserved
- *
- * AutoOpts is available under any one of two licenses. The license
- * in use must be one of these two and the choice is under the control
- * of the user of the license.
- *
- * The GNU Lesser General Public License, version 3 or later
- * See the files "COPYING.lgplv3" and "COPYING.gplv3"
- *
- * The Modified Berkeley Software Distribution License
- * See the file "COPYING.mbsd"
- *
- * These files have the following md5sums:
- *
- * 43b91e8ca915626ed3818ffb1b71248b pkg/libopts/COPYING.gplv3
- * 06a1a2e4760c90ea5e1dad8dfaac4d39 pkg/libopts/COPYING.lgplv3
- * 66a5cedaf62c4b2637025f049f9b826f pkg/libopts/COPYING.mbsd
- */
-
-static char const zNil[] = "";
-
-/* = = = START-STATIC-FORWARD = = = */
-/* static forward declarations maintained by mk-fwd */
-static tSuccess
-findOptDesc( tOptions* pOpts, tOptState* pOptState );
-
-static tSuccess
-next_opt_arg_must(tOptions* pOpts, tOptState* pOptState);
-
-static tSuccess
-next_opt_arg_may(tOptions* pOpts, tOptState* pOptState);
-
-static tSuccess
-next_opt_arg_none(tOptions* pOpts, tOptState* pOptState);
-
-static tSuccess
-nextOption(tOptions* pOpts, tOptState* pOptState);
-
-static tSuccess
-doPresets( tOptions* pOpts );
-
-static int
-checkConsistency( tOptions* pOpts );
-/* = = = END-STATIC-FORWARD = = = */
-
-LOCAL void *
-ao_malloc( size_t sz )
-{
- void * res = malloc(sz);
- if (res == NULL) {
- fprintf( stderr, "malloc of %d bytes failed\n", (int)sz );
- exit( EXIT_FAILURE );
- }
- return res;
-}
-#undef malloc
-#define malloc(_s) ao_malloc(_s)
-
-LOCAL void *
-ao_realloc( void *p, size_t sz )
-{
- void * res = realloc(p, sz);
- if (res == NULL) {
- fprintf( stderr, "realloc of %d bytes at 0x%p failed\n", (int)sz, p );
- exit( EXIT_FAILURE );
- }
- return res;
-}
-#undef realloc
-#define realloc(_p,_s) ao_realloc(_p,_s)
-
-
-LOCAL void
-ao_free( void *p )
-{
- if (p != NULL)
- free(p);
-}
-#undef free
-#define free(_p) ao_free(_p)
-
-
-LOCAL char *
-ao_strdup( char const *str )
-{
- char * res = strdup(str);
- if (res == NULL) {
- fprintf(stderr, "strdup of %d byte string failed\n", (int)strlen(str));
- exit( EXIT_FAILURE );
- }
- return res;
-}
-#undef strdup
-#define strdup(_p) ao_strdup(_p)
-
-#ifndef HAVE_PATHFIND
-# include "compat/pathfind.c"
-#endif
-
-#ifndef HAVE_SNPRINTF
-# include "compat/snprintf.c"
-#endif
-
-#ifndef HAVE_STRDUP
-# include "compat/strdup.c"
-#endif
-
-#ifndef HAVE_STRCHR
-# include "compat/strchr.c"
-#endif
-
-/*
- * handleOption
- *
- * This routine handles equivalencing, sets the option state flags and
- * invokes the handler procedure, if any.
- */
-LOCAL tSuccess
-handleOption( tOptions* pOpts, tOptState* pOptState )
-{
- /*
- * Save a copy of the option procedure pointer.
- * If this is an equivalence class option, we still want this proc.
- */
- tOptDesc* pOD = pOptState->pOD;
- tOptProc* pOP = pOD->pOptProc;
- if (pOD->fOptState & OPTST_ALLOC_ARG)
- AGFREE(pOD->optArg.argString);
-
- pOD->optArg.argString = pOptState->pzOptArg;
-
- /*
- * IF we are presetting options, then we will ignore any un-presettable
- * options. They are the ones either marked as such.
- */
- if ( ((pOpts->fOptSet & OPTPROC_PRESETTING) != 0)
- && ((pOD->fOptState & OPTST_NO_INIT) != 0)
- )
- return PROBLEM;
-
- /*
- * IF this is an equivalence class option,
- * THEN
- * Save the option value that got us to this option
- * entry. (It may not be pOD->optChar[0], if this is an
- * equivalence entry.)
- * set the pointer to the equivalence class base
- */
- if (pOD->optEquivIndex != NO_EQUIVALENT) {
- tOptDesc* p = pOpts->pOptDesc + pOD->optEquivIndex;
-
- /*
- * IF the current option state has not been defined (set on the
- * command line), THEN we will allow continued resetting of
- * the value. Once "defined", then it must not change.
- */
- if ((pOD->fOptState & OPTST_DEFINED) != 0) {
- /*
- * The equivalenced-to option has been found on the command
- * line before. Make sure new occurrences are the same type.
- *
- * IF this option has been previously equivalenced and
- * it was not the same equivalenced-to option,
- * THEN we have a usage problem.
- */
- if (p->optActualIndex != pOD->optIndex) {
- fprintf( stderr, (char*)zMultiEquiv, p->pz_Name, pOD->pz_Name,
- (pOpts->pOptDesc + p->optActualIndex)->pz_Name);
- return FAILURE;
- }
- } else {
- /*
- * Set the equivalenced-to actual option index to no-equivalent
- * so that we set all the entries below. This option may either
- * never have been selected before, or else it was selected by
- * some sort of "presetting" mechanism.
- */
- p->optActualIndex = NO_EQUIVALENT;
- }
-
- if (p->optActualIndex != pOD->optIndex) {
- /*
- * First time through, copy over the state
- * and add in the equivalence flag
- */
- p->optActualValue = pOD->optValue;
- p->optActualIndex = pOD->optIndex;
- pOptState->flags |= OPTST_EQUIVALENCE;
- }
-
- /*
- * Copy the most recent option argument. set membership state
- * is kept in ``p->optCookie''. Do not overwrite.
- */
- p->optArg.argString = pOD->optArg.argString;
- pOD = p;
-
- } else {
- pOD->optActualValue = pOD->optValue;
- pOD->optActualIndex = pOD->optIndex;
- }
-
- pOD->fOptState &= OPTST_PERSISTENT_MASK;
- pOD->fOptState |= (pOptState->flags & ~OPTST_PERSISTENT_MASK);
-
- /*
- * Keep track of count only for DEFINED (command line) options.
- * IF we have too many, build up an error message and bail.
- */
- if ( (pOD->fOptState & OPTST_DEFINED)
- && (++pOD->optOccCt > pOD->optMaxCt) ) {
-
- if ((pOpts->fOptSet & OPTPROC_ERRSTOP) != 0) {
- char const * pzEqv =
- (pOD->optEquivIndex != NO_EQUIVALENT) ? zEquiv : zNil;
-
- fputs( zErrOnly, stderr );
-
- if (pOD->optMaxCt > 1)
- fprintf(stderr, zAtMost, pOD->optMaxCt, pOD->pz_Name, pzEqv);
- else
- fprintf(stderr, zOnlyOne, pOD->pz_Name, pzEqv);
- }
-
- return FAILURE;
- }
-
- /*
- * If provided a procedure to call, call it
- */
- if (pOP != NULL)
- (*pOP)( pOpts, pOD );
-
- return SUCCESS;
-}
-
-
-/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
- *
- * HUNT FOR OPTIONS IN THE ARGUMENT LIST
- *
- * The next four procedures are "private" to nextOption().
- * nextOption() uses findOptDesc() to find the next descriptor and it, in
- * turn, uses longOptionFind() and shortOptionFind() to actually do the hunt.
- *
- * longOptionFind
- *
- * Find the long option descriptor for the current option
- */
-LOCAL tSuccess
-longOptionFind( tOptions* pOpts, char* pzOptName, tOptState* pOptState )
-{
- ag_bool disable = AG_FALSE;
- char* pzEq = strchr( pzOptName, '=' );
- tOptDesc* pOD = pOpts->pOptDesc;
- int idx = 0;
- int idxLim = pOpts->optCt;
- int matchCt = 0;
- int matchIdx = 0;
- int nameLen;
- char opt_name_buf[128];
-
- /*
- * IF the value is attached to the name,
- * copy it off so we can NUL terminate.
- */
- if (pzEq != NULL) {
- nameLen = (int)(pzEq - pzOptName);
- if (nameLen >= sizeof(opt_name_buf))
- return FAILURE;
- memcpy(opt_name_buf, pzOptName, nameLen);
- opt_name_buf[nameLen] = NUL;
- pzOptName = opt_name_buf;
- pzEq++;
-
- } else nameLen = strlen( pzOptName );
-
- do {
- if (SKIP_OPT(pOD)) {
- if ( (pOD->fOptState != (OPTST_OMITTED | OPTST_NO_INIT))
- || (pOD->pz_Name == NULL))
- continue;
- }
- else assert(pOD->pz_Name != NULL);
-
- if (strneqvcmp( pzOptName, pOD->pz_Name, nameLen ) == 0) {
- /*
- * IF we have a complete match
- * THEN it takes priority over any already located partial
- */
- if (pOD->pz_Name[ nameLen ] == NUL) {
- matchCt = 1;
- matchIdx = idx;
- break;
- }
- }
-
- /*
- * IF there is a disable name
- * *AND* no argument value has been supplied
- * (disabled options may have no argument)
- * *AND* the option name matches the disable name
- * THEN ...
- */
- else if ( (pOD->pz_DisableName != NULL)
- && (strneqvcmp(pzOptName, pOD->pz_DisableName, nameLen) == 0)
- ) {
- disable = AG_TRUE;
-
- /*
- * IF we have a complete match
- * THEN it takes priority over any already located partial
- */
- if (pOD->pz_DisableName[ nameLen ] == NUL) {
- matchCt = 1;
- matchIdx = idx;
- break;
- }
- }
-
- else
- continue;
-
- /*
- * We found a partial match, either regular or disabling.
- * Remember the index for later.
- */
- matchIdx = idx;
-
- if (++matchCt > 1)
- break;
-
- } while (pOD++, (++idx < idxLim));
-
- /*
- * Make sure we either found an exact match or found only one partial
- */
- if (matchCt == 1) {
- pOD = pOpts->pOptDesc + matchIdx;
-
- if (SKIP_OPT(pOD)) {
- fprintf(stderr, zDisabledErr, pOpts->pzProgName, pOD->pz_Name);
- if (pOD->pzText != NULL)
- fprintf(stderr, " -- %s", pOD->pzText);
- fputc('\n', stderr);
- (*pOpts->pUsageProc)(pOpts, EXIT_FAILURE);
- /* NOTREACHED */
- }
-
- /*
- * IF we found a disablement name,
- * THEN set the bit in the callers' flag word
- */
- if (disable)
- pOptState->flags |= OPTST_DISABLED;
-
- pOptState->pOD = pOD;
- pOptState->pzOptArg = pzEq;
- pOptState->optType = TOPT_LONG;
- return SUCCESS;
- }
-
- /*
- * IF there is no equal sign
- * *AND* we are using named arguments
- * *AND* there is a default named option,
- * THEN return that option.
- */
- if ( (pzEq == NULL)
- && NAMED_OPTS(pOpts)
- && (pOpts->specOptIdx.default_opt != NO_EQUIVALENT)) {
- pOptState->pOD = pOpts->pOptDesc + pOpts->specOptIdx.default_opt;
-
- pOptState->pzOptArg = pzOptName;
- pOptState->optType = TOPT_DEFAULT;
- return SUCCESS;
- }
-
- /*
- * IF we are to stop on errors (the default, actually)
- * THEN call the usage procedure.
- */
- if ((pOpts->fOptSet & OPTPROC_ERRSTOP) != 0) {
- fprintf(stderr, (matchCt == 0) ? zIllOptStr : zAmbigOptStr,
- pOpts->pzProgPath, pzOptName);
- (*pOpts->pUsageProc)(pOpts, EXIT_FAILURE);
- }
-
- return FAILURE;
-}
-
-
-/*
- * shortOptionFind
- *
- * Find the short option descriptor for the current option
- */
-LOCAL tSuccess
-shortOptionFind( tOptions* pOpts, uint_t optValue, tOptState* pOptState )
-{
- tOptDesc* pRes = pOpts->pOptDesc;
- int ct = pOpts->optCt;
-
- /*
- * Search the option list
- */
- do {
- if (optValue != pRes->optValue)
- continue;
-
- if (SKIP_OPT(pRes)) {
- if ( (pRes->fOptState == (OPTST_OMITTED | OPTST_NO_INIT))
- && (pRes->pz_Name != NULL)) {
- fprintf(stderr, zDisabledErr, pOpts->pzProgPath, pRes->pz_Name);
- if (pRes->pzText != NULL)
- fprintf(stderr, " -- %s", pRes->pzText);
- fputc('\n', stderr);
- (*pOpts->pUsageProc)(pOpts, EXIT_FAILURE);
- /* NOTREACHED */
- }
- goto short_opt_error;
- }
-
- pOptState->pOD = pRes;
- pOptState->optType = TOPT_SHORT;
- return SUCCESS;
-
- } while (pRes++, --ct > 0);
-
- /*
- * IF the character value is a digit
- * AND there is a special number option ("-n")
- * THEN the result is the "option" itself and the
- * option is the specially marked "number" option.
- */
- if ( IS_DEC_DIGIT_CHAR(optValue)
- && (pOpts->specOptIdx.number_option != NO_EQUIVALENT) ) {
- pOptState->pOD = \
- pRes = pOpts->pOptDesc + pOpts->specOptIdx.number_option;
- (pOpts->pzCurOpt)--;
- pOptState->optType = TOPT_SHORT;
- return SUCCESS;
- }
-
- short_opt_error:
-
- /*
- * IF we are to stop on errors (the default, actually)
- * THEN call the usage procedure.
- */
- if ((pOpts->fOptSet & OPTPROC_ERRSTOP) != 0) {
- fprintf( stderr, zIllOptChr, pOpts->pzProgPath, optValue );
- (*pOpts->pUsageProc)( pOpts, EXIT_FAILURE );
- }
-
- return FAILURE;
-}
-
-
-/*
- * findOptDesc
- *
- * Find the option descriptor for the current option
- */
-static tSuccess
-findOptDesc( tOptions* pOpts, tOptState* pOptState )
-{
- /*
- * IF we are continuing a short option list (e.g. -xyz...)
- * THEN continue a single flag option.
- * OTHERWISE see if there is room to advance and then do so.
- */
- if ((pOpts->pzCurOpt != NULL) && (*pOpts->pzCurOpt != NUL))
- return shortOptionFind( pOpts, (tAoUC)*(pOpts->pzCurOpt), pOptState );
-
- if (pOpts->curOptIdx >= pOpts->origArgCt)
- return PROBLEM; /* NORMAL COMPLETION */
-
- pOpts->pzCurOpt = pOpts->origArgVect[ pOpts->curOptIdx ];
-
- /*
- * IF all arguments must be named options, ...
- */
- if (NAMED_OPTS(pOpts)) {
- char * pz = pOpts->pzCurOpt;
- int def;
- tSuccess res;
- tAoUS * def_opt;
-
- pOpts->curOptIdx++;
-
- if (*pz != '-')
- return longOptionFind(pOpts, pz, pOptState);
-
- /*
- * The name is prefixed with one or more hyphens. Strip them off
- * and disable the "default_opt" setting. Use heavy recasting to
- * strip off the "const" quality of the "default_opt" field.
- */
- while (*(++pz) == '-') ;
- def_opt = (void *)&(pOpts->specOptIdx.default_opt);
- def = *def_opt;
- *def_opt = NO_EQUIVALENT;
- res = longOptionFind(pOpts, pz, pOptState);
- *def_opt = def;
- return res;
- }
-
- /*
- * Note the kind of flag/option marker
- */
- if (*((pOpts->pzCurOpt)++) != '-')
- return PROBLEM; /* NORMAL COMPLETION - this + rest are operands */
-
- /*
- * Special hack for a hyphen by itself
- */
- if (*(pOpts->pzCurOpt) == NUL)
- return PROBLEM; /* NORMAL COMPLETION - this + rest are operands */
-
- /*
- * The current argument is to be processed as an option argument
- */
- pOpts->curOptIdx++;
-
- /*
- * We have an option marker.
- * Test the next character for long option indication
- */
- if (pOpts->pzCurOpt[0] == '-') {
- if (*++(pOpts->pzCurOpt) == NUL)
- /*
- * NORMAL COMPLETION - NOT this arg, but rest are operands
- */
- return PROBLEM;
-
- /*
- * We do not allow the hyphen to be used as a flag value.
- * Therefore, if long options are not to be accepted, we punt.
- */
- if ((pOpts->fOptSet & OPTPROC_LONGOPT) == 0) {
- fprintf( stderr, zIllOptStr, pOpts->pzProgPath,
- zIllegal, pOpts->pzCurOpt-2 );
- return FAILURE;
- }
-
- return longOptionFind( pOpts, pOpts->pzCurOpt, pOptState );
- }
-
- /*
- * If short options are not allowed, then do long
- * option processing. Otherwise the character must be a
- * short (i.e. single character) option.
- */
- if ((pOpts->fOptSet & OPTPROC_SHORTOPT) != 0)
- return shortOptionFind( pOpts, (tAoUC)*(pOpts->pzCurOpt), pOptState );
-
- return longOptionFind( pOpts, pOpts->pzCurOpt, pOptState );
-}
-
-
-static tSuccess
-next_opt_arg_must(tOptions* pOpts, tOptState* pOptState)
-{
- /*
- * An option argument is required. Long options can either have
- * a separate command line argument, or an argument attached by
- * the '=' character. Figure out which.
- */
- switch (pOptState->optType) {
- case TOPT_SHORT:
- /*
- * See if an arg string follows the flag character
- */
- if (*++(pOpts->pzCurOpt) == NUL)
- pOpts->pzCurOpt = pOpts->origArgVect[ pOpts->curOptIdx++ ];
- pOptState->pzOptArg = pOpts->pzCurOpt;
- break;
-
- case TOPT_LONG:
- /*
- * See if an arg string has already been assigned (glued on
- * with an `=' character)
- */
- if (pOptState->pzOptArg == NULL)
- pOptState->pzOptArg = pOpts->origArgVect[ pOpts->curOptIdx++ ];
- break;
-
- default:
-#ifdef DEBUG
- fputs( "AutoOpts lib error: option type not selected\n",
- stderr );
- exit( EXIT_FAILURE );
-#endif
-
- case TOPT_DEFAULT:
- /*
- * The option was selected by default. The current token is
- * the option argument.
- */
- break;
- }
-
- /*
- * Make sure we did not overflow the argument list.
- */
- if (pOpts->curOptIdx > pOpts->origArgCt) {
- fprintf( stderr, zMisArg, pOpts->pzProgPath,
- pOptState->pOD->pz_Name );
- return FAILURE;
- }
-
- pOpts->pzCurOpt = NULL; /* next time advance to next arg */
- return SUCCESS;
-}
-
-
-static tSuccess
-next_opt_arg_may(tOptions* pOpts, tOptState* pOptState)
-{
- /*
- * An option argument is optional.
- */
- switch (pOptState->optType) {
- case TOPT_SHORT:
- if (*++pOpts->pzCurOpt != NUL)
- pOptState->pzOptArg = pOpts->pzCurOpt;
- else {
- char* pzLA = pOpts->origArgVect[ pOpts->curOptIdx ];
-
- /*
- * BECAUSE it is optional, we must make sure
- * we did not find another flag and that there
- * is such an argument.
- */
- if ((pzLA == NULL) || (*pzLA == '-'))
- pOptState->pzOptArg = NULL;
- else {
- pOpts->curOptIdx++; /* argument found */
- pOptState->pzOptArg = pzLA;
- }
- }
- break;
-
- case TOPT_LONG:
- /*
- * Look for an argument if we don't already have one (glued on
- * with a `=' character) *AND* we are not in named argument mode
- */
- if ( (pOptState->pzOptArg == NULL)
- && (! NAMED_OPTS(pOpts))) {
- char* pzLA = pOpts->origArgVect[ pOpts->curOptIdx ];
-
- /*
- * BECAUSE it is optional, we must make sure
- * we did not find another flag and that there
- * is such an argument.
- */
- if ((pzLA == NULL) || (*pzLA == '-'))
- pOptState->pzOptArg = NULL;
- else {
- pOpts->curOptIdx++; /* argument found */
- pOptState->pzOptArg = pzLA;
- }
- }
- break;
-
- default:
- case TOPT_DEFAULT:
- fputs(zAO_Woops, stderr );
- exit( EX_SOFTWARE );
- }
-
- /*
- * After an option with an optional argument, we will
- * *always* start with the next option because if there
- * were any characters following the option name/flag,
- * they would be interpreted as the argument.
- */
- pOpts->pzCurOpt = NULL;
- return SUCCESS;
-}
-
-
-static tSuccess
-next_opt_arg_none(tOptions* pOpts, tOptState* pOptState)
-{
- /*
- * No option argument. Make sure next time around we find
- * the correct option flag character for short options
- */
- if (pOptState->optType == TOPT_SHORT)
- (pOpts->pzCurOpt)++;
-
- /*
- * It is a long option. Make sure there was no ``=xxx'' argument
- */
- else if (pOptState->pzOptArg != NULL) {
- fprintf(stderr, zNoArg, pOpts->pzProgPath, pOptState->pOD->pz_Name);
- return FAILURE;
- }
-
- /*
- * It is a long option. Advance to next command line argument.
- */
- else
- pOpts->pzCurOpt = NULL;
- return SUCCESS;
-}
-
-/*
- * nextOption
- *
- * Find the option descriptor and option argument (if any) for the
- * next command line argument. DO NOT modify the descriptor. Put
- * all the state in the state argument so that the option can be skipped
- * without consequence (side effect).
- */
-static tSuccess
-nextOption(tOptions* pOpts, tOptState* pOptState)
-{
- {
- tSuccess res;
- res = findOptDesc( pOpts, pOptState );
- if (! SUCCESSFUL( res ))
- return res;
- }
-
- if ( ((pOptState->flags & OPTST_DEFINED) != 0)
- && ((pOptState->pOD->fOptState & OPTST_NO_COMMAND) != 0)) {
- fprintf(stderr, zNotCmdOpt, pOptState->pOD->pz_Name);
- return FAILURE;
- }
-
- pOptState->flags |= (pOptState->pOD->fOptState & OPTST_PERSISTENT_MASK);
-
- /*
- * Figure out what to do about option arguments. An argument may be
- * required, not associated with the option, or be optional. We detect the
- * latter by examining for an option marker on the next possible argument.
- * Disabled mode option selection also disables option arguments.
- */
- {
- enum { ARG_NONE, ARG_MAY, ARG_MUST } arg_type = ARG_NONE;
- tSuccess res;
-
- if ((pOptState->flags & OPTST_DISABLED) != 0)
- arg_type = ARG_NONE;
-
- else if (OPTST_GET_ARGTYPE(pOptState->flags) == OPARG_TYPE_NONE)
- arg_type = ARG_NONE;
-
- else if (pOptState->flags & OPTST_ARG_OPTIONAL)
- arg_type = ARG_MAY;
-
- else
- arg_type = ARG_MUST;
-
- switch (arg_type) {
- case ARG_MUST: res = next_opt_arg_must(pOpts, pOptState); break;
- case ARG_MAY: res = next_opt_arg_may( pOpts, pOptState); break;
- case ARG_NONE: res = next_opt_arg_none(pOpts, pOptState); break;
- }
-
- return res;
- }
-}
-
-
-/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
- *
- * DO PRESETS
- *
- * The next several routines do the immediate action pass on the command
- * line options, then the environment variables, then the config files in
- * reverse order. Once done with that, the order is reversed and all
- * the config files and environment variables are processed again, this
- * time only processing the non-immediate action options. doPresets()
- * will then return for optionProcess() to do the final pass on the command
- * line arguments.
- */
-
-/*
- * doImmediateOpts - scan the command line for immediate action options
- */
-LOCAL tSuccess
-doImmediateOpts( tOptions* pOpts )
-{
- pOpts->curOptIdx = 1; /* start by skipping program name */
- pOpts->pzCurOpt = NULL;
-
- /*
- * Examine all the options from the start. We process any options that
- * are marked for immediate processing.
- */
- for (;;) {
- tOptState optState = OPTSTATE_INITIALIZER(PRESET);
-
- switch (nextOption( pOpts, &optState )) {
- case FAILURE: goto optionsDone;
- case PROBLEM: return SUCCESS; /* no more args */
- case SUCCESS: break;
- }
-
- /*
- * IF this *is* an immediate-attribute option, then do it.
- */
- if (! DO_IMMEDIATELY(optState.flags))
- continue;
-
- if (! SUCCESSFUL( handleOption( pOpts, &optState )))
- break;
- } optionsDone:;
-
- if ((pOpts->fOptSet & OPTPROC_ERRSTOP) != 0)
- (*pOpts->pUsageProc)( pOpts, EXIT_FAILURE );
- return FAILURE;
-}
-
-
-LOCAL tSuccess
-doRegularOpts( tOptions* pOpts )
-{
- /*
- * Now, process all the options from our current position onward.
- * (This allows interspersed options and arguments for the few
- * non-standard programs that require it.)
- */
- for (;;) {
- tOptState optState = OPTSTATE_INITIALIZER(DEFINED);
-
- switch (nextOption( pOpts, &optState )) {
- case FAILURE: goto optionsDone;
- case PROBLEM: return SUCCESS; /* no more args */
- case SUCCESS: break;
- }
-
- /*
- * IF this is not being processed normally (i.e. is immediate action)
- * THEN skip it (unless we are supposed to do it a second time).
- */
- if (! DO_NORMALLY(optState.flags)) {
- if (! DO_SECOND_TIME(optState.flags))
- continue;
- optState.pOD->optOccCt--; /* don't count last time */
- }
-
- if (! SUCCESSFUL( handleOption( pOpts, &optState )))
- break;
- } optionsDone:;
- if ((pOpts->fOptSet & OPTPROC_ERRSTOP) != 0)
- (*pOpts->pUsageProc)( pOpts, EXIT_FAILURE );
- return FAILURE;
-}
-
-
-/*
- * doPresets - check for preset values from a config file or the envrionment
- */
-static tSuccess
-doPresets( tOptions* pOpts )
-{
- tOptDesc * pOD = NULL;
-
- if (! SUCCESSFUL( doImmediateOpts( pOpts )))
- return FAILURE;
-
- /*
- * IF this option set has a --save-opts option, then it also
- * has a --load-opts option. See if a command line option has disabled
- * option presetting.
- */
- if ( (pOpts->specOptIdx.save_opts != NO_EQUIVALENT)
- && (pOpts->specOptIdx.save_opts != 0)) {
- pOD = pOpts->pOptDesc + pOpts->specOptIdx.save_opts + 1;
- if (DISABLED_OPT(pOD))
- return SUCCESS;
- }
-
- /*
- * Until we return from this procedure, disable non-presettable opts
- */
- pOpts->fOptSet |= OPTPROC_PRESETTING;
- /*
- * IF there are no config files,
- * THEN do any environment presets and leave.
- */
- if (pOpts->papzHomeList == NULL) {
- doEnvPresets( pOpts, ENV_ALL );
- }
- else {
- doEnvPresets( pOpts, ENV_IMM );
-
- /*
- * Check to see if environment variables have disabled presetting.
- */
- if ((pOD != NULL) && ! DISABLED_OPT(pOD))
- internalFileLoad( pOpts );
-
- /*
- * ${PROGRAM_LOAD_OPTS} value of "no" cannot disable other environment
- * variable options. Only the loading of .rc files.
- */
- doEnvPresets( pOpts, ENV_NON_IMM );
- }
- pOpts->fOptSet &= ~OPTPROC_PRESETTING;
-
- return SUCCESS;
-}
-
-
-/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
- *
- * VERIFY OPTION CONSISTENCY
- *
- * Make sure that the argument list passes our consistency tests.
- */
-static int
-checkConsistency( tOptions* pOpts )
-{
- int errCt = 0;
- tOptDesc* pOD = pOpts->pOptDesc;
- int oCt = pOpts->presetOptCt;
-
- /*
- * FOR each of "oCt" options, ...
- */
- for (;;) {
- const int* pMust = pOD->pOptMust;
- const int* pCant = pOD->pOptCant;
-
- /*
- * IF the current option was provided on the command line
- * THEN ensure that any "MUST" requirements are not
- * "DEFAULT" (unspecified) *AND* ensure that any
- * "CANT" options have not been SET or DEFINED.
- */
- if (SELECTED_OPT(pOD)) {
- if (pMust != NULL) for (;;) {
- tOptDesc* p = pOpts->pOptDesc + *(pMust++);
- if (UNUSED_OPT(p)) {
- const tOptDesc* pN = pOpts->pOptDesc + pMust[-1];
- errCt++;
- fprintf( stderr, zReqFmt, pOD->pz_Name, pN->pz_Name );
- }
-
- if (*pMust == NO_EQUIVALENT)
- break;
- }
-
- if (pCant != NULL) for (;;) {
- tOptDesc* p = pOpts->pOptDesc + *(pCant++);
- if (SELECTED_OPT(p)) {
- const tOptDesc* pN = pOpts->pOptDesc + pCant[-1];
- errCt++;
- fprintf( stderr, zCantFmt, pOD->pz_Name, pN->pz_Name );
- }
-
- if (*pCant == NO_EQUIVALENT)
- break;
- }
- }
-
- /*
- * IF this option is not equivalenced to another,
- * OR it is equivalenced to itself (is the equiv. root)
- * THEN we need to make sure it occurs often enough.
- */
- if ( (pOD->optEquivIndex == NO_EQUIVALENT)
- || (pOD->optEquivIndex == pOD->optIndex) ) do {
- /*
- * IF the occurrence counts have been satisfied,
- * THEN there is no problem.
- */
- if (pOD->optOccCt >= pOD->optMinCt)
- break;
-
- /*
- * IF MUST_SET means SET and PRESET are okay,
- * so min occurrence count doesn't count
- */
- if ( (pOD->fOptState & OPTST_MUST_SET)
- && (pOD->fOptState & (OPTST_PRESET | OPTST_SET)) )
- break;
-
- errCt++;
- if (pOD->optMinCt > 1)
- fprintf( stderr, zNotEnough, pOD->pz_Name, pOD->optMinCt );
- else fprintf( stderr, zNeedOne, pOD->pz_Name );
- } while (0);
-
- if (--oCt <= 0)
- break;
- pOD++;
- }
-
- /*
- * IF we are stopping on errors, check to see if any remaining
- * arguments are required to be there or prohibited from being there.
- */
- if ((pOpts->fOptSet & OPTPROC_ERRSTOP) != 0) {
-
- /*
- * Check for prohibition
- */
- if ((pOpts->fOptSet & OPTPROC_NO_ARGS) != 0) {
- if (pOpts->origArgCt > pOpts->curOptIdx) {
- fprintf( stderr, zNoArgs, pOpts->pzProgName );
- ++errCt;
- }
- }
-
- /*
- * ELSE not prohibited, check for being required
- */
- else if ((pOpts->fOptSet & OPTPROC_ARGS_REQ) != 0) {
- if (pOpts->origArgCt <= pOpts->curOptIdx) {
- fprintf( stderr, zArgsMust, pOpts->pzProgName );
- ++errCt;
- }
- }
- }
-
- return errCt;
-}
-
-
-/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
- *
- * THESE ROUTINES ARE CALLABLE FROM THE GENERATED OPTION PROCESSING CODE
- */
-/*=--subblock=arg=arg_type,arg_name,arg_desc =*/
-/*=*
- * library: opts
- * header: your-opts.h
- *
- * lib_description:
- *
- * These are the routines that libopts users may call directly from their
- * code. There are several other routines that can be called by code
- * generated by the libopts option templates, but they are not to be
- * called from any other user code. The @file{options.h} header is
- * fairly clear about this, too.
-=*/
-
-/*=export_func optionProcess
- *
- * what: this is the main option processing routine
- *
- * arg: + tOptions* + pOpts + program options descriptor +
- * arg: + int + argc + program arg count +
- * arg: + char** + argv + program arg vector +
- *
- * ret_type: int
- * ret_desc: the count of the arguments processed
- *
- * doc:
- *
- * This is the main entry point for processing options. It is intended
- * that this procedure be called once at the beginning of the execution of
- * a program. Depending on options selected earlier, it is sometimes
- * necessary to stop and restart option processing, or to select completely
- * different sets of options. This can be done easily, but you generally
- * do not want to do this.
- *
- * The number of arguments processed always includes the program name.
- * If one of the arguments is "--", then it is counted and the processing
- * stops. If an error was encountered and errors are to be tolerated, then
- * the returned value is the index of the argument causing the error.
- * A hyphen by itself ("-") will also cause processing to stop and will
- * @emph{not} be counted among the processed arguments. A hyphen by itself
- * is treated as an operand. Encountering an operand stops option
- * processing.
- *
- * err: Errors will cause diagnostics to be printed. @code{exit(3)} may
- * or may not be called. It depends upon whether or not the options
- * were generated with the "allow-errors" attribute, or if the
- * ERRSKIP_OPTERR or ERRSTOP_OPTERR macros were invoked.
-=*/
-int
-optionProcess(
- tOptions* pOpts,
- int argCt,
- char** argVect )
-{
- if (! SUCCESSFUL( validateOptionsStruct( pOpts, argVect[0] )))
- exit( EX_SOFTWARE );
-
- /*
- * Establish the real program name, the program full path,
- * and do all the presetting the first time thru only.
- */
- if ((pOpts->fOptSet & OPTPROC_INITDONE) == 0) {
- pOpts->origArgCt = argCt;
- pOpts->origArgVect = argVect;
- pOpts->fOptSet |= OPTPROC_INITDONE;
-
- if (! SUCCESSFUL( doPresets( pOpts )))
- return 0;
-
- /*
- * IF option name conversion was suppressed but it is not suppressed
- * for the command line, then it's time to translate option names.
- * Usage text will not get retranslated.
- */
- if ( ((pOpts->fOptSet & OPTPROC_TRANSLATE) != 0)
- && (pOpts->pTransProc != NULL)
- && ((pOpts->fOptSet & OPTPROC_NO_XLAT_MASK)
- == OPTPROC_NXLAT_OPT_CFG) ) {
-
- pOpts->fOptSet &= ~OPTPROC_NXLAT_OPT_CFG;
- (*pOpts->pTransProc)();
- }
-
- if ((pOpts->fOptSet & OPTPROC_REORDER) != 0)
- optionSort( pOpts );
-
- pOpts->curOptIdx = 1;
- pOpts->pzCurOpt = NULL;
- }
-
- /*
- * IF we are (re)starting,
- * THEN reset option location
- */
- else if (pOpts->curOptIdx <= 0) {
- pOpts->curOptIdx = 1;
- pOpts->pzCurOpt = NULL;
- }
-
- if (! SUCCESSFUL( doRegularOpts( pOpts )))
- return pOpts->origArgCt;
-
- /*
- * IF there were no errors
- * AND we have RC/INI files
- * AND there is a request to save the files
- * THEN do that now before testing for conflicts.
- * (conflicts are ignored in preset options)
- */
- if ( (pOpts->specOptIdx.save_opts != NO_EQUIVALENT)
- && (pOpts->specOptIdx.save_opts != 0)) {
- tOptDesc* pOD = pOpts->pOptDesc + pOpts->specOptIdx.save_opts;
-
- if (SELECTED_OPT( pOD )) {
- optionSaveFile( pOpts );
- exit( EXIT_SUCCESS );
- }
- }
-
- /*
- * IF we are checking for errors,
- * THEN look for too few occurrences of required options
- */
- if ((pOpts->fOptSet & OPTPROC_ERRSTOP) != 0) {
- if (checkConsistency( pOpts ) != 0)
- (*pOpts->pUsageProc)( pOpts, EXIT_FAILURE );
- }
-
- return pOpts->curOptIdx;
-}
-
-/*
- * Local Variables:
- * mode: C
- * c-file-style: "stroustrup"
- * indent-tabs-mode: nil
- * End:
- * end of autoopts/autoopts.c */
+++ /dev/null
-
-/*
- * Time-stamp: "2008-11-01 20:08:06 bkorb"
- *
- * autoopts.h $Id: d5e30331d37ca10ec88c592d24d8615dd6c1f0ee $
- *
- * This file defines all the global structures and special values
- * used in the automated option processing library.
- *
- * This file is part of AutoOpts, a companion to AutoGen.
- * AutoOpts is free software.
- * AutoOpts is copyright (c) 1992-2009 by Bruce Korb - all rights reserved
- *
- * AutoOpts is available under any one of two licenses. The license
- * in use must be one of these two and the choice is under the control
- * of the user of the license.
- *
- * The GNU Lesser General Public License, version 3 or later
- * See the files "COPYING.lgplv3" and "COPYING.gplv3"
- *
- * The Modified Berkeley Software Distribution License
- * See the file "COPYING.mbsd"
- *
- * These files have the following md5sums:
- *
- * 43b91e8ca915626ed3818ffb1b71248b pkg/libopts/COPYING.gplv3
- * 06a1a2e4760c90ea5e1dad8dfaac4d39 pkg/libopts/COPYING.lgplv3
- * 66a5cedaf62c4b2637025f049f9b826f pkg/libopts/COPYING.mbsd
- */
-
-#ifndef AUTOGEN_AUTOOPTS_H
-#define AUTOGEN_AUTOOPTS_H
-
-#include "compat/compat.h"
-#include "ag-char-map.h"
-
-#define AO_NAME_LIMIT 127
-#define AO_NAME_SIZE ((size_t)(AO_NAME_LIMIT + 1))
-
-#ifndef AG_PATH_MAX
-# ifdef PATH_MAX
-# define AG_PATH_MAX ((size_t)PATH_MAX)
-# else
-# define AG_PATH_MAX ((size_t)4096)
-# endif
-#else
-# if defined(PATH_MAX) && (PATH_MAX > MAXPATHLEN)
-# undef AG_PATH_MAX
-# define AG_PATH_MAX ((size_t)PATH_MAX)
-# endif
-#endif
-
-#undef EXPORT
-#define EXPORT
-
-#if defined(_WIN32) && !defined(__CYGWIN__)
-# define DIRCH '\\'
-#else
-# define DIRCH '/'
-#endif
-
-#ifndef EX_NOINPUT
-# define EX_NOINPUT 66
-#endif
-#ifndef EX_SOFTWARE
-# define EX_SOFTWARE 70
-#endif
-#ifndef EX_CONFIG
-# define EX_CONFIG 78
-#endif
-
-/*
- * Convert the number to a list usable in a printf call
- */
-#define NUM_TO_VER(n) ((n) >> 12), ((n) >> 7) & 0x001F, (n) & 0x007F
-
-#define NAMED_OPTS(po) \
- (((po)->fOptSet & (OPTPROC_SHORTOPT | OPTPROC_LONGOPT)) == 0)
-
-#define SKIP_OPT(p) (((p)->fOptState & (OPTST_DOCUMENT|OPTST_OMITTED)) != 0)
-
-typedef int tDirection;
-#define DIRECTION_PRESET -1
-#define DIRECTION_PROCESS 1
-#define DIRECTION_CALLED 0
-
-#define PROCESSING(d) ((d)>0)
-#define PRESETTING(d) ((d)<0)
-
-/*
- * Procedure success codes
- *
- * USAGE: define procedures to return "tSuccess". Test their results
- * with the SUCCEEDED, FAILED and HADGLITCH macros.
- *
- * Microsoft sticks its nose into user space here, so for Windows' sake,
- * make sure all of these are undefined.
- */
-#undef SUCCESS
-#undef FAILURE
-#undef PROBLEM
-#undef SUCCEEDED
-#undef SUCCESSFUL
-#undef FAILED
-#undef HADGLITCH
-
-#define SUCCESS ((tSuccess) 0)
-#define FAILURE ((tSuccess)-1)
-#define PROBLEM ((tSuccess) 1)
-
-typedef int tSuccess;
-
-#define SUCCEEDED( p ) ((p) == SUCCESS)
-#define SUCCESSFUL( p ) SUCCEEDED( p )
-#define FAILED( p ) ((p) < SUCCESS)
-#define HADGLITCH( p ) ((p) > SUCCESS)
-
-/*
- * When loading a line (or block) of text as an option, the value can
- * be processed in any of several modes:
- *
- * @table @samp
- * @item keep
- * Every part of the value between the delimiters is saved.
- *
- * @item uncooked
- * Even if the value begins with quote characters, do not do quote processing.
- *
- * @item cooked
- * If the value looks like a quoted string, then process it.
- * Double quoted strings are processed the way strings are in "C" programs,
- * except they are treated as regular characters if the following character
- * is not a well-established escape sequence.
- * Single quoted strings (quoted with apostrophies) are handled the way
- * strings are handled in shell scripts, *except* that backslash escapes
- * are honored before backslash escapes and apostrophies.
- * @end table
- */
-typedef enum {
- OPTION_LOAD_COOKED,
- OPTION_LOAD_UNCOOKED,
- OPTION_LOAD_KEEP
-} tOptionLoadMode;
-
-extern tOptionLoadMode option_load_mode;
-
-/*
- * The pager state is used by optionPagedUsage() procedure.
- * When it runs, it sets itself up to be called again on exit.
- * If, however, a routine needs a child process to do some work
- * before it is done, then 'pagerState' must be set to
- * 'PAGER_STATE_CHILD' so that optionPagedUsage() will not try
- * to run the pager program before its time.
- */
-typedef enum {
- PAGER_STATE_INITIAL,
- PAGER_STATE_READY,
- PAGER_STATE_CHILD
-} tePagerState;
-
-extern tePagerState pagerState;
-
-typedef enum {
- ENV_ALL,
- ENV_IMM,
- ENV_NON_IMM
-} teEnvPresetType;
-
-typedef enum {
- TOPT_UNDEFINED = 0,
- TOPT_SHORT,
- TOPT_LONG,
- TOPT_DEFAULT
-} teOptType;
-
-typedef struct {
- tOptDesc* pOD;
- tCC* pzOptArg;
- tAoUL flags;
- teOptType optType;
-} tOptState;
-#define OPTSTATE_INITIALIZER(st) \
- { NULL, NULL, OPTST_ ## st, TOPT_UNDEFINED }
-
-#define TEXTTO_TABLE \
- _TT_( LONGUSAGE ) \
- _TT_( USAGE ) \
- _TT_( VERSION )
-#define _TT_(n) \
- TT_ ## n ,
-
-typedef enum { TEXTTO_TABLE COUNT_TT } teTextTo;
-
-#undef _TT_
-
-typedef struct {
- tCC* pzStr;
- tCC* pzReq;
- tCC* pzNum;
- tCC* pzFile;
- tCC* pzKey;
- tCC* pzKeyL;
- tCC* pzBool;
- tCC* pzNest;
- tCC* pzOpt;
- tCC* pzNo;
- tCC* pzBrk;
- tCC* pzNoF;
- tCC* pzSpc;
- tCC* pzOptFmt;
- tCC* pzTime;
-} arg_types_t;
-
-#define AGALOC( c, w ) ao_malloc((size_t)c)
-#define AGREALOC( p, c, w ) ao_realloc((void*)p, (size_t)c)
-#define AGFREE(_p) do{void*X=(void*)_p;ao_free(X);}while(0)
-#define AGDUPSTR( p, s, w ) (p = ao_strdup(s))
-
-static void *
-ao_malloc( size_t sz );
-
-static void *
-ao_realloc( void *p, size_t sz );
-
-static void
-ao_free( void *p );
-
-static char *
-ao_strdup( char const *str );
-
-#define TAGMEM( m, t )
-
-/*
- * DO option handling?
- *
- * Options are examined at two times: at immediate handling time and at
- * normal handling time. If an option is disabled, the timing may be
- * different from the handling of the undisabled option. The OPTST_DIABLED
- * bit indicates the state of the currently discovered option.
- * So, here's how it works:
- *
- * A) handling at "immediate" time, either 1 or 2:
- *
- * 1. OPTST_DISABLED is not set:
- * IMM must be set
- * DISABLE_IMM don't care
- * TWICE don't care
- * DISABLE_TWICE don't care
- * 0 -and- 1 x x x
- *
- * 2. OPTST_DISABLED is set:
- * IMM don't care
- * DISABLE_IMM must be set
- * TWICE don't care
- * DISABLE_TWICE don't care
- * 1 -and- x 1 x x
- */
-#define DO_IMMEDIATELY(_flg) \
- ( (((_flg) & (OPTST_DISABLED|OPTST_IMM)) == OPTST_IMM) \
- || ( ((_flg) & (OPTST_DISABLED|OPTST_DISABLE_IMM)) \
- == (OPTST_DISABLED|OPTST_DISABLE_IMM) ))
-
-/* B) handling at "regular" time because it was not immediate
- *
- * 1. OPTST_DISABLED is not set:
- * IMM must *NOT* be set
- * DISABLE_IMM don't care
- * TWICE don't care
- * DISABLE_TWICE don't care
- * 0 -and- 0 x x x
- *
- * 2. OPTST_DISABLED is set:
- * IMM don't care
- * DISABLE_IMM don't care
- * TWICE must be set
- * DISABLE_TWICE don't care
- * 1 -and- x x 1 x
- */
-#define DO_NORMALLY(_flg) ( \
- (((_flg) & (OPTST_DISABLED|OPTST_IMM)) == 0) \
- || (((_flg) & (OPTST_DISABLED|OPTST_DISABLE_IMM)) == \
- OPTST_DISABLED) )
-
-/* C) handling at "regular" time because it is to be handled twice.
- * The immediate bit was already tested and found to be set:
- *
- * 3. OPTST_DISABLED is not set:
- * IMM is set (but don't care)
- * DISABLE_IMM don't care
- * TWICE must be set
- * DISABLE_TWICE don't care
- * 0 -and- ? x 1 x
- *
- * 4. OPTST_DISABLED is set:
- * IMM don't care
- * DISABLE_IMM is set (but don't care)
- * TWICE don't care
- * DISABLE_TWICE must be set
- * 1 -and- x ? x 1
- */
-#define DO_SECOND_TIME(_flg) ( \
- (((_flg) & (OPTST_DISABLED|OPTST_TWICE)) == \
- OPTST_TWICE) \
- || (((_flg) & (OPTST_DISABLED|OPTST_DISABLE_TWICE)) == \
- (OPTST_DISABLED|OPTST_DISABLE_TWICE) ))
-
-/*
- * text_mmap structure. Only active on platforms with mmap(2).
- */
-#ifdef HAVE_SYS_MMAN_H
-# include <sys/mman.h>
-#else
-# ifndef PROT_READ
-# define PROT_READ 0x01
-# endif
-# ifndef PROT_WRITE
-# define PROT_WRITE 0x02
-# endif
-# ifndef MAP_SHARED
-# define MAP_SHARED 0x01
-# endif
-# ifndef MAP_PRIVATE
-# define MAP_PRIVATE 0x02
-# endif
-#endif
-
-#ifndef MAP_FAILED
-# define MAP_FAILED ((void*)-1)
-#endif
-
-#ifndef _SC_PAGESIZE
-# ifdef _SC_PAGE_SIZE
-# define _SC_PAGESIZE _SC_PAGE_SIZE
-# endif
-#endif
-
-#ifndef HAVE_STRCHR
-extern char* strchr( char const *s, int c);
-extern char* strrchr( char const *s, int c);
-#endif
-
-/*
- * Define and initialize all the user visible strings.
- * We do not do translations. If translations are to be done, then
- * the client will provide a callback for that purpose.
- */
-#undef DO_TRANSLATIONS
-#include "autoopts/usage-txt.h"
-
-/*
- * File pointer for usage output
- */
-extern FILE* option_usage_fp;
-
-extern tOptProc optionPrintVersion, optionPagedUsage, optionLoadOpt;
-
-#endif /* AUTOGEN_AUTOOPTS_H */
-/*
- * Local Variables:
- * mode: C
- * c-file-style: "stroustrup"
- * indent-tabs-mode: nil
- * End:
- * end of autoopts/autoopts.h */
+++ /dev/null
-/* -*- buffer-read-only: t -*- vi: set ro:
- *
- * DO NOT EDIT THIS FILE (options.h)
- *
- * It has been AutoGen-ed November 8, 2009 at 08:41:08 AM by AutoGen 5.9.10pre13
- * From the definitions funcs.def
- * and the template file options_h
- *
- * This file defines all the global structures and special values
- * used in the automated option processing library.
- *
- * Automated Options copyright (c) 1992-Y by Bruce Korb
- *
- * AutoOpts is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published
- * by the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * AutoOpts 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 Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-#ifndef AUTOOPTS_OPTIONS_H_GUARD
-#define AUTOOPTS_OPTIONS_H_GUARD 1
-#include <sys/types.h>
-#include <stdio.h>
-
-#if defined(HAVE_STDINT_H)
-# include <stdint.h>
-#elif defined(HAVE_INTTYPES_H)
-# include <inttypes.h>
-#endif /* HAVE_STDINT/INTTYPES_H */
-
-#if defined(HAVE_LIMITS_H)
-# include <limits.h>
-#elif defined(HAVE_SYS_LIMITS_H)
-# include <sys/limits.h>
-#endif /* HAVE_LIMITS/SYS_LIMITS_H */
-
-#if defined(HAVE_SYSEXITS_H)
-# include <sysexits.h>
-#endif /* HAVE_SYSEXITS_H */
-
-#ifndef EX_USAGE
-# define EX_USAGE 64
-#endif
-
-/*
- * PUBLIC DEFINES
- *
- * The following defines may be used in applications that need to test the
- * state of an option. To test against these masks and values, a pointer
- * to an option descriptor must be obtained. There are two ways:
- *
- * 1. inside an option processing procedure, it is the second argument,
- * conventionally "tOptDesc* pOD".
- *
- * 2. Outside of an option procedure (or to reference a different option
- * descriptor), use either "&DESC( opt_name )" or "&pfx_DESC( opt_name )".
- *
- * See the relevant generated header file to determine which and what
- * values for "opt_name" are available.
- */
-
-#define OPTIONS_STRUCT_VERSION 135168
-#define OPTIONS_VERSION_STRING "33:0:8"
-#define OPTIONS_MINIMUM_VERSION 102400
-#define OPTIONS_MIN_VER_STRING "25:0:0"
-
-typedef enum {
- OPARG_TYPE_NONE = 0,
- OPARG_TYPE_STRING = 1, /* default type/ vanilla string */
- OPARG_TYPE_ENUMERATION = 2, /* opt arg is an enum (keyword list) */
- OPARG_TYPE_BOOLEAN = 3, /* opt arg is boolean-valued */
- OPARG_TYPE_MEMBERSHIP = 4, /* opt arg sets set membership bits */
- OPARG_TYPE_NUMERIC = 5, /* opt arg has numeric value */
- OPARG_TYPE_HIERARCHY = 6, /* option arg is hierarchical value */
- OPARG_TYPE_FILE = 7, /* option arg names a file */
- OPARG_TYPE_TIME = 8 /* opt arg is a time duration */
-} teOptArgType;
-
-typedef struct optionValue {
- teOptArgType valType;
- char* pzName;
- union {
- char strVal[1]; /* OPARG_TYPE_STRING */
- unsigned int enumVal; /* OPARG_TYPE_ENUMERATION */
- unsigned int boolVal; /* OPARG_TYPE_BOOLEAN */
- unsigned long setVal; /* OPARG_TYPE_MEMBERSHIP */
- long longVal; /* OPARG_TYPE_NUMERIC */
- void* nestVal; /* OPARG_TYPE_HIERARCHY */
- } v;
-} tOptionValue;
-
-typedef enum {
- FTYPE_MODE_MAY_EXIST = 0x00,
- FTYPE_MODE_MUST_EXIST = 0x01,
- FTYPE_MODE_MUST_NOT_EXIST = 0x02,
- FTYPE_MODE_EXIST_MASK = 0x03,
- FTYPE_MODE_NO_OPEN = 0x00,
- FTYPE_MODE_OPEN_FD = 0x10,
- FTYPE_MODE_FOPEN_FP = 0x20,
- FTYPE_MODE_OPEN_MASK = 0x30
-} teOptFileType;
-
-typedef union {
- int file_flags;
- char const * file_mode;
-} tuFileMode;
-
-/*
- * Bits in the fOptState option descriptor field.
- */
-typedef enum {
- OPTST_SET_ID = 0, /* Set via the "SET_OPT()" macro */
- OPTST_PRESET_ID = 1, /* Set via an RC/INI file */
- OPTST_DEFINED_ID = 2, /* Set via a command line option */
- OPTST_RESET_ID = 3, /* Reset via command line option */
- OPTST_EQUIVALENCE_ID = 4, /* selected by equiv'ed option */
- OPTST_DISABLED_ID = 5, /* option is in disabled state */
- OPTST_ALLOC_ARG_ID = 6, /* pzOptArg was allocated */
- OPTST_NO_INIT_ID = 8, /* option cannot be preset */
- OPTST_NUMBER_OPT_ID = 9, /* opt value (flag) is any digit */
- OPTST_STACKED_ID = 10, /* opt uses optionStackArg proc */
- OPTST_INITENABLED_ID = 11, /* option defaults to enabled */
- OPTST_ARG_TYPE_1_ID = 12, /* bit 1 of arg type enum */
- OPTST_ARG_TYPE_2_ID = 13, /* bit 2 of arg type enum */
- OPTST_ARG_TYPE_3_ID = 14, /* bit 3 of arg type enum */
- OPTST_ARG_TYPE_4_ID = 15, /* bit 4 of arg type enum */
- OPTST_ARG_OPTIONAL_ID = 16, /* the option arg not required */
- OPTST_IMM_ID = 17, /* process opt on first pass */
- OPTST_DISABLE_IMM_ID = 18, /* process disablement immed. */
- OPTST_OMITTED_ID = 19, /* compiled out of program */
- OPTST_MUST_SET_ID = 20, /* must be set or pre-set */
- OPTST_DOCUMENT_ID = 21, /* opt is for doc only */
- OPTST_TWICE_ID = 22, /* process opt twice - imm + reg */
- OPTST_DISABLE_TWICE_ID = 23, /* process disabled option twice */
- OPTST_SCALED_NUM_ID = 24, /* scaled integer value */
- OPTST_NO_COMMAND_ID = 25, /* disable from cmd line */
- OPTST_DEPRECATED_ID = 26 /* support is being removed */
-} opt_state_enum_t;
-
-#define OPTST_INIT 0U
-#define OPTST_SET (1U << OPTST_SET_ID)
-#define OPTST_PRESET (1U << OPTST_PRESET_ID)
-#define OPTST_DEFINED (1U << OPTST_DEFINED_ID)
-#define OPTST_RESET (1U << OPTST_RESET_ID)
-#define OPTST_EQUIVALENCE (1U << OPTST_EQUIVALENCE_ID)
-#define OPTST_DISABLED (1U << OPTST_DISABLED_ID)
-#define OPTST_ALLOC_ARG (1U << OPTST_ALLOC_ARG_ID)
-#define OPTST_NO_INIT (1U << OPTST_NO_INIT_ID)
-#define OPTST_NUMBER_OPT (1U << OPTST_NUMBER_OPT_ID)
-#define OPTST_STACKED (1U << OPTST_STACKED_ID)
-#define OPTST_INITENABLED (1U << OPTST_INITENABLED_ID)
-#define OPTST_ARG_TYPE_1 (1U << OPTST_ARG_TYPE_1_ID)
-#define OPTST_ARG_TYPE_2 (1U << OPTST_ARG_TYPE_2_ID)
-#define OPTST_ARG_TYPE_3 (1U << OPTST_ARG_TYPE_3_ID)
-#define OPTST_ARG_TYPE_4 (1U << OPTST_ARG_TYPE_4_ID)
-#define OPTST_ARG_OPTIONAL (1U << OPTST_ARG_OPTIONAL_ID)
-#define OPTST_IMM (1U << OPTST_IMM_ID)
-#define OPTST_DISABLE_IMM (1U << OPTST_DISABLE_IMM_ID)
-#define OPTST_OMITTED (1U << OPTST_OMITTED_ID)
-#define OPTST_MUST_SET (1U << OPTST_MUST_SET_ID)
-#define OPTST_DOCUMENT (1U << OPTST_DOCUMENT_ID)
-#define OPTST_TWICE (1U << OPTST_TWICE_ID)
-#define OPTST_DISABLE_TWICE (1U << OPTST_DISABLE_TWICE_ID)
-#define OPTST_SCALED_NUM (1U << OPTST_SCALED_NUM_ID)
-#define OPTST_NO_COMMAND (1U << OPTST_NO_COMMAND_ID)
-#define OPTST_DEPRECATED (1U << OPTST_DEPRECATED_ID)
-#define OPT_STATE_MASK 0x07FFFF7FU
-
-#define OPTST_SET_MASK ( \
- OPTST_DEFINED | OPTST_PRESET | OPTST_RESET | \
- OPTST_SET \
- /* 0x0000000FU */ )
-
-#define OPTST_MUTABLE_MASK ( \
- OPTST_ALLOC_ARG | OPTST_DEFINED | \
- OPTST_DISABLED | OPTST_EQUIVALENCE | \
- OPTST_PRESET | OPTST_RESET | \
- OPTST_SET \
- /* 0x0000007FU */ )
-
-#define OPTST_SELECTED_MASK ( \
- OPTST_DEFINED | OPTST_SET \
- /* 0x00000005U */ )
-
-#define OPTST_ARG_TYPE_MASK ( \
- OPTST_ARG_TYPE_1 | OPTST_ARG_TYPE_2 | OPTST_ARG_TYPE_3 | \
- OPTST_ARG_TYPE_4 \
- /* 0x0000F000U */ )
-
-#define OPTST_DO_NOT_SAVE_MASK ( \
- OPTST_DOCUMENT | OPTST_NO_INIT | OPTST_OMITTED \
- /* 0x00280100U */ )
-
-#define OPTST_NO_USAGE_MASK ( \
- OPTST_DEPRECATED | OPTST_NO_COMMAND | OPTST_OMITTED \
- /* 0x06080000U */ )
-
-#ifdef NO_OPTIONAL_OPT_ARGS
-# undef OPTST_ARG_OPTIONAL
-# define OPTST_ARG_OPTIONAL 0
-#endif
-
-#define OPTST_PERSISTENT_MASK (~OPTST_MUTABLE_MASK)
-
-#define SELECTED_OPT(_od) ((_od)->fOptState & OPTST_SELECTED_MASK)
-#define UNUSED_OPT( _od) (((_od)->fOptState & OPTST_SET_MASK) == 0)
-#define DISABLED_OPT(_od) ((_od)->fOptState & OPTST_DISABLED)
-#define OPTION_STATE(_od) ((_od)->fOptState)
-#define OPTST_SET_ARGTYPE(_n) ((_n) << OPTST_ARG_TYPE_1_ID)
-#define OPTST_GET_ARGTYPE(_f) (((_f)&OPTST_ARG_TYPE_MASK)>>OPTST_ARG_TYPE_1_ID)
-
-/*
- * PRIVATE INTERFACES
- *
- * The following values are used in the generated code to communicate
- * with the option library procedures. They are not for public use
- * and may be subject to change.
- */
-
-/*
- * Define the processing state flags
- */
-typedef enum {
- OPTPROC_LONGOPT_ID = 0, /* Process long style options */
- OPTPROC_SHORTOPT_ID = 1, /* Process short style "flags" */
- OPTPROC_ERRSTOP_ID = 2, /* Stop on argument errors */
- OPTPROC_DISABLEDOPT_ID = 3, /* Current option is disabled */
- OPTPROC_NO_REQ_OPT_ID = 4, /* no options are required */
- OPTPROC_NUM_OPT_ID = 5, /* there is a number option */
- OPTPROC_INITDONE_ID = 6, /* have inits been done? */
- OPTPROC_NEGATIONS_ID = 7, /* any negation options? */
- OPTPROC_ENVIRON_ID = 8, /* check environment? */
- OPTPROC_NO_ARGS_ID = 9, /* Disallow remaining arguments */
- OPTPROC_ARGS_REQ_ID = 10, /* Require args after options */
- OPTPROC_REORDER_ID = 11, /* reorder operands after opts */
- OPTPROC_GNUUSAGE_ID = 12, /* emit usage in GNU style */
- OPTPROC_TRANSLATE_ID = 13, /* Translate strings in tOptions */
- OPTPROC_NXLAT_OPT_CFG_ID = 16, /* suppress for config only */
- OPTPROC_NXLAT_OPT_ID = 17, /* suppress xlation always */
- OPTPROC_PRESETTING_ID = 19 /* opt processing in preset state */
-} optproc_state_enum_t;
-
-#define OPTPROC_NONE 0U
-#define OPTPROC_LONGOPT (1U << OPTPROC_LONGOPT_ID)
-#define OPTPROC_SHORTOPT (1U << OPTPROC_SHORTOPT_ID)
-#define OPTPROC_ERRSTOP (1U << OPTPROC_ERRSTOP_ID)
-#define OPTPROC_DISABLEDOPT (1U << OPTPROC_DISABLEDOPT_ID)
-#define OPTPROC_NO_REQ_OPT (1U << OPTPROC_NO_REQ_OPT_ID)
-#define OPTPROC_NUM_OPT (1U << OPTPROC_NUM_OPT_ID)
-#define OPTPROC_INITDONE (1U << OPTPROC_INITDONE_ID)
-#define OPTPROC_NEGATIONS (1U << OPTPROC_NEGATIONS_ID)
-#define OPTPROC_ENVIRON (1U << OPTPROC_ENVIRON_ID)
-#define OPTPROC_NO_ARGS (1U << OPTPROC_NO_ARGS_ID)
-#define OPTPROC_ARGS_REQ (1U << OPTPROC_ARGS_REQ_ID)
-#define OPTPROC_REORDER (1U << OPTPROC_REORDER_ID)
-#define OPTPROC_GNUUSAGE (1U << OPTPROC_GNUUSAGE_ID)
-#define OPTPROC_TRANSLATE (1U << OPTPROC_TRANSLATE_ID)
-#define OPTPROC_NXLAT_OPT_CFG (1U << OPTPROC_NXLAT_OPT_CFG_ID)
-#define OPTPROC_NXLAT_OPT (1U << OPTPROC_NXLAT_OPT_ID)
-#define OPTPROC_PRESETTING (1U << OPTPROC_PRESETTING_ID)
-#define OPTPROC_STATE_MASK 0x000B3FFFU
-
-#define OPTPROC_NO_XLAT_MASK ( \
- OPTPROC_NXLAT_OPT | OPTPROC_NXLAT_OPT_CFG \
- /* 0x00030000U */ )
-
-#define STMTS(s) do { s; } while (0)
-
-/*
- * The following must be #defined instead of typedef-ed
- * because "static const" cannot both be applied to a type,
- * tho each individually can...so they all are
- */
-#define tSCC static char const
-#define tCC char const
-#define tAoSC static char
-#define tAoUC unsigned char
-#define tAoUI unsigned int
-#define tAoUL unsigned long
-#define tAoUS unsigned short
-
-/*
- * It is so disgusting that there must be so many ways
- * of specifying TRUE and FALSE.
- */
-typedef enum { AG_FALSE = 0, AG_TRUE } ag_bool;
-
-/*
- * Define a structure that describes each option and
- * a pointer to the procedure that handles it.
- * The argument is the count of this flag previously seen.
- */
-typedef struct options tOptions;
-typedef struct optDesc tOptDesc;
-typedef struct optNames tOptNames;
-#define OPTPROC_EMIT_USAGE ((tOptions *)0x01UL)
-#define OPTPROC_EMIT_SHELL ((tOptions *)0x02UL)
-#define OPTPROC_RETURN_VALNAME ((tOptions *)0x03UL)
-#define OPTPROC_EMIT_LIMIT ((tOptions *)0x0FUL)
-
-/*
- * The option procedures do the special processing for each
- * option flag that needs it.
- */
-typedef void (tOptProc)(tOptions* pOpts, tOptDesc* pOptDesc);
-typedef tOptProc* tpOptProc;
-
-/*
- * The usage procedure will never return. It calls "exit(2)"
- * with the "exitCode" argument passed to it.
- */
-// coverity[+kill]
-typedef void (tUsageProc)(tOptions* pOpts, int exitCode);
-typedef tUsageProc* tpUsageProc;
-
-/*
- * Special definitions. "NOLIMIT" is the 'max' value to use when
- * a flag may appear multiple times without limit. "NO_EQUIVALENT"
- * is an illegal value for 'optIndex' (option description index).
- */
-#define NOLIMIT USHRT_MAX
-#define OPTION_LIMIT SHRT_MAX
-#define NO_EQUIVALENT (OPTION_LIMIT+1)
-
-/*
- * Special values for optValue. It must not be generatable from the
- * computation "optIndex +96". Since "optIndex" is limited to 100, ...
- */
-#define NUMBER_OPTION '#'
-
-typedef struct argList tArgList;
-#define MIN_ARG_ALLOC_CT 6
-#define INCR_ARG_ALLOC_CT 8
-struct argList {
- int useCt;
- int allocCt;
- tCC* apzArgs[ MIN_ARG_ALLOC_CT ];
-};
-
-typedef union {
- char const * argString;
- uintptr_t argEnum;
- uintptr_t argIntptr;
- long argInt;
- unsigned long argUint;
- unsigned int argBool;
- FILE* argFp;
- int argFd;
-} optArgBucket_t;
-
-/*
- * Descriptor structure for each option.
- * Only the fields marked "PUBLIC" are for public use.
- */
-struct optDesc {
- tAoUS const optIndex; /* PUBLIC */
- tAoUS const optValue; /* PUBLIC */
- tAoUS optActualIndex; /* PUBLIC */
- tAoUS optActualValue; /* PUBLIC */
-
- tAoUS const optEquivIndex; /* PUBLIC */
- tAoUS const optMinCt;
- tAoUS const optMaxCt;
- tAoUS optOccCt; /* PUBLIC */
-
- tAoUI fOptState; /* PUBLIC */
- tAoUI reserved;
- optArgBucket_t optArg; /* PUBLIC */
-# define pzLastArg optArg.argString
- void* optCookie; /* PUBLIC */
-
- int const * const pOptMust;
- int const * const pOptCant;
- tpOptProc const pOptProc;
- char const* const pzText;
-
- char const* const pz_NAME;
- char const* const pz_Name;
- char const* const pz_DisableName;
- char const* const pz_DisablePfx;
-};
-
-/*
- * Some options need special processing, so we store their
- * indexes in a known place:
- */
-typedef struct optSpecIndex tOptSpecIndex;
-struct optSpecIndex {
- const tAoUS more_help;
- const tAoUS save_opts;
- const tAoUS number_option;
- const tAoUS default_opt;
-};
-
-/*
- * The procedure generated for translating option text
- */
-typedef void (tOptionXlateProc)(void);
-
-struct options {
- int const structVersion;
- int origArgCt;
- char** origArgVect;
- unsigned int fOptSet;
- unsigned int curOptIdx;
- char* pzCurOpt;
-
- char const* pzProgPath; /* PUBLIC */
- char const* pzProgName; /* PUBLIC */
- char const* const pzPROGNAME; /* PUBLIC */
- char const* const pzRcName; /* PUBLIC */
- char const* const pzCopyright; /* PUBLIC */
- char const* const pzCopyNotice; /* PUBLIC */
- char const* const pzFullVersion; /* PUBLIC */
- char const* const* const papzHomeList;
- char const* const pzUsageTitle;
- char const* const pzExplain;
- char const* const pzDetail;
- tOptDesc* const pOptDesc; /* PUBLIC */
- char const* const pzBugAddr; /* PUBLIC */
-
- void* pExtensions;
- void* pSavedState;
-
- // coverity[+kill]
- tpUsageProc pUsageProc;
- tOptionXlateProc* pTransProc;
-
- tOptSpecIndex specOptIdx;
- int const optCt;
- int const presetOptCt;
- char const * pzFullUsage;
- char const * pzShortUsage;
- /* PUBLIC: */
- optArgBucket_t const * const originalOptArgArray;
- void * const * const originalOptArgCookie;
-};
-
-/*
- * Versions where in various fields first appear:
- * ($AO_CURRENT * 4096 + $AO_REVISION, but $AO_REVISION must be zero)
- */
-#define originalOptArgArray_STRUCT_VERSION 131072 /* AO_CURRENT = 32 */
-#define HAS_originalOptArgArray(_opt) \
- ((_opt)->structVersion >= originalOptArgArray_STRUCT_VERSION)
-
-/*
- * "token list" structure returned by "string_tokenize()"
- */
-typedef struct {
- unsigned long tkn_ct;
- unsigned char* tkn_list[1];
-} token_list_t;
-
-/*
- * Hide the interface - it pollutes a POSIX claim, but leave it for
- * anyone #include-ing this header
- */
-#define strneqvcmp option_strneqvcmp
-#define streqvcmp option_streqvcmp
-#define streqvmap option_streqvmap
-#define strequate option_strequate
-#define strtransform option_strtransform
-
-/*
- * This is an output only structure used by text_mmap and text_munmap.
- * Clients must not alter the contents and must provide it to both
- * the text_mmap and text_munmap procedures. BE ADVISED: if you are
- * mapping the file with PROT_WRITE the NUL byte at the end MIGHT NOT
- * BE WRITABLE. In any event, that byte is not be written back
- * to the source file. ALSO: if "txt_data" is valid and "txt_errno"
- * is not zero, then there *may* not be a terminating NUL.
- */
-typedef struct {
- void* txt_data; /* text file data */
- size_t txt_size; /* actual file size */
- size_t txt_full_size; /* mmaped mem size */
- int txt_fd; /* file descriptor */
- int txt_zero_fd; /* fd for /dev/zero */
- int txt_errno; /* warning code */
- int txt_prot; /* "prot" flags */
- int txt_flags; /* mapping type */
- int txt_alloc; /* if we malloced memory */
-} tmap_info_t;
-
-#define TEXT_MMAP_FAILED_ADDR(a) ((void*)(a) == (void*)MAP_FAILED)
-
-#ifdef __cplusplus
-extern "C" {
-#define CPLUSPLUS_CLOSER }
-#else
-#define CPLUSPLUS_CLOSER
-#endif
-
-/*
- * The following routines may be coded into AutoOpts client code:
- */
-
-/* From: tokenize.c line 117
- *
- * ao_string_tokenize - tokenize an input string
- *
- * Arguments:
- * string string to be tokenized
- *
- * Returns: token_list_t* - pointer to a structure that lists each token
- *
- * This function will convert one input string into a list of strings.
- * The list of strings is derived by separating the input based on
- * white space separation. However, if the input contains either single
- * or double quote characters, then the text after that character up to
- * a matching quote will become the string in the list.
- *
- * The returned pointer should be deallocated with @code{free(3C)} when
- * are done using the data. The data are placed in a single block of
- * allocated memory. Do not deallocate individual token/strings.
- *
- * The structure pointed to will contain at least these two fields:
- * @table @samp
- * @item tkn_ct
- * The number of tokens found in the input string.
- * @item tok_list
- * An array of @code{tkn_ct + 1} pointers to substring tokens, with
- * the last pointer set to NULL.
- * @end table
- *
- * There are two types of quoted strings: single quoted (@code{'}) and
- * double quoted (@code{"}). Singly quoted strings are fairly raw in that
- * escape characters (@code{\\}) are simply another character, except when
- * preceding the following characters:
- * @example
- * @code{\\} double backslashes reduce to one
- * @code{'} incorporates the single quote into the string
- * @code{\n} suppresses both the backslash and newline character
- * @end example
- *
- * Double quote strings are formed according to the rules of string
- * constants in ANSI-C programs.
- */
-extern token_list_t* ao_string_tokenize(char const*);
-
-
-/* From: configfile.c line 85
- *
- * configFileLoad - parse a configuration file
- *
- * Arguments:
- * pzFile the file to load
- *
- * Returns: const tOptionValue* - An allocated, compound value structure
- *
- * This routine will load a named configuration file and parse the
- * text as a hierarchically valued option. The option descriptor
- * created from an option definition file is not used via this interface.
- * The returned value is "named" with the input file name and is of
- * type "@code{OPARG_TYPE_HIERARCHY}". It may be used in calls to
- * @code{optionGetValue()}, @code{optionNextValue()} and
- * @code{optionUnloadNested()}.
- */
-extern const tOptionValue* configFileLoad(char const*);
-
-
-/* From: configfile.c line 897
- *
- * optionFileLoad - Load the locatable config files, in order
- *
- * Arguments:
- * pOpts program options descriptor
- * pzProg program name
- *
- * Returns: int - 0 -> SUCCESS, -1 -> FAILURE
- *
- * This function looks in all the specified directories for a configuration
- * file ("rc" file or "ini" file) and processes any found twice. The first
- * time through, they are processed in reverse order (last file first). At
- * that time, only "immediate action" configurables are processed. For
- * example, if the last named file specifies not processing any more
- * configuration files, then no more configuration files will be processed.
- * Such an option in the @strong{first} named directory will have no effect.
- *
- * Once the immediate action configurables have been handled, then the
- * directories are handled in normal, forward order. In that way, later
- * config files can override the settings of earlier config files.
- *
- * See the AutoOpts documentation for a thorough discussion of the
- * config file format.
- *
- * Configuration files not found or not decipherable are simply ignored.
- */
-extern int optionFileLoad(tOptions*, char const*);
-
-
-/* From: configfile.c line 217
- *
- * optionFindNextValue - find a hierarcicaly valued option instance
- *
- * Arguments:
- * pOptDesc an option with a nested arg type
- * pPrevVal the last entry
- * name name of value to find
- * value the matching value
- *
- * Returns: const tOptionValue* - a compound value structure
- *
- * This routine will find the next entry in a nested value option or
- * configurable. It will search through the list and return the next entry
- * that matches the criteria.
- */
-extern const tOptionValue* optionFindNextValue(const tOptDesc*, const tOptionValue*, char const*, char const*);
-
-
-/* From: configfile.c line 143
- *
- * optionFindValue - find a hierarcicaly valued option instance
- *
- * Arguments:
- * pOptDesc an option with a nested arg type
- * name name of value to find
- * value the matching value
- *
- * Returns: const tOptionValue* - a compound value structure
- *
- * This routine will find an entry in a nested value option or configurable.
- * It will search through the list and return a matching entry.
- */
-extern const tOptionValue* optionFindValue(const tOptDesc*, char const*, char const*);
-
-
-/* From: restore.c line 165
- *
- * optionFree - free allocated option processing memory
- *
- * Arguments:
- * pOpts program options descriptor
- *
- * AutoOpts sometimes allocates memory and puts pointers to it in the
- * option state structures. This routine deallocates all such memory.
- */
-extern void optionFree(tOptions*);
-
-
-/* From: configfile.c line 286
- *
- * optionGetValue - get a specific value from a hierarcical list
- *
- * Arguments:
- * pOptValue a hierarchcal value
- * valueName name of value to get
- *
- * Returns: const tOptionValue* - a compound value structure
- *
- * This routine will find an entry in a nested value option or configurable.
- * If "valueName" is NULL, then the first entry is returned. Otherwise,
- * the first entry with a name that exactly matches the argument will be
- * returned.
- */
-extern const tOptionValue* optionGetValue(const tOptionValue*, char const*);
-
-
-/* From: load.c line 498
- *
- * optionLoadLine - process a string for an option name and value
- *
- * Arguments:
- * pOpts program options descriptor
- * pzLine NUL-terminated text
- *
- * This is a client program callable routine for setting options from, for
- * example, the contents of a file that they read in. Only one option may
- * appear in the text. It will be treated as a normal (non-preset) option.
- *
- * When passed a pointer to the option struct and a string, it will find
- * the option named by the first token on the string and set the option
- * argument to the remainder of the string. The caller must NUL terminate
- * the string. Any embedded new lines will be included in the option
- * argument. If the input looks like one or more quoted strings, then the
- * input will be "cooked". The "cooking" is identical to the string
- * formation used in AutoGen definition files (@pxref{basic expression}),
- * except that you may not use backquotes.
- */
-extern void optionLoadLine(tOptions*, char const*);
-
-
-/* From: configfile.c line 345
- *
- * optionNextValue - get the next value from a hierarchical list
- *
- * Arguments:
- * pOptValue a hierarchcal list value
- * pOldValue a value from this list
- *
- * Returns: const tOptionValue* - a compound value structure
- *
- * This routine will return the next entry after the entry passed in. At the
- * end of the list, NULL will be returned. If the entry is not found on the
- * list, NULL will be returned and "@var{errno}" will be set to EINVAL.
- * The "@var{pOldValue}" must have been gotten from a prior call to this
- * routine or to "@code{opitonGetValue()}".
- */
-extern const tOptionValue* optionNextValue(const tOptionValue*, const tOptionValue*);
-
-
-/* From: usage.c line 107
- *
- * optionOnlyUsage - Print usage text for just the options
- *
- * Arguments:
- * pOpts program options descriptor
- * ex_code exit code for calling exit(3)
- *
- * This routine will print only the usage for each option.
- * This function may be used when the emitted usage must incorporate
- * information not available to AutoOpts.
- */
-extern void optionOnlyUsage(tOptions*, int);
-
-
-/* From: autoopts.c line 1058
- *
- * optionProcess - this is the main option processing routine
- *
- * Arguments:
- * pOpts program options descriptor
- * argc program arg count
- * argv program arg vector
- *
- * Returns: int - the count of the arguments processed
- *
- * This is the main entry point for processing options. It is intended
- * that this procedure be called once at the beginning of the execution of
- * a program. Depending on options selected earlier, it is sometimes
- * necessary to stop and restart option processing, or to select completely
- * different sets of options. This can be done easily, but you generally
- * do not want to do this.
- *
- * The number of arguments processed always includes the program name.
- * If one of the arguments is "--", then it is counted and the processing
- * stops. If an error was encountered and errors are to be tolerated, then
- * the returned value is the index of the argument causing the error.
- * A hyphen by itself ("-") will also cause processing to stop and will
- * @emph{not} be counted among the processed arguments. A hyphen by itself
- * is treated as an operand. Encountering an operand stops option
- * processing.
- */
-extern int optionProcess(tOptions*, int, char**);
-
-
-/* From: restore.c line 122
- *
- * optionRestore - restore option state from memory copy
- *
- * Arguments:
- * pOpts program options descriptor
- *
- * Copy back the option state from saved memory.
- * The allocated memory is left intact, so this routine can be
- * called repeatedly without having to call optionSaveState again.
- * If you are restoring a state that was saved before the first call
- * to optionProcess(3AO), then you may change the contents of the
- * argc/argv parameters to optionProcess.
- */
-extern void optionRestore(tOptions*);
-
-
-/* From: save.c line 671
- *
- * optionSaveFile - saves the option state to a file
- *
- * Arguments:
- * pOpts program options descriptor
- *
- * This routine will save the state of option processing to a file. The name
- * of that file can be specified with the argument to the @code{--save-opts}
- * option, or by appending the @code{rcfile} attribute to the last
- * @code{homerc} attribute. If no @code{rcfile} attribute was specified, it
- * will default to @code{.@i{programname}rc}. If you wish to specify another
- * file, you should invoke the @code{SET_OPT_SAVE_OPTS( @i{filename} )} macro.
- *
- * The recommend usage is as follows:
- * @example
- * optionProcess(&progOptions, argc, argv);
- * if (i_want_a_non_standard_place_for_this)
- * SET_OPT_SAVE_OPTS("myfilename");
- * optionSaveFile(&progOptions);
- * @end example
- */
-extern void optionSaveFile(tOptions*);
-
-
-/* From: restore.c line 70
- *
- * optionSaveState - saves the option state to memory
- *
- * Arguments:
- * pOpts program options descriptor
- *
- * This routine will allocate enough memory to save the current option
- * processing state. If this routine has been called before, that memory
- * will be reused. You may only save one copy of the option state. This
- * routine may be called before optionProcess(3AO). If you do call it
- * before the first call to optionProcess, then you may also change the
- * contents of argc/argv after you call optionRestore(3AO)
- *
- * In fact, more strongly put: it is safest to only use this function
- * before having processed any options. In particular, the saving and
- * restoring of stacked string arguments and hierarchical values is
- * disabled. The values are not saved.
- */
-extern void optionSaveState(tOptions*);
-
-
-/* From: nested.c line 569
- *
- * optionUnloadNested - Deallocate the memory for a nested value
- *
- * Arguments:
- * pOptVal the hierarchical value
- *
- * A nested value needs to be deallocated. The pointer passed in should
- * have been gotten from a call to @code{configFileLoad()} (See
- * @pxref{libopts-configFileLoad}).
- */
-extern void optionUnloadNested(tOptionValue const *);
-
-
-/* From: version.c line 37
- *
- * optionVersion - return the compiled AutoOpts version number
- *
- * Returns: char const* - the version string in constant memory
- *
- * Returns the full version string compiled into the library.
- * The returned string cannot be modified.
- */
-extern char const* optionVersion(void);
-
-
-/* From: ../compat/pathfind.c line 32
- *
- * pathfind - fild a file in a list of directories
- *
- * Arguments:
- * path colon separated list of search directories
- * file the name of the file to look for
- * mode the mode bits that must be set to match
- *
- * Returns: char* - the path to the located file
- *
- * the pathfind function is available only if HAVE_PATHFIND is not defined
- *
- * pathfind looks for a a file with name "FILE" and "MODE" access
- * along colon delimited "PATH", and returns the full pathname as a
- * string, or NULL if not found. If "FILE" contains a slash, then
- * it is treated as a relative or absolute path and "PATH" is ignored.
- *
- * @strong{NOTE}: this function is compiled into @file{libopts} only if
- * it is not natively supplied.
- *
- * The "MODE" argument is a string of option letters chosen from the
- * list below:
- * @example
- * Letter Meaning
- * r readable
- * w writable
- * x executable
- * f normal file (NOT IMPLEMENTED)
- * b block special (NOT IMPLEMENTED)
- * c character special (NOT IMPLEMENTED)
- * d directory (NOT IMPLEMENTED)
- * p FIFO (pipe) (NOT IMPLEMENTED)
- * u set user ID bit (NOT IMPLEMENTED)
- * g set group ID bit (NOT IMPLEMENTED)
- * k sticky bit (NOT IMPLEMENTED)
- * s size nonzero (NOT IMPLEMENTED)
- * @end example
- */
-#ifndef HAVE_PATHFIND
-extern char* pathfind(char const*, char const*, char const*);
-#endif /* HAVE_PATHFIND */
-
-
-/* From: streqvcmp.c line 208
- *
- * strequate - map a list of characters to the same value
- *
- * Arguments:
- * ch_list characters to equivalence
- *
- * Each character in the input string get mapped to the first character
- * in the string.
- * This function name is mapped to option_strequate so as to not conflict
- * with the POSIX name space.
- */
-extern void strequate(char const*);
-
-
-/* From: streqvcmp.c line 118
- *
- * streqvcmp - compare two strings with an equivalence mapping
- *
- * Arguments:
- * str1 first string
- * str2 second string
- *
- * Returns: int - the difference between two differing characters
- *
- * Using a character mapping, two strings are compared for "equivalence".
- * Each input character is mapped to a comparison character and the
- * mapped-to characters are compared for the two NUL terminated input strings.
- * This function name is mapped to option_streqvcmp so as to not conflict
- * with the POSIX name space.
- */
-extern int streqvcmp(char const*, char const*);
-
-
-/* From: streqvcmp.c line 155
- *
- * streqvmap - Set the character mappings for the streqv functions
- *
- * Arguments:
- * From Input character
- * To Mapped-to character
- * ct compare length
- *
- * Set the character mapping. If the count (@code{ct}) is set to zero, then
- * the map is cleared by setting all entries in the map to their index
- * value. Otherwise, the "@code{From}" character is mapped to the "@code{To}"
- * character. If @code{ct} is greater than 1, then @code{From} and @code{To}
- * are incremented and the process repeated until @code{ct} entries have been
- * set. For example,
- * @example
- * streqvmap( 'a', 'A', 26 );
- * @end example
- * @noindent
- * will alter the mapping so that all English lower case letters
- * will map to upper case.
- *
- * This function name is mapped to option_streqvmap so as to not conflict
- * with the POSIX name space.
- */
-extern void streqvmap(char, char, int);
-
-
-/* From: streqvcmp.c line 77
- *
- * strneqvcmp - compare two strings with an equivalence mapping
- *
- * Arguments:
- * str1 first string
- * str2 second string
- * ct compare length
- *
- * Returns: int - the difference between two differing characters
- *
- * Using a character mapping, two strings are compared for "equivalence".
- * Each input character is mapped to a comparison character and the
- * mapped-to characters are compared for the two NUL terminated input strings.
- * The comparison is limited to @code{ct} bytes.
- * This function name is mapped to option_strneqvcmp so as to not conflict
- * with the POSIX name space.
- */
-extern int strneqvcmp(char const*, char const*, int);
-
-
-/* From: streqvcmp.c line 234
- *
- * strtransform - convert a string into its mapped-to value
- *
- * Arguments:
- * dest output string
- * src input string
- *
- * Each character in the input string is mapped and the mapped-to
- * character is put into the output.
- * This function name is mapped to option_strtransform so as to not conflict
- * with the POSIX name space.
- *
- * The source and destination may be the same.
- */
-extern void strtransform(char*, char const*);
-
-/* AutoOpts PRIVATE FUNCTIONS: */
-tOptProc optionStackArg, optionUnstackArg, optionBooleanVal, optionNumericVal;
-
-extern char* ao_string_cook(char*, int*);
-
-extern unsigned int ao_string_cook_escape_char(char const*, char*, unsigned int);
-
-extern void export_options_to_guile(tOptions*);
-
-extern void genshelloptUsage(tOptions*, int);
-
-extern void optionBooleanVal(tOptions*, tOptDesc*);
-
-extern uintptr_t optionEnumerationVal(tOptions*, tOptDesc*, char const * const *, unsigned int);
-
-extern void optionFileCheck(tOptions*, tOptDesc*, teOptFileType, tuFileMode);
-
-extern char const* optionKeywordName(tOptDesc*, unsigned int);
-
-extern void optionLoadOpt(tOptions*, tOptDesc*);
-
-extern ag_bool optionMakePath(char*, int, char const*, char const*);
-
-extern void optionNestedVal(tOptions*, tOptDesc*);
-
-extern void optionNumericVal(tOptions*, tOptDesc*);
-
-extern void optionPagedUsage(tOptions*, tOptDesc*);
-
-extern void optionParseShell(tOptions*);
-
-extern void optionPrintVersion(tOptions*, tOptDesc*);
-
-extern void optionPutShell(tOptions*);
-
-extern void optionResetOpt(tOptions*, tOptDesc*);
-
-extern void optionSetMembers(tOptions*, tOptDesc*, char const * const *, unsigned int);
-
-extern void optionShowRange(tOptions*, tOptDesc*, void *, int);
-
-extern void optionStackArg(tOptions*, tOptDesc*);
-
-extern void optionTimeVal(tOptions*, tOptDesc*);
-
-extern void optionUnstackArg(tOptions*, tOptDesc*);
-
-extern void optionUsage(tOptions*, int);
-
-extern void optionVersionStderr(tOptions*, tOptDesc*);
-
-extern void* text_mmap(char const*, int, int, tmap_info_t*);
-
-extern int text_munmap(tmap_info_t*);
-
-CPLUSPLUS_CLOSER
-#endif /* AUTOOPTS_OPTIONS_H_GUARD */
-/*
- * Local Variables:
- * c-file-style: "stroustrup"
- * indent-tabs-mode: nil
- * End:
- * options.h ends here */
+++ /dev/null
-/* -*- buffer-read-only: t -*- vi: set ro:
- *
- * DO NOT EDIT THIS FILE (usage-txt.h)
- *
- * It has been AutoGen-ed November 8, 2009 at 08:41:07 AM by AutoGen 5.9.10pre13
- * From the definitions usage-txt.def
- * and the template file usage-txt.tpl
- *
- * This file handles all the bookkeeping required for tracking all the little
- * tiny strings used by the AutoOpts library. There are 134
- * of them. This is not versioned because it is entirely internal to the
- * library and accessed by client code only in a very well-controlled way:
- * they may substitute translated strings using a procedure that steps through
- * all the string pointers.
- *
- * AutoOpts is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published
- * by the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * AutoOpts 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 Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-#ifndef AUTOOPTS_USAGE_TXT_H_GUARD
-#define AUTOOPTS_USAGE_TXT_H_GUARD 1
-
-#undef cch_t
-#define cch_t char const
-
-/*
- * One structure to hold all the pointers to all the stringlets.
- */
-typedef struct {
- int field_ct;
- char* utpz_GnuBoolArg;
- char* utpz_GnuKeyArg;
- char* utpz_GnuFileArg;
- char* utpz_GnuKeyLArg;
- char* utpz_GnuTimeArg;
- char* utpz_GnuNumArg;
- char* utpz_GnuStrArg;
- cch_t* apz_str[ 127 ];
-} usage_text_t;
-
-/*
- * Declare the global structure with all the pointers to translated
- * strings. This is then used by the usage generation procedure.
- */
-extern usage_text_t option_usage_text;
-
-#if defined(AUTOOPTS_INTERNAL) /* DEFINE ALL THE STRINGS = = = = = */
-/*
- * Provide a mapping from a short name to fields in this structure.
- */
-#define zAO_Bad (option_usage_text.apz_str[ 0])
-#define zAO_Big (option_usage_text.apz_str[ 1])
-#define zAO_Err (option_usage_text.apz_str[ 2])
-#define zAO_Sml (option_usage_text.apz_str[ 3])
-#define zAO_Ver (option_usage_text.apz_str[ 4])
-#define zAO_Woops (option_usage_text.apz_str[ 5])
-#define zAliasRange (option_usage_text.apz_str[ 6])
-#define zAll (option_usage_text.apz_str[ 7])
-#define zAlt (option_usage_text.apz_str[ 8])
-#define zAmbigKey (option_usage_text.apz_str[ 9])
-#define zAmbigOptStr (option_usage_text.apz_str[ 10])
-#define zArgsMust (option_usage_text.apz_str[ 11])
-#define zAtMost (option_usage_text.apz_str[ 12])
-#define zAuto (option_usage_text.apz_str[ 13])
-#define zBadPipe (option_usage_text.apz_str[ 14])
-#define zBadVerArg (option_usage_text.apz_str[ 15])
-#define zCantFmt (option_usage_text.apz_str[ 16])
-#define zCantSave (option_usage_text.apz_str[ 17])
-#define zDefaultOpt (option_usage_text.apz_str[ 18])
-#define zDis (option_usage_text.apz_str[ 19])
-#define zDisabledErr (option_usage_text.apz_str[ 20])
-#define zDisabledOpt (option_usage_text.apz_str[ 21])
-#define zDisabledWhy (option_usage_text.apz_str[ 22])
-#define zEnab (option_usage_text.apz_str[ 23])
-#define zEquiv (option_usage_text.apz_str[ 24])
-#define zErrOnly (option_usage_text.apz_str[ 25])
-#define zExamineFmt (option_usage_text.apz_str[ 26])
-#define zFiveSpaces (option_usage_text.apz_str[ 27])
-#define zFlagOkay (option_usage_text.apz_str[ 28])
-#define zFmtFmt (option_usage_text.apz_str[ 29])
-#define zForkFail (option_usage_text.apz_str[ 30])
-#define zFSErrOptLoad (option_usage_text.apz_str[ 31])
-#define zFSErrReadFile (option_usage_text.apz_str[ 32])
-#define zFSOptError (option_usage_text.apz_str[ 33])
-#define zFSOptErrMayExist (option_usage_text.apz_str[ 34])
-#define zFSOptErrMustExist (option_usage_text.apz_str[ 35])
-#define zFSOptErrNoExist (option_usage_text.apz_str[ 36])
-#define zFSOptErrOpen (option_usage_text.apz_str[ 37])
-#define zFSOptErrFopen (option_usage_text.apz_str[ 38])
-#define zFileCannotExist (option_usage_text.apz_str[ 39])
-#define zFileMustExist (option_usage_text.apz_str[ 40])
-#define zGenshell (option_usage_text.apz_str[ 41])
-#define zGnuBoolArg (option_usage_text.utpz_GnuBoolArg)
-#define zGnuBreak (option_usage_text.apz_str[ 42])
-#define zGnuKeyArg (option_usage_text.utpz_GnuKeyArg)
-#define zGnuFileArg (option_usage_text.utpz_GnuFileArg)
-#define zGnuKeyLArg (option_usage_text.utpz_GnuKeyLArg)
-#define zGnuTimeArg (option_usage_text.utpz_GnuTimeArg)
-#define zGnuNestArg (option_usage_text.apz_str[ 43])
-#define zGnuNumArg (option_usage_text.utpz_GnuNumArg)
-#define zGnuOptArg (option_usage_text.apz_str[ 44])
-#define zGnuOptFmt (option_usage_text.apz_str[ 45])
-#define zGnuStrArg (option_usage_text.utpz_GnuStrArg)
-#define zIllOptChr (option_usage_text.apz_str[ 46])
-#define zIllOptStr (option_usage_text.apz_str[ 47])
-#define zIllegal (option_usage_text.apz_str[ 48])
-#define zIntRange (option_usage_text.apz_str[ 49])
-#define zInvalOptDesc (option_usage_text.apz_str[ 50])
-#define zLowerBits (option_usage_text.apz_str[ 51])
-#define zMembers (option_usage_text.apz_str[ 52])
-#define zMisArg (option_usage_text.apz_str[ 53])
-#define zMultiEquiv (option_usage_text.apz_str[ 54])
-#define zMust (option_usage_text.apz_str[ 55])
-#define zNeedOne (option_usage_text.apz_str[ 56])
-#define zNoArg (option_usage_text.apz_str[ 57])
-#define zNoArgs (option_usage_text.apz_str[ 58])
-#define zNoCreat (option_usage_text.apz_str[ 59])
-#define zNoFlags (option_usage_text.apz_str[ 60])
-#define zNoKey (option_usage_text.apz_str[ 61])
-#define zNoLim (option_usage_text.apz_str[ 62])
-#define zNoPreset (option_usage_text.apz_str[ 63])
-#define zNoResetArg (option_usage_text.apz_str[ 64])
-#define zNoRq_NoShrtTtl (option_usage_text.apz_str[ 65])
-#define zNoRq_ShrtTtl (option_usage_text.apz_str[ 66])
-#define zNoStat (option_usage_text.apz_str[ 67])
-#define zNoState (option_usage_text.apz_str[ 68])
-#define zNone (option_usage_text.apz_str[ 69])
-#define zNotDef (option_usage_text.apz_str[ 70])
-#define zNotCmdOpt (option_usage_text.apz_str[ 71])
-#define zNotEnough (option_usage_text.apz_str[ 72])
-#define zNotFile (option_usage_text.apz_str[ 73])
-#define zNotNumber (option_usage_text.apz_str[ 74])
-#define zNrmOptFmt (option_usage_text.apz_str[ 75])
-#define zNumberOpt (option_usage_text.apz_str[ 76])
-#define zOneSpace (option_usage_text.apz_str[ 77])
-#define zOnlyOne (option_usage_text.apz_str[ 78])
-#define zOptsOnly (option_usage_text.apz_str[ 79])
-#define zPathFmt (option_usage_text.apz_str[ 80])
-#define zPlsSendBugs (option_usage_text.apz_str[ 81])
-#define zPreset (option_usage_text.apz_str[ 82])
-#define zPresetFile (option_usage_text.apz_str[ 83])
-#define zPresetIntro (option_usage_text.apz_str[ 84])
-#define zProg (option_usage_text.apz_str[ 85])
-#define zProhib (option_usage_text.apz_str[ 86])
-#define zReorder (option_usage_text.apz_str[ 87])
-#define zRange (option_usage_text.apz_str[ 88])
-#define zRangeAbove (option_usage_text.apz_str[ 89])
-#define zRangeLie (option_usage_text.apz_str[ 90])
-#define zRangeBadLie (option_usage_text.apz_str[ 91])
-#define zRangeOnly (option_usage_text.apz_str[ 92])
-#define zRangeOr (option_usage_text.apz_str[ 93])
-#define zRangeErr (option_usage_text.apz_str[ 94])
-#define zRangeExact (option_usage_text.apz_str[ 95])
-#define zRangeScaled (option_usage_text.apz_str[ 96])
-#define zRangeUpto (option_usage_text.apz_str[ 97])
-#define zResetNotConfig (option_usage_text.apz_str[ 98])
-#define zReqFmt (option_usage_text.apz_str[ 99])
-#define zReqOptFmt (option_usage_text.apz_str[100])
-#define zReqThese (option_usage_text.apz_str[101])
-#define zReq_NoShrtTtl (option_usage_text.apz_str[102])
-#define zReq_ShrtTtl (option_usage_text.apz_str[103])
-#define zSepChars (option_usage_text.apz_str[104])
-#define zSetMemberSettings (option_usage_text.apz_str[105])
-#define zShrtGnuOptFmt (option_usage_text.apz_str[106])
-#define zSixSpaces (option_usage_text.apz_str[107])
-#define zStdBoolArg (option_usage_text.apz_str[108])
-#define zStdBreak (option_usage_text.apz_str[109])
-#define zStdFileArg (option_usage_text.apz_str[110])
-#define zStdKeyArg (option_usage_text.apz_str[111])
-#define zStdKeyLArg (option_usage_text.apz_str[112])
-#define zStdTimeArg (option_usage_text.apz_str[113])
-#define zStdNestArg (option_usage_text.apz_str[114])
-#define zStdNoArg (option_usage_text.apz_str[115])
-#define zStdNumArg (option_usage_text.apz_str[116])
-#define zStdOptArg (option_usage_text.apz_str[117])
-#define zStdReqArg (option_usage_text.apz_str[118])
-#define zStdStrArg (option_usage_text.apz_str[119])
-#define zTabHyp (option_usage_text.apz_str[120])
-#define zTabHypAnd (option_usage_text.apz_str[121])
-#define zTabout (option_usage_text.apz_str[122])
-#define zThreeSpaces (option_usage_text.apz_str[123])
-#define zTwoSpaces (option_usage_text.apz_str[124])
-#define zUpTo (option_usage_text.apz_str[125])
-#define zValidKeys (option_usage_text.apz_str[126])
-
- /*
- * First, set up the strings. Some of these are writable. These are all in
- * English. This gets compiled into libopts and is distributed here so that
- * xgettext (or equivalents) can extract these strings for translation.
- */
-
- static char eng_zGnuBoolArg[] = "=T/F";
- static char eng_zGnuKeyArg[] = "=KWd";
- static char eng_zGnuFileArg[] = "=file";
- static char eng_zGnuKeyLArg[] = "=Mbr";
- static char eng_zGnuTimeArg[] = "=Tim";
- static char eng_zGnuNumArg[] = "=num";
- static char eng_zGnuStrArg[] = "=str";
-static char const usage_txt[4159] =
- "AutoOpts function called without option descriptor\n\0"
- "\tThis exceeds the compiled library version: \0"
- "Automated Options Processing Error!\n"
- "\t%s called AutoOpts function with structure version %d:%d:%d.\n\0"
- "\tThis is less than the minimum library version: \0"
- "Automated Options version %s\n"
- "\tcopyright (c) 1999-2009 by Bruce Korb - all rights reserved\n\0"
- "AutoOpts lib error: defaulted to option with optional arg\n\0"
- "(AutoOpts bug): Aliasing option is out of range.\0"
- "all\0"
- "\t\t\t\t- an alternate for %s\n\0"
- "%s error: the keyword `%s' is ambiguous for %s\n\0"
- "%s: ambiguous option -- %s\n\0"
- "%s: Command line arguments required\n\0"
- "%d %s%s options allowed\n\0"
- "version and help options:\0"
- "Error %d (%s) from the pipe(2) syscall\n\0"
- "ERROR: version option argument '%c' invalid. Use:\n"
- "\t'v' - version only\n"
- "\t'c' - version and copyright\n"
- "\t'n' - version and copyright notice\n\0"
- "ERROR: %s option conflicts with the %s option\n\0"
- "%s(optionSaveState): error: cannot allocate %d bytes\n\0"
- "\t\t\t\t- default option for unnamed options\n\0"
- "\t\t\t\t- disabled as --%s\n\0"
- "%s: The ``%s'' option has been disabled\0"
- " --- %-14s %s\n\0"
- "This option has been disabled\0"
- "\t\t\t\t- enabled by default\n\0"
- "-equivalence\0"
- "ERROR: only \0"
- " - examining environment variables named %s_*\n\0"
- " \0"
- "Options are specified by doubled hyphens and their name\n"
- "or by a single hyphen and the flag character.\n\0"
- "%%-%ds %%s\n\0"
- "fs error %d (%s) on fork - cannot obtain %s usage\n\0"
- "File error %d (%s) opening %s for loading options\n\0"
- "fs error %d (%s) reading file %s\n\0"
- "fs error %d (%s) on %s %s for option %s\n\0"
- "stat-ing for directory\0"
- "stat-ing for regular file\0"
- "stat-ing for non-existant file\0"
- "open-ing file\0"
- "fopen-ing file\0"
- "\t\t\t\t- file must not pre-exist\n\0"
- "\t\t\t\t- file must pre-exist\n\0"
- "\n"
- "= = = = = = = =\n\n"
- "This incarnation of genshell will produce\n"
- "a shell script to parse the options for %s:\n\n\0"
- "\n"
- "%s\n\n\0"
- "=Cplx\0"
- "[=arg]\0"
- "--%2$s%1$s\0"
- "%s: illegal option -- %c\n\0"
- "%s: illegal option -- %s\n\0"
- "illegal\0"
- " or an integer from %d through %d\n\0"
- "AutoOpts ERROR: invalid option descriptor for %s\n\0"
- " or an integer mask with any of the lower %d bits set\n\0"
- "\t\t\t\t- is a set membership option\n\0"
- "%s: option `%s' requires an argument\n\0"
- "Equivalenced option '%s' was equivalenced to both\n"
- "\t'%s' and '%s'\0"
- "\t\t\t\t- must appear between %d and %d times\n\0"
- "ERROR: The %s option is required\n\0"
- "%s: option `%s' cannot have an argument\n\0"
- "%s: Command line arguments not allowed\n\0"
- "error %d (%s) creating %s\n\0"
- "Options are specified by single or double hyphens and their name.\n\0"
- "%s error: `%s' does not match any %s keywords\n\0"
- "\t\t\t\t- may appear multiple times\n\0"
- "\t\t\t\t- may not be preset\n\0"
- "The 'reset-option' option requires an argument\n\0"
- " Arg Option-Name Description\n\0"
- " Flg Arg Option-Name Description\n\0"
- "error %d (%s) stat-ing %s\n\0"
- "%s(optionRestore): error: no saved option state\n\0"
- "none\0"
- "'%s' not defined\n\0"
- "'%s' is not a command line option\n\0"
- "ERROR: The %s option must appear %d times\n\0"
- "error: cannot load options from non-regular file %s\n\0"
- "%s error: `%s' is not a recognizable number\n\0"
- " %3s %s\0"
- "The '-#<number>' option may omit the hash char\n\0"
- " \0"
- "one %s%s option allowed\n\0"
- "All arguments are named options.\n\0"
- " - reading file %s\0"
- "\n"
- "please send bug reports to: %s\n\0"
- "\t\t\t\t- may NOT appear - preset only\n\0"
- "# preset/initialization file\n"
- "# %s#\n\0"
- "\n"
- "The following option preset mechanisms are supported:\n\0"
- "program\0"
- "prohibits these options:\n\0"
- "Operands and options may be intermixed. They will be reordered.\n\0"
- "%s%ld to %ld\0"
- "%sgreater than or equal to %ld\0"
- "%sIt must lie in one of the ranges:\n\0"
- "%sThis option must lie in one of the ranges:\n\0"
- "%sit must be: \0"
- ", or\n\0"
- "%s error: %s option value ``%s'' is out of range.\n\0"
- "%s%ld exactly\0"
- "%sis scalable with a suffix: k/K/m/M/g/G/t/T\n\0"
- "%sless than or equal to %ld\0"
- "The --reset-option has not been configured.\n\0"
- "ERROR: %s option requires the %s option\n\0"
- " %3s %-14s %s\0"
- "requires these options:\n\0"
- " Arg Option-Name Req? Description\n\0"
- " Flg Arg Option-Name Req? Description\n\0"
- "-_^\0"
- "or you may use a numeric representation. Preceding these with a '!' will\n"
- "clear the bits, specifying 'none' will clear all bits, and 'all' will set them\n"
- "all. Multiple entries may be passed as an option argument list.\n\0"
- "%s\0"
- " \0"
- "T/F\0"
- "\n"
- "%s\n\n"
- "%s\0"
- "Fil\0"
- "KWd\0"
- "Mbr\0"
- "Tim\0"
- "Cpx\0"
- "no \0"
- "Num\0"
- "opt\0"
- "YES\0"
- "Str\0"
- "\t\t\t\t- \0"
- "\t\t\t\t-- and \0"
- "\t\t\t\t%s\n\0"
- " \0"
- " \0"
- "\t\t\t\t- may appear up to %d times\n\0"
- "The valid \"%s\" option keywords are:\n\0";
-
-
- /*
- * Now, define (and initialize) the structure that contains
- * the pointers to all these strings.
- * Aren't you glad you don't maintain this by hand?
- */
- usage_text_t option_usage_text = {
- 134,
- eng_zGnuBoolArg, eng_zGnuKeyArg, eng_zGnuFileArg, eng_zGnuKeyLArg,
- eng_zGnuTimeArg, eng_zGnuNumArg, eng_zGnuStrArg,
- {
- usage_txt + 0, usage_txt + 52, usage_txt + 98, usage_txt + 197,
- usage_txt + 247, usage_txt + 338, usage_txt + 397, usage_txt + 447,
- usage_txt + 451, usage_txt + 478, usage_txt + 527, usage_txt + 555,
- usage_txt + 592, usage_txt + 617, usage_txt + 643, usage_txt + 683,
- usage_txt + 820, usage_txt + 868, usage_txt + 922, usage_txt + 964,
- usage_txt + 988, usage_txt +1028, usage_txt +1043, usage_txt +1073,
- usage_txt +1099, usage_txt +1112, usage_txt +1126, usage_txt +1173,
- usage_txt +1179, usage_txt +1282, usage_txt +1294, usage_txt +1345,
- usage_txt +1396, usage_txt +1430, usage_txt +1471, usage_txt +1494,
- usage_txt +1520, usage_txt +1551, usage_txt +1565, usage_txt +1580,
- usage_txt +1611, usage_txt +1638, usage_txt +1744, usage_txt +1750,
- usage_txt +1756, usage_txt +1763, usage_txt +1774, usage_txt +1800,
- usage_txt +1826, usage_txt +1834, usage_txt +1870, usage_txt +1921,
- usage_txt +1977, usage_txt +2011, usage_txt +2049, usage_txt +2114,
- usage_txt +2157, usage_txt +2192, usage_txt +2233, usage_txt +2273,
- usage_txt +2300, usage_txt +2367, usage_txt +2415, usage_txt +2448,
- usage_txt +2473, usage_txt +2521, usage_txt +2556, usage_txt +2594,
- usage_txt +2621, usage_txt +2670, usage_txt +2675, usage_txt +2693,
- usage_txt +2728, usage_txt +2772, usage_txt +2826, usage_txt +2872,
- usage_txt +2880, usage_txt +2928, usage_txt +2930, usage_txt +2955,
- usage_txt +2989, usage_txt +3008, usage_txt +3042, usage_txt +3078,
- usage_txt +3116, usage_txt +3172, usage_txt +3180, usage_txt +3206,
- usage_txt +3272, usage_txt +3285, usage_txt +3316, usage_txt +3353,
- usage_txt +3399, usage_txt +3415, usage_txt +3421, usage_txt +3473,
- usage_txt +3487, usage_txt +3533, usage_txt +3561, usage_txt +3606,
- usage_txt +3648, usage_txt +3662, usage_txt +3687, usage_txt +3727,
- usage_txt +3770, usage_txt +3774, usage_txt +3993, usage_txt +3996,
- usage_txt +4003, usage_txt +4007, usage_txt +4015, usage_txt +4019,
- usage_txt +4023, usage_txt +4027, usage_txt +4031, usage_txt +4035,
- usage_txt +4039, usage_txt +4043, usage_txt +4047, usage_txt +4051,
- usage_txt +4055, usage_txt +4062, usage_txt +4074, usage_txt +4082,
- usage_txt +4086, usage_txt +4089, usage_txt +4122
- }
- };
-
-#endif /* DO_TRANSLATIONS */
-#endif /* AUTOOPTS_USAGE_TXT_H_GUARD */
+++ /dev/null
-
-/*
- * $Id: 329b43154b88d78564d8f960a00a83ec7d8baee0 $
- * Time-stamp: "2008-08-03 13:06:02 bkorb"
- *
- * Automated Options Paged Usage module.
- *
- * This routine will run run-on options through a pager so the
- * user may examine, print or edit them at their leisure.
- *
- * This file is part of AutoOpts, a companion to AutoGen.
- * AutoOpts is free software.
- * AutoOpts is copyright (c) 1992-2009 by Bruce Korb - all rights reserved
- *
- * AutoOpts is available under any one of two licenses. The license
- * in use must be one of these two and the choice is under the control
- * of the user of the license.
- *
- * The GNU Lesser General Public License, version 3 or later
- * See the files "COPYING.lgplv3" and "COPYING.gplv3"
- *
- * The Modified Berkeley Software Distribution License
- * See the file "COPYING.mbsd"
- *
- * These files have the following md5sums:
- *
- * 43b91e8ca915626ed3818ffb1b71248b pkg/libopts/COPYING.gplv3
- * 06a1a2e4760c90ea5e1dad8dfaac4d39 pkg/libopts/COPYING.lgplv3
- * 66a5cedaf62c4b2637025f049f9b826f pkg/libopts/COPYING.mbsd
- */
-
-/*=export_func optionBooleanVal
- * private:
- *
- * what: Decipher a boolean value
- * arg: + tOptions* + pOpts + program options descriptor +
- * arg: + tOptDesc* + pOptDesc + the descriptor for this arg +
- *
- * doc:
- * Decipher a true or false value for a boolean valued option argument.
- * The value is true, unless it starts with 'n' or 'f' or "#f" or
- * it is an empty string or it is a number that evaluates to zero.
-=*/
-void
-optionBooleanVal( tOptions* pOpts, tOptDesc* pOD )
-{
- char* pz;
- ag_bool res = AG_TRUE;
-
- if ((pOD->fOptState & OPTST_RESET) != 0)
- return;
-
- if (pOD->optArg.argString == NULL) {
- pOD->optArg.argBool = AG_FALSE;
- return;
- }
-
- switch (*(pOD->optArg.argString)) {
- case '0':
- {
- long val = strtol( pOD->optArg.argString, &pz, 0 );
- if ((val != 0) || (*pz != NUL))
- break;
- /* FALLTHROUGH */
- }
- case 'N':
- case 'n':
- case 'F':
- case 'f':
- case NUL:
- res = AG_FALSE;
- break;
- case '#':
- if (pOD->optArg.argString[1] != 'f')
- break;
- res = AG_FALSE;
- }
-
- if (pOD->fOptState & OPTST_ALLOC_ARG) {
- AGFREE(pOD->optArg.argString);
- pOD->fOptState &= ~OPTST_ALLOC_ARG;
- }
- pOD->optArg.argBool = res;
-}
-/*
- * Local Variables:
- * mode: C
- * c-file-style: "stroustrup"
- * indent-tabs-mode: nil
- * End:
- * end of autoopts/boolean.c */
+++ /dev/null
-/* -*- Mode: C -*- */
-
-/* compat.h --- fake the preprocessor into handlng portability
- *
- * Time-stamp: "2009-10-18 11:14:14 bkorb"
- *
- * $Id: 27c1eb45f171295ab6176280aeca742cfdbe9fed $
- *
- * compat.h is free software.
- * This file is part of AutoGen.
- *
- * AutoGen copyright (c) 1992-2009 by Bruce Korb - all rights reserved
- *
- * AutoGen 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.
- *
- * AutoGen 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 <http://www.gnu.org/licenses/>.
- *
- * As a special exception, Bruce Korb gives permission for additional
- * uses of the text contained in the release of compat.h.
- *
- * The exception is that, if you link the compat.h library with other
- * files to produce an executable, this does not by itself cause the
- * resulting executable to be covered by the GNU General Public License.
- * Your use of that executable is in no way restricted on account of
- * linking the compat.h library code into it.
- *
- * This exception does not however invalidate any other reasons why
- * the executable file might be covered by the GNU General Public License.
- *
- * This exception applies only to the code released by Bruce Korb under
- * the name compat.h. If you copy code from other sources under the
- * General Public License into a copy of compat.h, as the General Public
- * License permits, the exception does not apply to the code that you add
- * in this way. To avoid misleading anyone as to the status of such
- * modified files, you must delete this exception notice from them.
- *
- * If you write modifications of your own for compat.h, it is your choice
- * whether to permit this exception to apply to your modifications.
- * If you do not wish that, delete this exception notice.
- */
-#ifndef COMPAT_H_GUARD
-#define COMPAT_H_GUARD 1
-
-#if defined(HAVE_CONFIG_H)
-# include <config.h>
-
-#elif defined(_WIN32) && !defined(__CYGWIN__)
-# include "windows-config.h"
-
-#else
-# error "compat.h" requires "config.h"
- choke me.
-#endif
-
-
-#ifndef HAVE_STRSIGNAL
- char * strsignal( int signo );
-#endif
-
-#define _GNU_SOURCE 1 /* for strsignal in GNU's libc */
-#define __USE_GNU 1 /* exact same thing as above */
-#define __EXTENSIONS__ 1 /* and another way to call for it */
-
-/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
- *
- * SYSTEM HEADERS:
- */
-#include <sys/types.h>
-#ifdef HAVE_SYS_MMAN_H
-# include <sys/mman.h>
-#endif
-#include <sys/param.h>
-#if HAVE_SYS_PROCSET_H
-# include <sys/procset.h>
-#endif
-#include <sys/stat.h>
-#include <sys/wait.h>
-
-#if defined( HAVE_SOLARIS_SYSINFO )
-# include <sys/systeminfo.h>
-#elif defined( HAVE_UNAME_SYSCALL )
-# include <sys/utsname.h>
-#endif
-
-#ifdef DAEMON_ENABLED
-# if HAVE_SYS_STROPTS_H
-# include <sys/stropts.h>
-# endif
-
-# if HAVE_SYS_SOCKET_H
-# include <sys/socket.h>
-# endif
-
-# if ! defined(HAVE_SYS_POLL_H) && ! defined(HAVE_SYS_SELECT_H)
-# error This system cannot support daemon processing
- Choke Me.
-# endif
-
-# if HAVE_SYS_POLL_H
-# include <sys/poll.h>
-# endif
-
-# if HAVE_SYS_SELECT_H
-# include <sys/select.h>
-# endif
-
-# if HAVE_NETINET_IN_H
-# include <netinet/in.h>
-# endif
-
-# if HAVE_SYS_UN_H
-# include <sys/un.h>
-# endif
-#endif
-
-/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
- *
- * USER HEADERS:
- */
-#include <stdio.h>
-#include <assert.h>
-#include <ctype.h>
-
-/*
- * Directory opening stuff:
- */
-# if defined (_POSIX_SOURCE)
-/* Posix does not require that the d_ino field be present, and some
- systems do not provide it. */
-# define REAL_DIR_ENTRY(dp) 1
-# else /* !_POSIX_SOURCE */
-# define REAL_DIR_ENTRY(dp) (dp->d_ino != 0)
-# endif /* !_POSIX_SOURCE */
-
-# if defined (HAVE_DIRENT_H)
-# include <dirent.h>
-# define D_NAMLEN(dirent) strlen((dirent)->d_name)
-# else /* !HAVE_DIRENT_H */
-# define dirent direct
-# define D_NAMLEN(dirent) (dirent)->d_namlen
-# if defined (HAVE_SYS_NDIR_H)
-# include <sys/ndir.h>
-# endif /* HAVE_SYS_NDIR_H */
-# if defined (HAVE_SYS_DIR_H)
-# include <sys/dir.h>
-# endif /* HAVE_SYS_DIR_H */
-# if defined (HAVE_NDIR_H)
-# include <ndir.h>
-# endif /* HAVE_NDIR_H */
-# endif /* !HAVE_DIRENT_H */
-
-#include <errno.h>
-#ifdef HAVE_FCNTL_H
-# include <fcntl.h>
-#endif
-#ifndef O_NONBLOCK
-# define O_NONBLOCK FNDELAY
-#endif
-
-#if defined(HAVE_LIBGEN) && defined(HAVE_LIBGEN_H)
-# include <libgen.h>
-#endif
-
-#if defined(HAVE_LIMITS_H) /* this is also in options.h */
-# include <limits.h>
-#elif defined(HAVE_SYS_LIMITS_H)
-# include <sys/limits.h>
-#endif /* HAVE_LIMITS/SYS_LIMITS_H */
-
-#include <memory.h>
-#include <setjmp.h>
-#include <signal.h>
-
-#if defined( HAVE_STDINT_H )
-# include <stdint.h>
-#elif defined( HAVE_INTTYPES_H )
-# include <inttypes.h>
-#endif
-
-#include <stdlib.h>
-#include <string.h>
-
-#include <time.h>
-
-#ifdef HAVE_UTIME_H
-# include <utime.h>
-#endif
-
-#ifdef HAVE_UNISTD_H
-# include <unistd.h>
-#endif
-
-/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
- *
- * FIXUPS and CONVIENCE STUFF:
- */
-#ifdef __cplusplus
-# define EXTERN extern "C"
-#else
-# define EXTERN extern
-#endif
-
-/* some systems #def errno! and others do not declare it!! */
-#ifndef errno
- extern int errno;
-#endif
-
-/* Some machines forget this! */
-
-# ifndef EXIT_FAILURE
-# define EXIT_SUCCESS 0
-# define EXIT_FAILURE 1
-# endif
-
-#ifndef NUL
-# define NUL '\0'
-#endif
-
-#ifndef NULL
-# define NULL 0
-#endif
-
-#if !defined (MAXPATHLEN) && defined (HAVE_SYS_PARAM_H)
-# include <sys/param.h>
-#endif /* !MAXPATHLEN && HAVE_SYS_PARAM_H */
-
-#if !defined (MAXPATHLEN) && defined (PATH_MAX)
-# define MAXPATHLEN PATH_MAX
-#endif /* !MAXPATHLEN && PATH_MAX */
-
-#if !defined (MAXPATHLEN) && defined(_MAX_PATH)
-# define PATH_MAX _MAX_PATH
-# define MAXPATHLEN _MAX_PATH
-#endif
-
-#if !defined (MAXPATHLEN)
-# define MAXPATHLEN ((size_t)4096)
-#endif /* MAXPATHLEN */
-
-#define AG_PATH_MAX ((size_t)MAXPATHLEN)
-
-#ifndef LONG_MAX
-# define LONG_MAX ~(1L << (8*sizeof(long) -1))
-# define INT_MAX ~(1 << (8*sizeof(int) -1))
-#endif
-
-#ifndef ULONG_MAX
-# define ULONG_MAX ~(OUL)
-# define UINT_MAX ~(OU)
-#endif
-
-#ifndef SHORT_MAX
-# define SHORT_MAX ~(1 << (8*sizeof(short) - 1))
-#else
-# define USHORT_MAX ~(OUS)
-#endif
-
-#ifndef HAVE_INT8_T
- typedef signed char int8_t;
-# define HAVE_INT8_T 1
-#endif
-#ifndef HAVE_UINT8_T
- typedef unsigned char uint8_t;
-# define HAVE_UINT8_T 1
-#endif
-#ifndef HAVE_INT16_T
- typedef signed short int16_t;
-# define HAVE_INT16_T 1
-#endif
-#ifndef HAVE_UINT16_T
- typedef unsigned short uint16_t;
-# define HAVE_UINT16_T 1
-#endif
-
-#ifndef HAVE_INT32_T
-# if SIZEOF_INT == 4
- typedef signed int int32_t;
-# elif SIZEOF_LONG == 4
- typedef signed long int32_t;
-# endif
-# define HAVE_INT32_T 1
-#endif
-
-#ifndef HAVE_UINT32_T
-# if SIZEOF_INT == 4
- typedef unsigned int uint32_t;
-# elif SIZEOF_LONG == 4
- typedef unsigned long uint32_t;
-# else
-# error Cannot create a uint32_t type.
- Choke Me.
-# endif
-# define HAVE_UINT32_T 1
-#endif
-
-#ifndef HAVE_INTPTR_T
-# if SIZEOF_CHARP == SIZEOF_LONG
- typedef signed long intptr_t;
-# else
- typedef signed int intptr_t;
-# endif
-# define HAVE_INTPTR_T 1
-#endif
-
-#ifndef HAVE_UINTPTR_T
-# if SIZEOF_CHARP == SIZEOF_LONG
- typedef unsigned long intptr_t;
-# else
- typedef unsigned int intptr_t;
-# endif
-# define HAVE_INTPTR_T 1
-#endif
-
-#ifndef HAVE_UINT_T
- typedef unsigned int uint_t;
-# define HAVE_UINT_T 1
-#endif
-
-#ifndef HAVE_SIZE_T
- typedef unsigned int size_t;
-# define HAVE_SIZE_T 1
-#endif
-#ifndef HAVE_WINT_T
- typedef unsigned int wint_t;
-# define HAVE_WINT_T 1
-#endif
-#ifndef HAVE_PID_T
- typedef signed int pid_t;
-# define HAVE_PID_T 1
-#endif
-
-/* redefine these for BSD style string libraries */
-#ifndef HAVE_STRCHR
-# define strchr index
-# define strrchr rindex
-#endif
-
-#ifdef USE_FOPEN_BINARY
-# ifndef FOPEN_BINARY_FLAG
-# define FOPEN_BINARY_FLAG "b"
-# endif
-# ifndef FOPEN_TEXT_FLAG
-# define FOPEN_TEXT_FLAG "t"
-# endif
-#else
-# ifndef FOPEN_BINARY_FLAG
-# define FOPEN_BINARY_FLAG
-# endif
-# ifndef FOPEN_TEXT_FLAG
-# define FOPEN_TEXT_FLAG
-# endif
-#endif
-
-#ifndef STR
-# define _STR(s) #s
-# define STR(s) _STR(s)
-#endif
-
-/* ##### Pointer sized word ##### */
-
-/* FIXME: the MAX stuff in here is broken! */
-#if SIZEOF_CHARP > SIZEOF_INT
- typedef long t_word;
- #define WORD_MAX LONG_MAX
- #define WORD_MIN LONG_MIN
-#else /* SIZEOF_CHARP <= SIZEOF_INT */
- typedef int t_word;
- #define WORD_MAX INT_MAX
- #define WORD_MIN INT_MIN
-#endif
-
-#endif /* COMPAT_H_GUARD */
-
-/*
- * Local Variables:
- * mode: C
- * c-file-style: "stroustrup"
- * indent-tabs-mode: nil
- * End:
- * end of compat/compat.h */
+++ /dev/null
-/* -*- Mode: C -*- */
-
-/* pathfind.c --- find a FILE MODE along PATH */
-
-/*
- * Author: Gary V Vaughan <gvaughan@oranda.demon.co.uk>
- * Time-stamp: "2006-09-23 19:46:16 bkorb"
- * by: bkorb
- *
- * $Id: 8ce7ddfe2378f0b75c91c0ab348a6ad81634fb01 $
- */
-
-/* Code: */
-
-#include "compat.h"
-#ifndef HAVE_PATHFIND
-#if defined(__windows__) && !defined(__CYGWIN__)
-char*
-pathfind( char const* path,
- char const* fileName,
- char const* mode )
-{
- return NULL;
-}
-#else
-
-static char* make_absolute( char const *string, char const *dot_path );
-static char* canonicalize_pathname( char *path );
-static char* extract_colon_unit( char* dir, char const *string, int *p_index );
-
-
-/*=export_func pathfind
- *
- * what: fild a file in a list of directories
- *
- * ifndef: HAVE_PATHFIND
- *
- * arg: + char const* + path + colon separated list of search directories +
- * arg: + char const* + file + the name of the file to look for +
- * arg: + char const* + mode + the mode bits that must be set to match +
- *
- * ret_type: char*
- * ret_desc: the path to the located file
- *
- * doc:
- *
- * pathfind looks for a a file with name "FILE" and "MODE" access
- * along colon delimited "PATH", and returns the full pathname as a
- * string, or NULL if not found. If "FILE" contains a slash, then
- * it is treated as a relative or absolute path and "PATH" is ignored.
- *
- * @strong{NOTE}: this function is compiled into @file{libopts} only if
- * it is not natively supplied.
- *
- * The "MODE" argument is a string of option letters chosen from the
- * list below:
- * @example
- * Letter Meaning
- * r readable
- * w writable
- * x executable
- * f normal file (NOT IMPLEMENTED)
- * b block special (NOT IMPLEMENTED)
- * c character special (NOT IMPLEMENTED)
- * d directory (NOT IMPLEMENTED)
- * p FIFO (pipe) (NOT IMPLEMENTED)
- * u set user ID bit (NOT IMPLEMENTED)
- * g set group ID bit (NOT IMPLEMENTED)
- * k sticky bit (NOT IMPLEMENTED)
- * s size nonzero (NOT IMPLEMENTED)
- * @end example
- *
- * example:
- * To find the "ls" command using the "PATH" environment variable:
- * @example
- * #include <stdlib.h>
- * char* pz_ls = pathfind( getenv("PATH"), "ls", "rx" );
- * <<do whatever with pz_ls>>
- * free( pz_ls );
- * @end example
- * The path is allocated with @code{malloc(3C)}, so you must @code{free(3C)}
- * the result. Also, do not use unimplemented file modes. :-)
- *
- * err: returns NULL if the file is not found.
-=*/
-char*
-pathfind( char const* path,
- char const* fileName,
- char const* mode )
-{
- int p_index = 0;
- int mode_bits = 0;
- char* pathName = NULL;
- char zPath[ AG_PATH_MAX + 1 ];
-
- if (strchr( mode, 'r' )) mode_bits |= R_OK;
- if (strchr( mode, 'w' )) mode_bits |= W_OK;
- if (strchr( mode, 'x' )) mode_bits |= X_OK;
-
- /*
- * FOR each non-null entry in the colon-separated path, DO ...
- */
- for (;;) {
- DIR* dirP;
- char* colon_unit = extract_colon_unit( zPath, path, &p_index );
-
- /*
- * IF no more entries, THEN quit
- */
- if (colon_unit == NULL)
- break;
-
- dirP = opendir( colon_unit );
-
- /*
- * IF the directory is inaccessable, THEN next directory
- */
- if (dirP == NULL)
- continue;
-
- /*
- * FOR every entry in the given directory, ...
- */
- for (;;) {
- struct dirent *entP = readdir( dirP );
-
- if (entP == (struct dirent*)NULL)
- break;
-
- /*
- * IF the file name matches the one we are looking for, ...
- */
- if (strcmp( entP->d_name, fileName ) == 0) {
- char* pzFullName = make_absolute( fileName, colon_unit);
-
- /*
- * Make sure we can access it in the way we want
- */
- if (access( pzFullName, mode_bits ) >= 0) {
- /*
- * We can, so normalize the name and return it below
- */
- pathName = canonicalize_pathname( pzFullName );
- }
-
- free( (void*)pzFullName );
- break;
- }
- }
-
- closedir( dirP );
-
- if (pathName != NULL)
- break;
- }
-
- return pathName;
-}
-
-/*
- * Turn STRING (a pathname) into an absolute pathname, assuming that
- * DOT_PATH contains the symbolic location of `.'. This always returns
- * a new string, even if STRING was an absolute pathname to begin with.
- */
-static char*
-make_absolute( char const *string, char const *dot_path )
-{
- char *result;
- int result_len;
-
- if (!dot_path || *string == '/') {
- result = strdup( string );
- } else {
- if (dot_path && dot_path[0]) {
- result = malloc( 2 + strlen( dot_path ) + strlen( string ) );
- strcpy( result, dot_path );
- result_len = strlen( result );
- if (result[result_len - 1] != '/') {
- result[result_len++] = '/';
- result[result_len] = '\0';
- }
- } else {
- result = malloc( 3 + strlen( string ) );
- result[0] = '.'; result[1] = '/'; result[2] = '\0';
- result_len = 2;
- }
-
- strcpy( result + result_len, string );
- }
-
- return result;
-}
-
-/*
- * Canonicalize PATH, and return a new path. The new path differs from
- * PATH in that:
- *
- * Multiple `/'s are collapsed to a single `/'.
- * Leading `./'s are removed.
- * Trailing `/.'s are removed.
- * Trailing `/'s are removed.
- * Non-leading `../'s and trailing `..'s are handled by removing
- * portions of the path.
- */
-static char*
-canonicalize_pathname( char *path )
-{
- int i, start;
- char stub_char, *result;
-
- /* The result cannot be larger than the input PATH. */
- result = strdup( path );
-
- stub_char = (*path == '/') ? '/' : '.';
-
- /* Walk along RESULT looking for things to compact. */
- i = 0;
- while (result[i]) {
- while (result[i] != '\0' && result[i] != '/')
- i++;
-
- start = i++;
-
- /* If we didn't find any slashes, then there is nothing left to
- * do.
- */
- if (!result[start])
- break;
-
- /* Handle multiple `/'s in a row. */
- while (result[i] == '/')
- i++;
-
-#if !defined (apollo)
- if ((start + 1) != i)
-#else
- if ((start + 1) != i && (start != 0 || i != 2))
-#endif /* apollo */
- {
- strcpy( result + start + 1, result + i );
- i = start + 1;
- }
-
- /* Handle backquoted `/'. */
- if (start > 0 && result[start - 1] == '\\')
- continue;
-
- /* Check for trailing `/', and `.' by itself. */
- if ((start && !result[i])
- || (result[i] == '.' && !result[i+1])) {
- result[--i] = '\0';
- break;
- }
-
- /* Check for `../', `./' or trailing `.' by itself. */
- if (result[i] == '.') {
- /* Handle `./'. */
- if (result[i + 1] == '/') {
- strcpy( result + i, result + i + 1 );
- i = (start < 0) ? 0 : start;
- continue;
- }
-
- /* Handle `../' or trailing `..' by itself. */
- if (result[i + 1] == '.' &&
- (result[i + 2] == '/' || !result[i + 2])) {
- while (--start > -1 && result[start] != '/')
- ;
- strcpy( result + start + 1, result + i + 2 );
- i = (start < 0) ? 0 : start;
- continue;
- }
- }
- }
-
- if (!*result) {
- *result = stub_char;
- result[1] = '\0';
- }
-
- return result;
-}
-
-/*
- * Given a string containing units of information separated by colons,
- * return the next one pointed to by (P_INDEX), or NULL if there are no
- * more. Advance (P_INDEX) to the character after the colon.
- */
-static char*
-extract_colon_unit( char* pzDir, char const *string, int *p_index )
-{
- char* pzDest = pzDir;
- int ix = *p_index;
-
- if (string == NULL)
- return NULL;
-
- if ((unsigned)ix >= strlen( string ))
- return NULL;
-
- {
- char const* pzSrc = string + ix;
-
- while (*pzSrc == ':') pzSrc++;
-
- for (;;) {
- char ch = (*(pzDest++) = *(pzSrc++));
- switch (ch) {
- case ':':
- pzDest[-1] = NUL;
- case NUL:
- goto copy_done;
- }
-
- if ((pzDest - pzDir) >= AG_PATH_MAX)
- break;
- } copy_done:;
-
- ix = pzSrc - string;
- }
-
- if (*pzDir == NUL)
- return NULL;
-
- *p_index = ix;
- return pzDir;
-}
-#endif /* __windows__ / __CYGWIN__ */
-#endif /* HAVE_PATHFIND */
-
-/*
- * Local Variables:
- * mode: C
- * c-file-style: "stroustrup"
- * indent-tabs-mode: nil
- * End:
- * end of compat/pathfind.c */
+++ /dev/null
-
-#ifndef HAVE_VPRINTF
-#include "choke-me: no vprintf and no snprintf"
-#endif
-
-#if defined(HAVE_STDARG_H)
-# include <stdarg.h>
-# ifndef VA_START
-# define VA_START(a, f) va_start(a, f)
-# define VA_END(a) va_end(a)
-# endif /* VA_START */
-# define SNV_USING_STDARG_H
-
-#elif defined(HAVE_VARARGS_H)
-# include <varargs.h>
-# ifndef VA_START
-# define VA_START(a, f) va_start(a)
-# define VA_END(a) va_end(a)
-# endif /* VA_START */
-# undef SNV_USING_STDARG_H
-
-#else
-# include "must-have-stdarg-or-varargs"
-#endif
-
-static int
-snprintf(char *str, size_t n, char const *fmt, ...)
-{
- va_list ap;
- int rval;
-
-#ifdef VSPRINTF_CHARSTAR
- char *rp;
- VA_START(ap, fmt);
- rp = vsprintf(str, fmt, ap);
- VA_END(ap);
- rval = strlen(rp);
-
-#else
- VA_START(ap, fmt);
- rval = vsprintf(str, fmt, ap);
- VA_END(ap);
-#endif
-
- if (rval > n) {
- fprintf(stderr, "snprintf buffer overrun %d > %d\n", rval, (int)n);
- abort();
- }
- return rval;
-}
-
-static int
-vsnprintf( char *str, size_t n, char const *fmt, va_list ap )
-{
-#ifdef VSPRINTF_CHARSTAR
- return (strlen(vsprintf(str, fmt, ap)));
-#else
- return (vsprintf(str, fmt, ap));
-#endif
-}
+++ /dev/null
-/*
- SYNOPSIS
- #include <string.h>
-
- char *strchr(char const *s, int c);
-
- char *strrchr(char const *s, int c);
-
- DESCRIPTION
- The strchr() function returns a pointer to the first occurrence of the
- character c in the string s.
-
- The strrchr() function returns a pointer to the last occurrence of the
- character c in the string s.
-
- Here "character" means "byte" - these functions do not work with wide
- or multi-byte characters.
-
- RETURN VALUE
- The strchr() and strrchr() functions return a pointer to the matched
- character or NULL if the character is not found.
-
- CONFORMING TO
- SVID 3, POSIX, BSD 4.3, ISO 9899
-*/
-
-char*
-strchr( char const *s, int c)
-{
- do {
- if ((unsigned)*s == (unsigned)c)
- return s;
-
- } while (*(++s) != NUL);
-
- return NULL;
-}
-
-char*
-strrchr( char const *s, int c)
-{
- char const *e = s + strlen(s);
-
- for (;;) {
- if (--e < s)
- break;
-
- if ((unsigned)*e == (unsigned)c)
- return e;
- }
- return NULL;
-}
-
-/*
- * Local Variables:
- * mode: C
- * c-file-style: "stroustrup"
- * indent-tabs-mode: nil
- * End:
- * end of compat/strsignal.c */
+++ /dev/null
-/*
- * Platforms without strdup ?!?!?!
- */
-
-static char *
-strdup( char const *s )
-{
- char *cp;
-
- if (s == NULL)
- return NULL;
-
- cp = (char *) AGALOC((unsigned) (strlen(s)+1), "strdup");
-
- if (cp != NULL)
- (void) strcpy(cp, s);
-
- return cp;
-}
+++ /dev/null
-
-/*
- * Time-stamp: "2009-07-22 18:53:59 bkorb"
- * by: bkorb
- *
- * This file is part of AutoGen.
- *
- * AutoGen copyright (c) 1992-2009 by Bruce Korb - all rights reserved
- *
- * AutoGen 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.
- *
- * AutoGen 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 <http://www.gnu.org/licenses/>.
- */
-#ifndef WINDOWS_CONFIG_HACKERY
-#define WINDOWS_CONFIG_HACKERY 1
-
-/*
- * The definitions below have been stolen from NTP's config.h for Windows.
- * However, they may be kept here in order to keep libopts independent from
- * the NTP project.
- */
-#ifndef __windows__
-# define __windows__ 4
-#endif
-
-/*
- * Miscellaneous functions that Microsoft maps
- * to other names
- *
- * #define inline __inline
- * #define vsnprintf _vsnprintf
- */
-#define snprintf _snprintf
-/*
- * #define stricmp _stricmp
- * #define strcasecmp _stricmp
- * #define isascii __isascii
- * #define finite _finite
- * #define random rand
- * #define srandom srand
- */
-
-#define SIZEOF_INT 4
-#define SIZEOF_CHARP 4
-#define SIZEOF_LONG 4
-#define SIZEOF_SHORT 2
-
-typedef unsigned long uintptr_t;
-
-/*
- * # define HAVE_NET_IF_H
- * # define QSORT_USES_VOID_P
- * # define HAVE_SETVBUF
- * # define HAVE_VSPRINTF
- * # define HAVE_SNPRINTF
- * # define HAVE_VSNPRINTF
- * # define HAVE_PROTOTYPES /* from ntpq.mak * /
- * # define HAVE_MEMMOVE
- * # define HAVE_TERMIOS_H
- * # define HAVE_ERRNO_H
- * # define HAVE_STDARG_H
- * # define HAVE_NO_NICE
- * # define HAVE_MKTIME
- * # define TIME_WITH_SYS_TIME
- * # define HAVE_IO_COMPLETION_PORT
- * # define ISC_PLATFORM_NEEDNTOP
- * # define ISC_PLATFORM_NEEDPTON
- * # define NEED_S_CHAR_TYPEDEF
- * # define USE_PROTOTYPES /* for ntp_types.h * /
- *
- * #define ULONG_CONST(a) a ## UL
- */
-
-#define HAVE_LIMITS_H 1
-#define HAVE_STRDUP 1
-#define HAVE_STRCHR 1
-#define HAVE_FCNTL_H 1
-
-/*
- * VS.NET's version of wspiapi.h has a bug in it
- * where it assigns a value to a variable inside
- * an if statement. It should be comparing them.
- * We prevent inclusion since we are not using this
- * code so we don't have to see the warning messages
- */
-#ifndef _WSPIAPI_H_
-#define _WSPIAPI_H_
-#endif
-
-/* Prevent inclusion of winsock.h in windows.h */
-#ifndef _WINSOCKAPI_
-#define _WINSOCKAPI_
-#endif
-
-#ifndef __RPCASYNC_H__
-#define __RPCASYNC_H__
-#endif
-
-/* Include Windows headers */
-#include <windows.h>
-#include <winsock2.h>
-#include <limits.h>
-
-/*
- * Compatibility declarations for Windows, assuming SYS_WINNT
- * has been defined.
- */
-#define strdup _strdup
-#define stat _stat /* struct stat from <sys/stat.h> */
-#define unlink _unlink
-#define fchmod( _x, _y );
-#define ssize_t SSIZE_T
-
-#include <io.h>
-#define open _open
-#define close _close
-#define read _read
-#define write _write
-#define lseek _lseek
-#define pipe _pipe
-#define dup2 _dup2
-
-#define O_RDWR _O_RDWR
-#define O_RDONLY _O_RDONLY
-#define O_EXCL _O_EXCL
-
-#ifndef S_ISREG
-# define S_IFREG _S_IFREG
-# define S_ISREG(mode) (((mode) & S_IFREG) == S_IFREG)
-#endif
-
-#ifndef S_ISDIR
-# define S_IFDIR _S_IFDIR
-# define S_ISDIR(mode) (((mode) & S_IFDIR) == S_IFDIR)
-#endif
-
-#endif /* WINDOWS_CONFIG_HACKERY */
+++ /dev/null
-/*
- * $Id: f1650b45a91ec95af830ff76041cc4f0048e60f0 $
- * Time-stamp: "2009-01-18 10:21:58 bkorb"
- *
- * configuration/rc/ini file handling.
- *
- * This file is part of AutoOpts, a companion to AutoGen.
- * AutoOpts is free software.
- * AutoOpts is copyright (c) 1992-2009 by Bruce Korb - all rights reserved
- *
- * AutoOpts is available under any one of two licenses. The license
- * in use must be one of these two and the choice is under the control
- * of the user of the license.
- *
- * The GNU Lesser General Public License, version 3 or later
- * See the files "COPYING.lgplv3" and "COPYING.gplv3"
- *
- * The Modified Berkeley Software Distribution License
- * See the file "COPYING.mbsd"
- *
- * These files have the following md5sums:
- *
- * 43b91e8ca915626ed3818ffb1b71248b pkg/libopts/COPYING.gplv3
- * 06a1a2e4760c90ea5e1dad8dfaac4d39 pkg/libopts/COPYING.lgplv3
- * 66a5cedaf62c4b2637025f049f9b826f pkg/libopts/COPYING.mbsd
- */
-
-/* = = = START-STATIC-FORWARD = = = */
-/* static forward declarations maintained by mk-fwd */
-static void
-filePreset(
- tOptions* pOpts,
- char const* pzFileName,
- int direction );
-
-static char*
-handleComment( char* pzText );
-
-static char*
-handleConfig(
- tOptions* pOpts,
- tOptState* pOS,
- char* pzText,
- int direction );
-
-static char*
-handleDirective(
- tOptions* pOpts,
- char* pzText );
-
-static char*
-handleProgramSection(
- tOptions* pOpts,
- char* pzText );
-
-static char*
-handleStructure(
- tOptions* pOpts,
- tOptState* pOS,
- char* pzText,
- int direction );
-
-static char*
-parseKeyWordType(
- tOptions* pOpts,
- char* pzText,
- tOptionValue* pType );
-
-static char*
-parseSetMemType(
- tOptions* pOpts,
- char* pzText,
- tOptionValue* pType );
-
-static char*
-parseValueType(
- char* pzText,
- tOptionValue* pType );
-
-static char*
-skipUnknown( char* pzText );
-/* = = = END-STATIC-FORWARD = = = */
-
-
-/*=export_func configFileLoad
- *
- * what: parse a configuration file
- * arg: + char const* + pzFile + the file to load +
- *
- * ret_type: const tOptionValue*
- * ret_desc: An allocated, compound value structure
- *
- * doc:
- * This routine will load a named configuration file and parse the
- * text as a hierarchically valued option. The option descriptor
- * created from an option definition file is not used via this interface.
- * The returned value is "named" with the input file name and is of
- * type "@code{OPARG_TYPE_HIERARCHY}". It may be used in calls to
- * @code{optionGetValue()}, @code{optionNextValue()} and
- * @code{optionUnloadNested()}.
- *
- * err:
- * If the file cannot be loaded or processed, @code{NULL} is returned and
- * @var{errno} is set. It may be set by a call to either @code{open(2)}
- * @code{mmap(2)} or other file system calls, or it may be:
- * @itemize @bullet
- * @item
- * @code{ENOENT} - the file was empty.
- * @item
- * @code{EINVAL} - the file contents are invalid -- not properly formed.
- * @item
- * @code{ENOMEM} - not enough memory to allocate the needed structures.
- * @end itemize
-=*/
-const tOptionValue*
-configFileLoad( char const* pzFile )
-{
- tmap_info_t cfgfile;
- tOptionValue* pRes = NULL;
- tOptionLoadMode save_mode = option_load_mode;
-
- char* pzText =
- text_mmap( pzFile, PROT_READ, MAP_PRIVATE, &cfgfile );
-
- if (TEXT_MMAP_FAILED_ADDR(pzText))
- return NULL; /* errno is set */
-
- option_load_mode = OPTION_LOAD_COOKED;
- pRes = optionLoadNested(pzText, pzFile, strlen(pzFile));
-
- if (pRes == NULL) {
- int err = errno;
- text_munmap( &cfgfile );
- errno = err;
- } else
- text_munmap( &cfgfile );
-
- option_load_mode = save_mode;
- return pRes;
-}
-
-
-/*=export_func optionFindValue
- *
- * what: find a hierarcicaly valued option instance
- * arg: + const tOptDesc* + pOptDesc + an option with a nested arg type +
- * arg: + char const* + name + name of value to find +
- * arg: + char const* + value + the matching value +
- *
- * ret_type: const tOptionValue*
- * ret_desc: a compound value structure
- *
- * doc:
- * This routine will find an entry in a nested value option or configurable.
- * It will search through the list and return a matching entry.
- *
- * err:
- * The returned result is NULL and errno is set:
- * @itemize @bullet
- * @item
- * @code{EINVAL} - the @code{pOptValue} does not point to a valid
- * hierarchical option value.
- * @item
- * @code{ENOENT} - no entry matched the given name.
- * @end itemize
-=*/
-const tOptionValue*
-optionFindValue( const tOptDesc* pOptDesc,
- char const* pzName, char const* pzVal )
-{
- const tOptionValue* pRes = NULL;
-
- if ( (pOptDesc == NULL)
- || (OPTST_GET_ARGTYPE(pOptDesc->fOptState) != OPARG_TYPE_HIERARCHY)) {
- errno = EINVAL;
- }
-
- else if (pOptDesc->optCookie == NULL) {
- errno = ENOENT;
- }
-
- else do {
- tArgList* pAL = pOptDesc->optCookie;
- int ct = pAL->useCt;
- void** ppOV = (void**)(pAL->apzArgs);
-
- if (ct == 0) {
- errno = ENOENT;
- break;
- }
-
- if (pzName == NULL) {
- pRes = (tOptionValue*)*ppOV;
- break;
- }
-
- while (--ct >= 0) {
- const tOptionValue* pOV = *(ppOV++);
- const tOptionValue* pRV = optionGetValue( pOV, pzName );
-
- if (pRV == NULL)
- continue;
-
- if (pzVal == NULL) {
- pRes = pOV;
- break;
- }
- }
- if (pRes == NULL)
- errno = ENOENT;
- } while (0);
-
- return pRes;
-}
-
-
-/*=export_func optionFindNextValue
- *
- * what: find a hierarcicaly valued option instance
- * arg: + const tOptDesc* + pOptDesc + an option with a nested arg type +
- * arg: + const tOptionValue* + pPrevVal + the last entry +
- * arg: + char const* + name + name of value to find +
- * arg: + char const* + value + the matching value +
- *
- * ret_type: const tOptionValue*
- * ret_desc: a compound value structure
- *
- * doc:
- * This routine will find the next entry in a nested value option or
- * configurable. It will search through the list and return the next entry
- * that matches the criteria.
- *
- * err:
- * The returned result is NULL and errno is set:
- * @itemize @bullet
- * @item
- * @code{EINVAL} - the @code{pOptValue} does not point to a valid
- * hierarchical option value.
- * @item
- * @code{ENOENT} - no entry matched the given name.
- * @end itemize
-=*/
-const tOptionValue*
-optionFindNextValue( const tOptDesc* pOptDesc, const tOptionValue* pPrevVal,
- char const* pzName, char const* pzVal )
-{
- int foundOldVal = 0;
- tOptionValue* pRes = NULL;
-
- if ( (pOptDesc == NULL)
- || (OPTST_GET_ARGTYPE(pOptDesc->fOptState) != OPARG_TYPE_HIERARCHY)) {
- errno = EINVAL;
- }
-
- else if (pOptDesc->optCookie == NULL) {
- errno = ENOENT;
- }
-
- else do {
- tArgList* pAL = pOptDesc->optCookie;
- int ct = pAL->useCt;
- void** ppOV = (void**)pAL->apzArgs;
-
- if (ct == 0) {
- errno = ENOENT;
- break;
- }
-
- while (--ct >= 0) {
- tOptionValue* pOV = *(ppOV++);
- if (foundOldVal) {
- pRes = pOV;
- break;
- }
- if (pOV == pPrevVal)
- foundOldVal = 1;
- }
- if (pRes == NULL)
- errno = ENOENT;
- } while (0);
-
- return pRes;
-}
-
-
-/*=export_func optionGetValue
- *
- * what: get a specific value from a hierarcical list
- * arg: + const tOptionValue* + pOptValue + a hierarchcal value +
- * arg: + char const* + valueName + name of value to get +
- *
- * ret_type: const tOptionValue*
- * ret_desc: a compound value structure
- *
- * doc:
- * This routine will find an entry in a nested value option or configurable.
- * If "valueName" is NULL, then the first entry is returned. Otherwise,
- * the first entry with a name that exactly matches the argument will be
- * returned.
- *
- * err:
- * The returned result is NULL and errno is set:
- * @itemize @bullet
- * @item
- * @code{EINVAL} - the @code{pOptValue} does not point to a valid
- * hierarchical option value.
- * @item
- * @code{ENOENT} - no entry matched the given name.
- * @end itemize
-=*/
-const tOptionValue*
-optionGetValue( const tOptionValue* pOld, char const* pzValName )
-{
- tArgList* pAL;
- tOptionValue* pRes = NULL;
-
- if ((pOld == NULL) || (pOld->valType != OPARG_TYPE_HIERARCHY)) {
- errno = EINVAL;
- return NULL;
- }
- pAL = pOld->v.nestVal;
-
- if (pAL->useCt > 0) {
- int ct = pAL->useCt;
- void** papOV = (void**)(pAL->apzArgs);
-
- if (pzValName == NULL) {
- pRes = (tOptionValue*)*papOV;
- }
-
- else do {
- tOptionValue* pOV = *(papOV++);
- if (strcmp( pOV->pzName, pzValName ) == 0) {
- pRes = pOV;
- break;
- }
- } while (--ct > 0);
- }
- if (pRes == NULL)
- errno = ENOENT;
- return pRes;
-}
-
-
-/*=export_func optionNextValue
- *
- * what: get the next value from a hierarchical list
- * arg: + const tOptionValue* + pOptValue + a hierarchcal list value +
- * arg: + const tOptionValue* + pOldValue + a value from this list +
- *
- * ret_type: const tOptionValue*
- * ret_desc: a compound value structure
- *
- * doc:
- * This routine will return the next entry after the entry passed in. At the
- * end of the list, NULL will be returned. If the entry is not found on the
- * list, NULL will be returned and "@var{errno}" will be set to EINVAL.
- * The "@var{pOldValue}" must have been gotten from a prior call to this
- * routine or to "@code{opitonGetValue()}".
- *
- * err:
- * The returned result is NULL and errno is set:
- * @itemize @bullet
- * @item
- * @code{EINVAL} - the @code{pOptValue} does not point to a valid
- * hierarchical option value or @code{pOldValue} does not point to a
- * member of that option value.
- * @item
- * @code{ENOENT} - the supplied @code{pOldValue} pointed to the last entry.
- * @end itemize
-=*/
-tOptionValue const *
-optionNextValue(tOptionValue const * pOVList,tOptionValue const * pOldOV )
-{
- tArgList* pAL;
- tOptionValue* pRes = NULL;
- int err = EINVAL;
-
- if ((pOVList == NULL) || (pOVList->valType != OPARG_TYPE_HIERARCHY)) {
- errno = EINVAL;
- return NULL;
- }
- pAL = pOVList->v.nestVal;
- {
- int ct = pAL->useCt;
- void** papNV = (void**)(pAL->apzArgs);
-
- while (ct-- > 0) {
- tOptionValue* pNV = *(papNV++);
- if (pNV == pOldOV) {
- if (ct == 0) {
- err = ENOENT;
-
- } else {
- err = 0;
- pRes = (tOptionValue*)*papNV;
- }
- break;
- }
- }
- }
- if (err != 0)
- errno = err;
- return pRes;
-}
-
-
-/* filePreset
- *
- * Load a file containing presetting information (a configuration file).
- */
-static void
-filePreset(
- tOptions* pOpts,
- char const* pzFileName,
- int direction )
-{
- tmap_info_t cfgfile;
- tOptState optst = OPTSTATE_INITIALIZER(PRESET);
- char* pzFileText =
- text_mmap( pzFileName, PROT_READ|PROT_WRITE, MAP_PRIVATE, &cfgfile );
-
- if (TEXT_MMAP_FAILED_ADDR(pzFileText))
- return;
-
- if (direction == DIRECTION_CALLED) {
- optst.flags = OPTST_DEFINED;
- direction = DIRECTION_PROCESS;
- }
-
- /*
- * IF this is called via "optionProcess", then we are presetting.
- * This is the default and the PRESETTING bit will be set.
- * If this is called via "optionFileLoad", then the bit is not set
- * and we consider stuff set herein to be "set" by the client program.
- */
- if ((pOpts->fOptSet & OPTPROC_PRESETTING) == 0)
- optst.flags = OPTST_SET;
-
- do {
- while (IS_WHITESPACE_CHAR(*pzFileText)) pzFileText++;
-
- if (IS_VAR_FIRST_CHAR(*pzFileText)) {
- pzFileText = handleConfig(pOpts, &optst, pzFileText, direction);
-
- } else switch (*pzFileText) {
- case '<':
- if (IS_VAR_FIRST_CHAR(pzFileText[1]))
- pzFileText =
- handleStructure(pOpts, &optst, pzFileText, direction);
-
- else switch (pzFileText[1]) {
- case '?':
- pzFileText = handleDirective( pOpts, pzFileText );
- break;
-
- case '!':
- pzFileText = handleComment( pzFileText );
- break;
-
- case '/':
- pzFileText = strchr( pzFileText+2, '>' );
- if (pzFileText++ != NULL)
- break;
-
- default:
- goto all_done;
- }
- break;
-
- case '[':
- pzFileText = handleProgramSection( pOpts, pzFileText );
- break;
-
- case '#':
- pzFileText = strchr( pzFileText+1, '\n' );
- break;
-
- default:
- goto all_done; /* invalid format */
- }
- } while (pzFileText != NULL);
-
- all_done:
- text_munmap( &cfgfile );
-}
-
-
-/* handleComment
- *
- * "pzText" points to a "<!" sequence.
- * Theoretically, we should ensure that it begins with "<!--",
- * but actually I don't care that much. It ends with "-->".
- */
-static char*
-handleComment( char* pzText )
-{
- char* pz = strstr( pzText, "-->" );
- if (pz != NULL)
- pz += 3;
- return pz;
-}
-
-
-/* handleConfig
- *
- * "pzText" points to the start of some value name.
- * The end of the entry is the end of the line that is not preceded by
- * a backslash escape character. The string value is always processed
- * in "cooked" mode.
- */
-static char*
-handleConfig(
- tOptions* pOpts,
- tOptState* pOS,
- char* pzText,
- int direction )
-{
- char* pzName = pzText++;
- char* pzEnd = strchr( pzText, '\n' );
-
- if (pzEnd == NULL)
- return pzText + strlen(pzText);
-
- while (IS_VALUE_NAME_CHAR(*pzText)) pzText++;
- while (IS_WHITESPACE_CHAR(*pzText)) pzText++;
- if (pzText > pzEnd) {
- name_only:
- *pzEnd++ = NUL;
- loadOptionLine( pOpts, pOS, pzName, direction, OPTION_LOAD_UNCOOKED );
- return pzEnd;
- }
-
- /*
- * Either the first character after the name is a ':' or '=',
- * or else we must have skipped over white space. Anything else
- * is an invalid format and we give up parsing the text.
- */
- if ((*pzText == '=') || (*pzText == ':')) {
- while (IS_WHITESPACE_CHAR(*++pzText)) ;
- if (pzText > pzEnd)
- goto name_only;
- } else if (! IS_WHITESPACE_CHAR(pzText[-1]))
- return NULL;
-
- /*
- * IF the value is continued, remove the backslash escape and push "pzEnd"
- * on to a newline *not* preceded by a backslash.
- */
- if (pzEnd[-1] == '\\') {
- char* pcD = pzEnd-1;
- char* pcS = pzEnd;
-
- for (;;) {
- char ch = *(pcS++);
- switch (ch) {
- case NUL:
- pcS = NULL;
-
- case '\n':
- *pcD = NUL;
- pzEnd = pcS;
- goto copy_done;
-
- case '\\':
- if (*pcS == '\n') {
- ch = *(pcS++);
- }
- /* FALLTHROUGH */
- default:
- *(pcD++) = ch;
- }
- } copy_done:;
-
- } else {
- /*
- * The newline was not preceded by a backslash. NUL it out
- */
- *(pzEnd++) = NUL;
- }
-
- /*
- * "pzName" points to what looks like text for one option/configurable.
- * It is NUL terminated. Process it.
- */
- loadOptionLine( pOpts, pOS, pzName, direction, OPTION_LOAD_UNCOOKED );
-
- return pzEnd;
-}
-
-
-/* handleDirective
- *
- * "pzText" points to a "<?" sequence.
- * For the moment, we only handle "<?program" directives.
- */
-static char*
-handleDirective(
- tOptions* pOpts,
- char* pzText )
-{
- char ztitle[32] = "<?";
- size_t title_len = strlen( zProg );
- size_t name_len;
-
- if ( (strncmp( pzText+2, zProg, title_len ) != 0)
- || (! IS_WHITESPACE_CHAR(pzText[title_len+2])) ) {
- pzText = strchr( pzText+2, '>' );
- if (pzText != NULL)
- pzText++;
- return pzText;
- }
-
- name_len = strlen( pOpts->pzProgName );
- strcpy( ztitle+2, zProg );
- title_len += 2;
-
- do {
- pzText += title_len;
-
- if (IS_WHITESPACE_CHAR(*pzText)) {
- while (IS_WHITESPACE_CHAR(*++pzText)) ;
- if ( (strneqvcmp( pzText, pOpts->pzProgName, (int)name_len) == 0)
- && (pzText[name_len] == '>')) {
- pzText += name_len + 1;
- break;
- }
- }
-
- pzText = strstr( pzText, ztitle );
- } while (pzText != NULL);
-
- return pzText;
-}
-
-
-/* handleProgramSection
- *
- * "pzText" points to a '[' character.
- * The "traditional" [PROG_NAME] segmentation of the config file.
- * Do not ever mix with the "<?program prog-name>" variation.
- */
-static char*
-handleProgramSection(
- tOptions* pOpts,
- char* pzText )
-{
- size_t len = strlen( pOpts->pzPROGNAME );
- if ( (strncmp( pzText+1, pOpts->pzPROGNAME, len ) == 0)
- && (pzText[len+1] == ']'))
- return strchr( pzText + len + 2, '\n' );
-
- if (len > 16)
- return NULL;
-
- {
- char z[24];
- sprintf( z, "[%s]", pOpts->pzPROGNAME );
- pzText = strstr( pzText, z );
- }
-
- if (pzText != NULL)
- pzText = strchr( pzText, '\n' );
- return pzText;
-}
-
-
-/* handleStructure
- *
- * "pzText" points to a '<' character, followed by an alpha.
- * The end of the entry is either the "/>" following the name, or else a
- * "</name>" string.
- */
-static char*
-handleStructure(
- tOptions* pOpts,
- tOptState* pOS,
- char* pzText,
- int direction )
-{
- tOptionLoadMode mode = option_load_mode;
- tOptionValue valu;
-
- char* pzName = ++pzText;
- char* pzData;
- char* pcNulPoint;
-
- while (IS_VALUE_NAME_CHAR(*pzText)) pzText++;
- pcNulPoint = pzText;
- valu.valType = OPARG_TYPE_STRING;
-
- switch (*pzText) {
- case ' ':
- case '\t':
- pzText = parseAttributes( pOpts, pzText, &mode, &valu );
- if (*pzText == '>')
- break;
- if (*pzText != '/')
- return NULL;
- /* FALLTHROUGH */
-
- case '/':
- if (pzText[1] != '>')
- return NULL;
- *pzText = NUL;
- pzText += 2;
- loadOptionLine( pOpts, pOS, pzName, direction, mode );
- return pzText;
-
- case '>':
- break;
-
- default:
- pzText = strchr( pzText, '>');
- if (pzText != NULL)
- pzText++;
- return pzText;
- }
-
- /*
- * If we are here, we have a value. "pzText" points to a closing angle
- * bracket. Separate the name from the value for a moment.
- */
- *pcNulPoint = NUL;
- pzData = ++pzText;
-
- /*
- * Find the end of the option text and NUL terminate it
- */
- {
- char z[64], *pz = z;
- size_t len = strlen(pzName) + 4;
- if (len > sizeof(z))
- pz = AGALOC(len, "scan name");
-
- sprintf( pz, "</%s>", pzName );
- *pzText = ' ';
- pzText = strstr( pzText, pz );
- if (pz != z) AGFREE(pz);
-
- if (pzText == NULL)
- return pzText;
-
- *pzText = NUL;
-
- pzText += len-1;
- }
-
- /*
- * Rejoin the name and value for parsing by "loadOptionLine()".
- * Erase any attributes parsed by "parseAttributes()".
- */
- memset(pcNulPoint, ' ', pzData - pcNulPoint);
-
- /*
- * If we are getting a "string" value, the process the XML-ish
- * %XX hex characters.
- */
- if (valu.valType == OPARG_TYPE_STRING) {
- char * pzSrc = pzData;
- char * pzDst = pzData;
- char bf[4];
- bf[2] = NUL;
-
- for (;;) {
- int ch = ((int)*(pzSrc++)) & 0xFF;
- switch (ch) {
- case NUL: goto string_fixup_done;
-
- case '%':
- bf[0] = *(pzSrc++);
- bf[1] = *(pzSrc++);
- if ((bf[0] == NUL) || (bf[1] == NUL))
- goto string_fixup_done;
- ch = strtoul(bf, NULL, 16);
- /* FALLTHROUGH */
-
- default:
- *(pzDst++) = ch;
- }
- } string_fixup_done:;
- *pzDst = NUL;
- }
-
- /*
- * "pzName" points to what looks like text for one option/configurable.
- * It is NUL terminated. Process it.
- */
- loadOptionLine( pOpts, pOS, pzName, direction, mode );
-
- return pzText;
-}
-
-
-/* internalFileLoad
- *
- * Load a configuration file. This may be invoked either from
- * scanning the "homerc" list, or from a specific file request.
- * (see "optionFileLoad()", the implementation for --load-opts)
- */
-LOCAL void
-internalFileLoad( tOptions* pOpts )
-{
- uint32_t svfl;
- int idx;
- int inc;
- char zFileName[ AG_PATH_MAX+1 ];
-
- if (pOpts->papzHomeList == NULL)
- return;
-
- svfl = pOpts->fOptSet;
- inc = DIRECTION_PRESET;
-
- /*
- * Never stop on errors in config files.
- */
- pOpts->fOptSet &= ~OPTPROC_ERRSTOP;
-
- /*
- * Find the last RC entry (highest priority entry)
- */
- for (idx = 0; pOpts->papzHomeList[ idx+1 ] != NULL; ++idx) ;
-
- /*
- * For every path in the home list, ... *TWICE* We start at the last
- * (highest priority) entry, work our way down to the lowest priority,
- * handling the immediate options.
- * Then we go back up, doing the normal options.
- */
- for (;;) {
- struct stat StatBuf;
- cch_t* pzPath;
-
- /*
- * IF we've reached the bottom end, change direction
- */
- if (idx < 0) {
- inc = DIRECTION_PROCESS;
- idx = 0;
- }
-
- pzPath = pOpts->papzHomeList[ idx ];
-
- /*
- * IF we've reached the top end, bail out
- */
- if (pzPath == NULL)
- break;
-
- idx += inc;
-
- if (! optionMakePath( zFileName, (int)sizeof(zFileName),
- pzPath, pOpts->pzProgPath ))
- continue;
-
- /*
- * IF the file name we constructed is a directory,
- * THEN append the Resource Configuration file name
- * ELSE we must have the complete file name
- */
- if (stat( zFileName, &StatBuf ) != 0)
- continue; /* bogus name - skip the home list entry */
-
- if (S_ISDIR( StatBuf.st_mode )) {
- size_t len = strlen( zFileName );
- char* pz;
-
- if (len + 1 + strlen( pOpts->pzRcName ) >= sizeof( zFileName ))
- continue;
-
- pz = zFileName + len;
- if (pz[-1] != DIRCH)
- *(pz++) = DIRCH;
- strcpy( pz, pOpts->pzRcName );
- }
-
- filePreset( pOpts, zFileName, inc );
-
- /*
- * IF we are now to skip config files AND we are presetting,
- * THEN change direction. We must go the other way.
- */
- {
- tOptDesc * pOD = pOpts->pOptDesc + pOpts->specOptIdx.save_opts+1;
- if (DISABLED_OPT(pOD) && PRESETTING(inc)) {
- idx -= inc; /* go back and reprocess current file */
- inc = DIRECTION_PROCESS;
- }
- }
- } /* twice for every path in the home list, ... */
-
- pOpts->fOptSet = svfl;
-}
-
-
-/*=export_func optionFileLoad
- *
- * what: Load the locatable config files, in order
- *
- * arg: + tOptions* + pOpts + program options descriptor +
- * arg: + char const* + pzProg + program name +
- *
- * ret_type: int
- * ret_desc: 0 -> SUCCESS, -1 -> FAILURE
- *
- * doc:
- *
- * This function looks in all the specified directories for a configuration
- * file ("rc" file or "ini" file) and processes any found twice. The first
- * time through, they are processed in reverse order (last file first). At
- * that time, only "immediate action" configurables are processed. For
- * example, if the last named file specifies not processing any more
- * configuration files, then no more configuration files will be processed.
- * Such an option in the @strong{first} named directory will have no effect.
- *
- * Once the immediate action configurables have been handled, then the
- * directories are handled in normal, forward order. In that way, later
- * config files can override the settings of earlier config files.
- *
- * See the AutoOpts documentation for a thorough discussion of the
- * config file format.
- *
- * Configuration files not found or not decipherable are simply ignored.
- *
- * err: Returns the value, "-1" if the program options descriptor
- * is out of date or indecipherable. Otherwise, the value "0" will
- * always be returned.
-=*/
-int
-optionFileLoad( tOptions* pOpts, char const* pzProgram )
-{
- if (! SUCCESSFUL( validateOptionsStruct( pOpts, pzProgram )))
- return -1;
-
- pOpts->pzProgName = pzProgram;
- internalFileLoad( pOpts );
- return 0;
-}
-
-
-/*=export_func optionLoadOpt
- * private:
- *
- * what: Load an option rc/ini file
- * arg: + tOptions* + pOpts + program options descriptor +
- * arg: + tOptDesc* + pOptDesc + the descriptor for this arg +
- *
- * doc:
- * Processes the options found in the file named with
- * pOptDesc->optArg.argString.
-=*/
-void
-optionLoadOpt( tOptions* pOpts, tOptDesc* pOptDesc )
-{
- struct stat sb;
-
- /*
- * IF the option is not being disabled, THEN load the file. There must
- * be a file. (If it is being disabled, then the disablement processing
- * already took place. It must be done to suppress preloading of ini/rc
- * files.)
- */
- if ( DISABLED_OPT(pOptDesc)
- || ((pOptDesc->fOptState & OPTST_RESET) != 0))
- return;
-
- if (stat( pOptDesc->optArg.argString, &sb ) != 0) {
- if ((pOpts->fOptSet & OPTPROC_ERRSTOP) == 0)
- return;
-
- fprintf( stderr, zFSErrOptLoad, errno, strerror( errno ),
- pOptDesc->optArg.argString );
- exit(EX_NOINPUT);
- /* NOT REACHED */
- }
-
- if (! S_ISREG( sb.st_mode )) {
- if ((pOpts->fOptSet & OPTPROC_ERRSTOP) == 0)
- return;
-
- fprintf( stderr, zNotFile, pOptDesc->optArg.argString );
- exit(EX_NOINPUT);
- /* NOT REACHED */
- }
-
- filePreset(pOpts, pOptDesc->optArg.argString, DIRECTION_CALLED);
-}
-
-
-/* parseAttributes
- *
- * Parse the various attributes of an XML-styled config file entry
- */
-LOCAL char*
-parseAttributes(
- tOptions* pOpts,
- char* pzText,
- tOptionLoadMode* pMode,
- tOptionValue* pType )
-{
- size_t len;
-
- do {
- if (! IS_WHITESPACE_CHAR(*pzText))
- switch (*pzText) {
- case '/': pType->valType = OPARG_TYPE_NONE;
- case '>': return pzText;
-
- default:
- case NUL: return NULL;
- }
-
- while (IS_WHITESPACE_CHAR(*++pzText)) ;
- len = 0;
- while (IS_LOWER_CASE_CHAR(pzText[len])) len++;
-
- switch (find_xat_attribute_id(pzText, len)) {
- case XAT_KWD_TYPE:
- pzText = parseValueType( pzText+len, pType );
- break;
-
- case XAT_KWD_WORDS:
- pzText = parseKeyWordType( pOpts, pzText+len, pType );
- break;
-
- case XAT_KWD_MEMBERS:
- pzText = parseSetMemType( pOpts, pzText+len, pType );
- break;
-
- case XAT_KWD_COOKED:
- pzText += len;
- if (! IS_END_XML_TOKEN_CHAR(*pzText))
- goto invalid_kwd;
-
- *pMode = OPTION_LOAD_COOKED;
- break;
-
- case XAT_KWD_UNCOOKED:
- pzText += len;
- if (! IS_END_XML_TOKEN_CHAR(*pzText))
- goto invalid_kwd;
-
- *pMode = OPTION_LOAD_UNCOOKED;
- break;
-
- case XAT_KWD_KEEP:
- pzText += len;
- if (! IS_END_XML_TOKEN_CHAR(*pzText))
- goto invalid_kwd;
-
- *pMode = OPTION_LOAD_KEEP;
- break;
-
- default:
- case XAT_KWD_INVALID:
- invalid_kwd:
- pType->valType = OPARG_TYPE_NONE;
- return skipUnknown( pzText );
- }
- } while (pzText != NULL);
-
- return pzText;
-}
-
-
-/* parseKeyWordType
- *
- * "pzText" points to the character after "words=".
- * What should follow is a name of a keyword (enumeration) list.
- */
-static char*
-parseKeyWordType(
- tOptions* pOpts,
- char* pzText,
- tOptionValue* pType )
-{
- return skipUnknown( pzText );
-}
-
-
-/* parseSetMemType
- *
- * "pzText" points to the character after "members="
- * What should follow is a name of a "set membership".
- * A collection of bit flags.
- */
-static char*
-parseSetMemType(
- tOptions* pOpts,
- char* pzText,
- tOptionValue* pType )
-{
- return skipUnknown( pzText );
-}
-
-
-/* parseValueType
- *
- * "pzText" points to the character after "type="
- */
-static char*
-parseValueType(
- char* pzText,
- tOptionValue* pType )
-{
- size_t len = 0;
-
- if (*(pzText++) != '=')
- goto woops;
-
- while (IS_OPTION_NAME_CHAR(pzText[len])) len++;
- pzText += len;
-
- if ((len == 0) || (! IS_END_XML_TOKEN_CHAR(*pzText))) {
- woops:
- pType->valType = OPARG_TYPE_NONE;
- return skipUnknown( pzText );
- }
-
- switch (find_value_type_id(pzText - len, len)) {
- default:
- case VTP_KWD_INVALID: goto woops;
-
- case VTP_KWD_STRING:
- pType->valType = OPARG_TYPE_STRING;
- break;
-
- case VTP_KWD_INTEGER:
- pType->valType = OPARG_TYPE_NUMERIC;
- break;
-
- case VTP_KWD_BOOL:
- case VTP_KWD_BOOLEAN:
- pType->valType = OPARG_TYPE_BOOLEAN;
- break;
-
- case VTP_KWD_KEYWORD:
- pType->valType = OPARG_TYPE_ENUMERATION;
- break;
-
- case VTP_KWD_SET:
- case VTP_KWD_SET_MEMBERSHIP:
- pType->valType = OPARG_TYPE_MEMBERSHIP;
- break;
-
- case VTP_KWD_NESTED:
- case VTP_KWD_HIERARCHY:
- pType->valType = OPARG_TYPE_HIERARCHY;
- }
-
- return pzText;
-}
-
-
-/* skipUnknown
- *
- * Skip over some unknown attribute
- */
-static char*
-skipUnknown( char* pzText )
-{
- for (;; pzText++) {
- if (IS_END_XML_TOKEN_CHAR(*pzText)) return pzText;
- if (*pzText == NUL) return NULL;
- }
-}
-
-
-/* validateOptionsStruct
- *
- * Make sure the option descriptor is there and that we understand it.
- * This should be called from any user entry point where one needs to
- * worry about validity. (Some entry points are free to assume that
- * the call is not the first to the library and, thus, that this has
- * already been called.)
- */
-LOCAL tSuccess
-validateOptionsStruct( tOptions* pOpts, char const* pzProgram )
-{
- if (pOpts == NULL) {
- fputs( zAO_Bad, stderr );
- exit( EX_CONFIG );
- }
-
- /*
- * IF the client has enabled translation and the translation procedure
- * is available, then go do it.
- */
- if ( ((pOpts->fOptSet & OPTPROC_TRANSLATE) != 0)
- && (pOpts->pTransProc != NULL) ) {
- /*
- * If option names are not to be translated at all, then do not do
- * it for configuration parsing either. (That is the bit that really
- * gets tested anyway.)
- */
- if ((pOpts->fOptSet & OPTPROC_NO_XLAT_MASK) == OPTPROC_NXLAT_OPT)
- pOpts->fOptSet |= OPTPROC_NXLAT_OPT_CFG;
- (*pOpts->pTransProc)();
- pOpts->fOptSet &= ~OPTPROC_TRANSLATE;
- }
-
- /*
- * IF the struct version is not the current, and also
- * either too large (?!) or too small,
- * THEN emit error message and fail-exit
- */
- if ( ( pOpts->structVersion != OPTIONS_STRUCT_VERSION )
- && ( (pOpts->structVersion > OPTIONS_STRUCT_VERSION )
- || (pOpts->structVersion < OPTIONS_MINIMUM_VERSION )
- ) ) {
-
- fprintf(stderr, zAO_Err, pzProgram, NUM_TO_VER(pOpts->structVersion));
- if (pOpts->structVersion > OPTIONS_STRUCT_VERSION )
- fputs( zAO_Big, stderr );
- else
- fputs( zAO_Sml, stderr );
-
- return FAILURE;
- }
-
- /*
- * If the program name hasn't been set, then set the name and the path
- * and the set of equivalent characters.
- */
- if (pOpts->pzProgName == NULL) {
- char const* pz = strrchr( pzProgram, DIRCH );
-
- if (pz == NULL)
- pOpts->pzProgName = pzProgram;
- else pOpts->pzProgName = pz+1;
-
- pOpts->pzProgPath = pzProgram;
-
- /*
- * when comparing long names, these are equivalent
- */
- strequate( zSepChars );
- }
-
- return SUCCESS;
-}
-
-
-/**
- * Local Variables:
- * mode: C
- * c-file-style: "stroustrup"
- * indent-tabs-mode: nil
- * End:
- * end of autoopts/configfile.c */
+++ /dev/null
-/*
- * $Id: 3da9a5fc88c904673b3b95d0c9667b2bcbccfc80 $
- * Time-stamp: "2007-11-16 22:49:11 bkorb"
- *
- * This file contains the routines that deal with processing quoted strings
- * into an internal format.
- *
- * This file is part of AutoOpts, a companion to AutoGen.
- * AutoOpts is free software.
- * AutoOpts is copyright (c) 1992-2009 by Bruce Korb - all rights reserved
- *
- * AutoOpts is available under any one of two licenses. The license
- * in use must be one of these two and the choice is under the control
- * of the user of the license.
- *
- * The GNU Lesser General Public License, version 3 or later
- * See the files "COPYING.lgplv3" and "COPYING.gplv3"
- *
- * The Modified Berkeley Software Distribution License
- * See the file "COPYING.mbsd"
- *
- * These files have the following md5sums:
- *
- * 43b91e8ca915626ed3818ffb1b71248b pkg/libopts/COPYING.gplv3
- * 06a1a2e4760c90ea5e1dad8dfaac4d39 pkg/libopts/COPYING.lgplv3
- * 66a5cedaf62c4b2637025f049f9b826f pkg/libopts/COPYING.mbsd
- */
-
-/* = = = START-STATIC-FORWARD = = = */
-/* static forward declarations maintained by mk-fwd */
-/* = = = END-STATIC-FORWARD = = = */
-
-/*=export_func ao_string_cook_escape_char
- * private:
- *
- * what: escape-process a string fragment
- * arg: + char const* + pzScan + points to character after the escape +
- * arg: + char* + pRes + Where to put the result byte +
- * arg: + unsigned int + nl_ch + replacement char if scanned char is \n +
- *
- * ret-type: unsigned int
- * ret-desc: The number of bytes consumed processing the escaped character.
- *
- * doc:
- *
- * This function converts "t" into "\t" and all your other favorite
- * escapes, including numeric ones: hex and ocatal, too.
- * The returned result tells the caller how far to advance the
- * scan pointer (passed in). The default is to just pass through the
- * escaped character and advance the scan by one.
- *
- * Some applications need to keep an escaped newline, others need to
- * suppress it. This is accomplished by supplying a '\n' replacement
- * character that is different from \n, if need be. For example, use
- * 0x7F and never emit a 0x7F.
- *
- * err: @code{NULL} is returned if the string is mal-formed.
-=*/
-unsigned int
-ao_string_cook_escape_char( char const* pzIn, char* pRes, u_int nl )
-{
- unsigned int res = 1;
-
- switch (*pRes = *pzIn++) {
- case NUL: /* NUL - end of input string */
- return 0;
- case '\r':
- if (*pzIn != '\n')
- return 1;
- res++;
- /* FALLTHROUGH */
- case '\n': /* NL - emit newline */
- *pRes = (char)nl;
- return res;
-
- case 'a': *pRes = '\a'; break;
- case 'b': *pRes = '\b'; break;
- case 'f': *pRes = '\f'; break;
- case 'n': *pRes = '\n'; break;
- case 'r': *pRes = '\r'; break;
- case 't': *pRes = '\t'; break;
- case 'v': *pRes = '\v'; break;
-
- case 'x':
- case 'X': /* HEX Escape */
- if (IS_HEX_DIGIT_CHAR(*pzIn)) {
- char z[4], *pz = z;
-
- do *(pz++) = *(pzIn++);
- while (IS_HEX_DIGIT_CHAR(*pzIn) && (pz < z + 2));
- *pz = NUL;
- *pRes = (unsigned char)strtoul(z, NULL, 16);
- res += pz - z;
- }
- break;
-
- case '0': case '1': case '2': case '3':
- case '4': case '5': case '6': case '7':
- {
- /*
- * IF the character copied was an octal digit,
- * THEN set the output character to an octal value
- */
- char z[4], *pz = z + 1;
- unsigned long val;
- z[0] = *pRes;
-
- while (IS_OCT_DIGIT_CHAR(*pzIn) && (pz < z + 3))
- *(pz++) = *(pzIn++);
- *pz = NUL;
- val = strtoul(z, NULL, 8);
- if (val > 0xFF)
- val = 0xFF;
- *pRes = (unsigned char)val;
- res = pz - z;
- break;
- }
-
- default: ;
- }
-
- return res;
-}
-
-
-/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
- *
- * A quoted string has been found.
- * Find the end of it and compress any escape sequences.
- */
-/*=export_func ao_string_cook
- * private:
- *
- * what: concatenate and escape-process strings
- * arg: + char* + pzScan + The *MODIFIABLE* input buffer +
- * arg: + int* + pLineCt + The (possibly NULL) pointer to a line count +
- *
- * ret-type: char*
- * ret-desc: The address of the text following the processed strings.
- * The return value is NULL if the strings are ill-formed.
- *
- * doc:
- *
- * A series of one or more quoted strings are concatenated together.
- * If they are quoted with double quotes (@code{"}), then backslash
- * escapes are processed per the C programming language. If they are
- * single quote strings, then the backslashes are honored only when they
- * precede another backslash or a single quote character.
- *
- * err: @code{NULL} is returned if the string(s) is/are mal-formed.
-=*/
-char*
-ao_string_cook( char* pzScan, int* pLineCt )
-{
- int l = 0;
- char q = *pzScan;
-
- /*
- * It is a quoted string. Process the escape sequence characters
- * (in the set "abfnrtv") and make sure we find a closing quote.
- */
- char* pzD = pzScan++;
- char* pzS = pzScan;
-
- if (pLineCt == NULL)
- pLineCt = &l;
-
- for (;;) {
- /*
- * IF the next character is the quote character, THEN we may end the
- * string. We end it unless the next non-blank character *after* the
- * string happens to also be a quote. If it is, then we will change
- * our quote character to the new quote character and continue
- * condensing text.
- */
- while (*pzS == q) {
- *pzD = NUL; /* This is probably the end of the line */
- pzS++;
-
- scan_for_quote:
- while (IS_WHITESPACE_CHAR(*pzS))
- if (*(pzS++) == '\n')
- (*pLineCt)++;
-
- /*
- * IF the next character is a quote character,
- * THEN we will concatenate the strings.
- */
- switch (*pzS) {
- case '"':
- case '\'':
- break;
-
- case '/':
- /*
- * Allow for a comment embedded in the concatenated string.
- */
- switch (pzS[1]) {
- default: return NULL;
- case '/':
- /*
- * Skip to end of line
- */
- pzS = strchr( pzS, '\n' );
- if (pzS == NULL)
- return NULL;
- (*pLineCt)++;
- break;
-
- case '*':
- {
- char* p = strstr( pzS+2, "*/" );
- /*
- * Skip to terminating star slash
- */
- if (p == NULL)
- return NULL;
- while (pzS < p) {
- if (*(pzS++) == '\n')
- (*pLineCt)++;
- }
-
- pzS = p + 2;
- }
- }
- goto scan_for_quote;
-
- default:
- /*
- * The next non-whitespace character is not a quote.
- * The series of quoted strings has come to an end.
- */
- return pzS;
- }
-
- q = *(pzS++); /* assign new quote character and advance scan */
- }
-
- /*
- * We are inside a quoted string. Copy text.
- */
- switch (*(pzD++) = *(pzS++)) {
- case NUL:
- return NULL;
-
- case '\n':
- (*pLineCt)++;
- break;
-
- case '\\':
- /*
- * IF we are escaping a new line,
- * THEN drop both the escape and the newline from
- * the result string.
- */
- if (*pzS == '\n') {
- pzS++;
- pzD--;
- (*pLineCt)++;
- }
-
- /*
- * ELSE IF the quote character is '"' or '`',
- * THEN we do the full escape character processing
- */
- else if (q != '\'') {
- int ct = ao_string_cook_escape_char( pzS, pzD-1, (u_int)'\n' );
- if (ct == 0)
- return NULL;
-
- pzS += ct;
- } /* if (q != '\'') */
-
- /*
- * OTHERWISE, we only process "\\", "\'" and "\#" sequences.
- * The latter only to easily hide preprocessing directives.
- */
- else switch (*pzS) {
- case '\\':
- case '\'':
- case '#':
- pzD[-1] = *pzS++;
- }
- } /* switch (*(pzD++) = *(pzS++)) */
- } /* for (;;) */
-}
-/*
- * Local Variables:
- * mode: C
- * c-file-style: "stroustrup"
- * indent-tabs-mode: nil
- * End:
- * end of autoopts/cook.c */
+++ /dev/null
-
-/*
- * $Id: 27595043d23170eb4bb8b9831fc54016944e00e8 $
- * Time-stamp: "2008-07-27 12:28:01 bkorb"
- *
- * Automated Options Paged Usage module.
- *
- * This routine will run run-on options through a pager so the
- * user may examine, print or edit them at their leisure.
- *
- * This file is part of AutoOpts, a companion to AutoGen.
- * AutoOpts is free software.
- * AutoOpts is copyright (c) 1992-2009 by Bruce Korb - all rights reserved
- *
- * AutoOpts is available under any one of two licenses. The license
- * in use must be one of these two and the choice is under the control
- * of the user of the license.
- *
- * The GNU Lesser General Public License, version 3 or later
- * See the files "COPYING.lgplv3" and "COPYING.gplv3"
- *
- * The Modified Berkeley Software Distribution License
- * See the file "COPYING.mbsd"
- *
- * These files have the following md5sums:
- *
- * 43b91e8ca915626ed3818ffb1b71248b pkg/libopts/COPYING.gplv3
- * 06a1a2e4760c90ea5e1dad8dfaac4d39 pkg/libopts/COPYING.lgplv3
- * 66a5cedaf62c4b2637025f049f9b826f pkg/libopts/COPYING.mbsd
- */
-
-tSCC* pz_enum_err_fmt;
-
-/* = = = START-STATIC-FORWARD = = = */
-/* static forward declarations maintained by mk-fwd */
-static void
-enumError(
- tOptions* pOpts,
- tOptDesc* pOD,
- tCC* const * paz_names,
- int name_ct );
-
-static uintptr_t
-findName(
- tCC* pzName,
- tOptions* pOpts,
- tOptDesc* pOD,
- tCC* const * paz_names,
- unsigned int name_ct );
-/* = = = END-STATIC-FORWARD = = = */
-
-static void
-enumError(
- tOptions* pOpts,
- tOptDesc* pOD,
- tCC* const * paz_names,
- int name_ct )
-{
- size_t max_len = 0;
- size_t ttl_len = 0;
- int ct_down = name_ct;
- int hidden = 0;
-
- /*
- * A real "pOpts" pointer means someone messed up. Give a real error.
- */
- if (pOpts > OPTPROC_EMIT_LIMIT)
- fprintf(option_usage_fp, pz_enum_err_fmt, pOpts->pzProgName,
- pOD->optArg.argString, pOD->pz_Name);
-
- fprintf(option_usage_fp, zValidKeys, pOD->pz_Name);
-
- /*
- * If the first name starts with this funny character, then we have
- * a first value with an unspellable name. You cannot specify it.
- * So, we don't list it either.
- */
- if (**paz_names == 0x7F) {
- paz_names++;
- hidden = 1;
- ct_down = --name_ct;
- }
-
- /*
- * Figure out the maximum length of any name, plus the total length
- * of all the names.
- */
- {
- tCC * const * paz = paz_names;
-
- do {
- size_t len = strlen( *(paz++) ) + 1;
- if (len > max_len)
- max_len = len;
- ttl_len += len;
- } while (--ct_down > 0);
-
- ct_down = name_ct;
- }
-
- /*
- * IF any one entry is about 1/2 line or longer, print one per line
- */
- if (max_len > 35) {
- do {
- fprintf( option_usage_fp, " %s\n", *(paz_names++) );
- } while (--ct_down > 0);
- }
-
- /*
- * ELSE IF they all fit on one line, then do so.
- */
- else if (ttl_len < 76) {
- fputc( ' ', option_usage_fp );
- do {
- fputc( ' ', option_usage_fp );
- fputs( *(paz_names++), option_usage_fp );
- } while (--ct_down > 0);
- fputc( '\n', option_usage_fp );
- }
-
- /*
- * Otherwise, columnize the output
- */
- else {
- int ent_no = 0;
- char zFmt[16]; /* format for all-but-last entries on a line */
-
- sprintf( zFmt, "%%-%ds", (int)max_len );
- max_len = 78 / max_len; /* max_len is now max entries on a line */
- fputs( " ", option_usage_fp );
-
- /*
- * Loop through all but the last entry
- */
- ct_down = name_ct;
- while (--ct_down > 0) {
- if (++ent_no == max_len) {
- /*
- * Last entry on a line. Start next line, too.
- */
- fprintf( option_usage_fp, "%s\n ", *(paz_names++) );
- ent_no = 0;
- }
-
- else
- fprintf(option_usage_fp, zFmt, *(paz_names++) );
- }
- fprintf(option_usage_fp, "%s\n", *paz_names);
- }
-
- if (pOpts > OPTPROC_EMIT_LIMIT) {
- fprintf(option_usage_fp, zIntRange, hidden, name_ct - 1 + hidden);
-
- (*(pOpts->pUsageProc))( pOpts, EXIT_FAILURE );
- /* NOTREACHED */
- }
-
-
- if (OPTST_GET_ARGTYPE(pOD->fOptState) == OPARG_TYPE_MEMBERSHIP) {
- fprintf(option_usage_fp, zLowerBits, name_ct);
- fputs(zSetMemberSettings, option_usage_fp);
- } else {
- fprintf(option_usage_fp, zIntRange, hidden, name_ct - 1 + hidden);
- }
-}
-
-
-static uintptr_t
-findName(
- tCC* pzName,
- tOptions* pOpts,
- tOptDesc* pOD,
- tCC* const * paz_names,
- unsigned int name_ct )
-{
- /*
- * Return the matching index as a pointer sized integer.
- * The result gets stashed in a char* pointer.
- */
- uintptr_t res = name_ct;
- size_t len = strlen( (char*)pzName );
- uintptr_t idx;
-
- if (IS_DEC_DIGIT_CHAR(*pzName)) {
- char * pz = (char *)(void *)pzName;
- unsigned long val = strtoul(pz, &pz, 0);
- if ((*pz == NUL) && (val < name_ct))
- return (uintptr_t)val;
- enumError(pOpts, pOD, paz_names, (int)name_ct);
- return name_ct;
- }
-
- /*
- * Look for an exact match, but remember any partial matches.
- * Multiple partial matches means we have an ambiguous match.
- */
- for (idx = 0; idx < name_ct; idx++) {
- if (strncmp( (char*)paz_names[idx], (char*)pzName, len) == 0) {
- if (paz_names[idx][len] == NUL)
- return idx; /* full match */
-
- res = (res != name_ct) ? ~0 : idx; /* save partial match */
- }
- }
-
- if (res < name_ct)
- return res; /* partial match */
-
- pz_enum_err_fmt = (res == name_ct) ? zNoKey : zAmbigKey;
- option_usage_fp = stderr;
- enumError(pOpts, pOD, paz_names, (int)name_ct);
- return name_ct;
-}
-
-
-/*=export_func optionKeywordName
- * what: Convert between enumeration values and strings
- * private:
- *
- * arg: tOptDesc*, pOD, enumeration option description
- * arg: unsigned int, enum_val, the enumeration value to map
- *
- * ret_type: char const*
- * ret_desc: the enumeration name from const memory
- *
- * doc: This converts an enumeration value into the matching string.
-=*/
-char const*
-optionKeywordName(
- tOptDesc* pOD,
- unsigned int enum_val )
-{
- tOptDesc od;
-
- od.optArg.argEnum = enum_val;
- (*(pOD->pOptProc))(OPTPROC_RETURN_VALNAME, &od );
- return od.optArg.argString;
-}
-
-
-/*=export_func optionEnumerationVal
- * what: Convert from a string to an enumeration value
- * private:
- *
- * arg: tOptions*, pOpts, the program options descriptor
- * arg: tOptDesc*, pOD, enumeration option description
- * arg: char const * const *, paz_names, list of enumeration names
- * arg: unsigned int, name_ct, number of names in list
- *
- * ret_type: uintptr_t
- * ret_desc: the enumeration value
- *
- * doc: This converts the optArg.argString string from the option description
- * into the index corresponding to an entry in the name list.
- * This will match the generated enumeration value.
- * Full matches are always accepted. Partial matches are accepted
- * if there is only one partial match.
-=*/
-uintptr_t
-optionEnumerationVal(
- tOptions* pOpts,
- tOptDesc* pOD,
- tCC * const * paz_names,
- unsigned int name_ct )
-{
- uintptr_t res = 0UL;
-
- /*
- * IF the program option descriptor pointer is invalid,
- * then it is some sort of special request.
- */
- switch ((uintptr_t)pOpts) {
- case (uintptr_t)OPTPROC_EMIT_USAGE:
- /*
- * print the list of enumeration names.
- */
- enumError(pOpts, pOD, paz_names, (int)name_ct);
- break;
-
- case (uintptr_t)OPTPROC_EMIT_SHELL:
- {
- unsigned int ix = pOD->optArg.argEnum;
- /*
- * print the name string.
- */
- if (ix >= name_ct)
- printf( "INVALID-%d", ix );
- else
- fputs( paz_names[ ix ], stdout );
-
- break;
- }
-
- case (uintptr_t)OPTPROC_RETURN_VALNAME:
- {
- tSCC zInval[] = "*INVALID*";
- unsigned int ix = pOD->optArg.argEnum;
- /*
- * Replace the enumeration value with the name string.
- */
- if (ix >= name_ct)
- return (uintptr_t)zInval;
-
- pOD->optArg.argString = paz_names[ix];
- break;
- }
-
- default:
- res = findName(pOD->optArg.argString, pOpts, pOD, paz_names, name_ct);
-
- if (pOD->fOptState & OPTST_ALLOC_ARG) {
- AGFREE(pOD->optArg.argString);
- pOD->fOptState &= ~OPTST_ALLOC_ARG;
- pOD->optArg.argString = NULL;
- }
- }
-
- return res;
-}
-
-
-/*=export_func optionSetMembers
- * what: Convert between bit flag values and strings
- * private:
- *
- * arg: tOptions*, pOpts, the program options descriptor
- * arg: tOptDesc*, pOD, enumeration option description
- * arg: char const * const *,
- * paz_names, list of enumeration names
- * arg: unsigned int, name_ct, number of names in list
- *
- * doc: This converts the optArg.argString string from the option description
- * into the index corresponding to an entry in the name list.
- * This will match the generated enumeration value.
- * Full matches are always accepted. Partial matches are accepted
- * if there is only one partial match.
-=*/
-void
-optionSetMembers(
- tOptions* pOpts,
- tOptDesc* pOD,
- tCC* const * paz_names,
- unsigned int name_ct )
-{
- /*
- * IF the program option descriptor pointer is invalid,
- * then it is some sort of special request.
- */
- switch ((uintptr_t)pOpts) {
- case (uintptr_t)OPTPROC_EMIT_USAGE:
- /*
- * print the list of enumeration names.
- */
- enumError(OPTPROC_EMIT_USAGE, pOD, paz_names, (int)name_ct );
- return;
-
- case (uintptr_t)OPTPROC_EMIT_SHELL:
- {
- /*
- * print the name string.
- */
- int ix = 0;
- uintptr_t bits = (uintptr_t)pOD->optCookie;
- size_t len = 0;
-
- bits &= ((uintptr_t)1 << (uintptr_t)name_ct) - (uintptr_t)1;
-
- while (bits != 0) {
- if (bits & 1) {
- if (len++ > 0) fputs( " | ", stdout );
- fputs(paz_names[ix], stdout);
- }
- if (++ix >= name_ct) break;
- bits >>= 1;
- }
- return;
- }
-
- case (uintptr_t)OPTPROC_RETURN_VALNAME:
- {
- char* pz;
- uintptr_t bits = (uintptr_t)pOD->optCookie;
- int ix = 0;
- size_t len = 5;
-
- bits &= ((uintptr_t)1 << (uintptr_t)name_ct) - (uintptr_t)1;
-
- /*
- * Replace the enumeration value with the name string.
- * First, determine the needed length, then allocate and fill in.
- */
- while (bits != 0) {
- if (bits & 1)
- len += strlen( paz_names[ix]) + 8;
- if (++ix >= name_ct) break;
- bits >>= 1;
- }
-
- pOD->optArg.argString = pz = AGALOC(len, "enum name");
-
- /*
- * Start by clearing all the bits. We want to turn off any defaults
- * because we will be restoring to current state, not adding to
- * the default set of bits.
- */
- strcpy( pz, "none" );
- pz += 4;
- bits = (uintptr_t)pOD->optCookie;
- bits &= ((uintptr_t)1 << (uintptr_t)name_ct) - (uintptr_t)1;
- ix = 0;
-
- while (bits != 0) {
- if (bits & 1) {
- strcpy( pz, " + " );
- strcpy( pz+3, paz_names[ix]);
- pz += strlen( paz_names[ix]) + 3;
- }
- if (++ix >= name_ct) break;
- bits >>= 1;
- }
- return;
- }
-
- default:
- break;
- }
-
- if ((pOD->fOptState & OPTST_RESET) != 0)
- return;
-
- {
- tCC* pzArg = pOD->optArg.argString;
- uintptr_t res;
- if ((pzArg == NULL) || (*pzArg == NUL)) {
- pOD->optCookie = (void*)0;
- return;
- }
-
- res = (uintptr_t)pOD->optCookie;
- for (;;) {
- tSCC zSpn[] = " ,|+\t\r\f\n";
- int iv, len;
-
- pzArg += strspn( pzArg, zSpn );
- iv = (*pzArg == '!');
- if (iv)
- pzArg += strspn( pzArg+1, zSpn ) + 1;
-
- len = strcspn( pzArg, zSpn );
- if (len == 0)
- break;
-
- if ((len == 3) && (strncmp(pzArg, zAll, (size_t)3) == 0)) {
- if (iv)
- res = 0;
- else res = ~0UL;
- }
- else if ((len == 4) && (strncmp(pzArg, zNone, (size_t)4) == 0)) {
- if (! iv)
- res = 0;
- }
- else do {
- char* pz;
- uintptr_t bit = strtoul( pzArg, &pz, 0 );
-
- if (pz != pzArg + len) {
- char z[ AO_NAME_SIZE ];
- tCC* p;
- int shift_ct;
-
- if (*pz != NUL) {
- if (len >= AO_NAME_LIMIT)
- break;
- strncpy( z, pzArg, (size_t)len );
- z[len] = NUL;
- p = z;
- } else {
- p = pzArg;
- }
-
- shift_ct = findName(p, pOpts, pOD, paz_names, name_ct);
- if (shift_ct >= name_ct) {
- pOD->optCookie = (void*)0;
- return;
- }
- bit = 1UL << shift_ct;
- }
- if (iv)
- res &= ~bit;
- else res |= bit;
- } while (0);
-
- if (pzArg[len] == NUL)
- break;
- pzArg += len + 1;
- }
- if (name_ct < (8 * sizeof( uintptr_t ))) {
- res &= (1UL << name_ct) - 1UL;
- }
-
- pOD->optCookie = (void*)res;
- }
-}
-
-/*
- * Local Variables:
- * mode: C
- * c-file-style: "stroustrup"
- * indent-tabs-mode: nil
- * End:
- * end of autoopts/enumeration.c */
+++ /dev/null
-
-/*
- * $Id: 8700c8e91e8094c455392c691d9b6a7d62222240 $
- * Time-stamp: "2009-07-20 20:12:24 bkorb"
- *
- * This file contains all of the routines that must be linked into
- * an executable to use the generated option processing. The optional
- * routines are in separately compiled modules so that they will not
- * necessarily be linked in.
- *
- * This file is part of AutoOpts, a companion to AutoGen.
- * AutoOpts is free software.
- * AutoOpts is copyright (c) 1992-2009 by Bruce Korb - all rights reserved
- *
- * AutoOpts is available under any one of two licenses. The license
- * in use must be one of these two and the choice is under the control
- * of the user of the license.
- *
- * The GNU Lesser General Public License, version 3 or later
- * See the files "COPYING.lgplv3" and "COPYING.gplv3"
- *
- * The Modified Berkeley Software Distribution License
- * See the file "COPYING.mbsd"
- *
- * These files have the following md5sums:
- *
- * 43b91e8ca915626ed3818ffb1b71248b pkg/libopts/COPYING.gplv3
- * 06a1a2e4760c90ea5e1dad8dfaac4d39 pkg/libopts/COPYING.lgplv3
- * 66a5cedaf62c4b2637025f049f9b826f pkg/libopts/COPYING.mbsd
- */
-
-/* = = = START-STATIC-FORWARD = = = */
-/* static forward declarations maintained by mk-fwd */
-static void
-checkEnvOpt(tOptState * os, char * env_name,
- tOptions* pOpts, teEnvPresetType type);
-/* = = = END-STATIC-FORWARD = = = */
-
-/*
- * doPrognameEnv - check for preset values from the ${PROGNAME}
- * environment variable. This is accomplished by parsing the text into
- * tokens, temporarily replacing the arg vector and calling
- * doImmediateOpts and/or doRegularOpts.
- */
-LOCAL void
-doPrognameEnv( tOptions* pOpts, teEnvPresetType type )
-{
- char const* pczOptStr = getenv( pOpts->pzPROGNAME );
- token_list_t* pTL;
- int sv_argc;
- tAoUI sv_flag;
- char** sv_argv;
-
- /*
- * No such beast? Then bail now.
- */
- if (pczOptStr == NULL)
- return;
-
- /*
- * Tokenize the string. If there's nothing of interest, we'll bail
- * here immediately.
- */
- pTL = ao_string_tokenize( pczOptStr );
- if (pTL == NULL)
- return;
-
- /*
- * Substitute our $PROGNAME argument list for the real one
- */
- sv_argc = pOpts->origArgCt;
- sv_argv = pOpts->origArgVect;
- sv_flag = pOpts->fOptSet;
-
- /*
- * We add a bogus pointer to the start of the list. The program name
- * has already been pulled from "argv", so it won't get dereferenced.
- * The option scanning code will skip the "program name" at the start
- * of this list of tokens, so we accommodate this way ....
- */
- pOpts->origArgVect = (char**)(pTL->tkn_list - 1);
- pOpts->origArgCt = pTL->tkn_ct + 1;
- pOpts->fOptSet &= ~OPTPROC_ERRSTOP;
-
- pOpts->curOptIdx = 1;
- pOpts->pzCurOpt = NULL;
-
- switch (type) {
- case ENV_IMM:
- (void)doImmediateOpts( pOpts );
- break;
-
- case ENV_ALL:
- (void)doImmediateOpts( pOpts );
- pOpts->curOptIdx = 1;
- pOpts->pzCurOpt = NULL;
- /* FALLTHROUGH */
-
- case ENV_NON_IMM:
- (void)doRegularOpts( pOpts );
- }
-
- /*
- * Free up the temporary arg vector and restore the original program args.
- */
- free( pTL );
- pOpts->origArgVect = sv_argv;
- pOpts->origArgCt = sv_argc;
- pOpts->fOptSet = sv_flag;
-}
-
-static void
-checkEnvOpt(tOptState * os, char * env_name,
- tOptions* pOpts, teEnvPresetType type)
-{
- os->pzOptArg = getenv( env_name );
- if (os->pzOptArg == NULL)
- return;
-
- os->flags = OPTST_PRESET | OPTST_ALLOC_ARG | os->pOD->fOptState;
- os->optType = TOPT_UNDEFINED;
-
- if ( (os->pOD->pz_DisablePfx != NULL)
- && (streqvcmp( os->pzOptArg, os->pOD->pz_DisablePfx ) == 0)) {
- os->flags |= OPTST_DISABLED;
- os->pzOptArg = NULL;
- }
-
- switch (type) {
- case ENV_IMM:
- /*
- * Process only immediate actions
- */
- if (DO_IMMEDIATELY(os->flags))
- break;
- return;
-
- case ENV_NON_IMM:
- /*
- * Process only NON immediate actions
- */
- if (DO_NORMALLY(os->flags) || DO_SECOND_TIME(os->flags))
- break;
- return;
-
- default: /* process everything */
- break;
- }
-
- /*
- * Make sure the option value string is persistent and consistent.
- *
- * The interpretation of the option value depends
- * on the type of value argument the option takes
- */
- if (os->pzOptArg != NULL) {
- if (OPTST_GET_ARGTYPE(os->pOD->fOptState) == OPARG_TYPE_NONE) {
- os->pzOptArg = NULL;
- } else if ( (os->pOD->fOptState & OPTST_ARG_OPTIONAL)
- && (*os->pzOptArg == NUL)) {
- os->pzOptArg = NULL;
- } else if (*os->pzOptArg == NUL) {
- os->pzOptArg = zNil;
- } else {
- AGDUPSTR( os->pzOptArg, os->pzOptArg, "option argument" );
- os->flags |= OPTST_ALLOC_ARG;
- }
- }
-
- handleOption( pOpts, os );
-}
-
-/*
- * doEnvPresets - check for preset values from the envrionment
- * This routine should process in all, immediate or normal modes....
- */
-LOCAL void
-doEnvPresets( tOptions* pOpts, teEnvPresetType type )
-{
- int ct;
- tOptState st;
- char* pzFlagName;
- size_t spaceLeft;
- char zEnvName[ AO_NAME_SIZE ];
-
- /*
- * Finally, see if we are to look at the environment
- * variables for initial values.
- */
- if ((pOpts->fOptSet & OPTPROC_ENVIRON) == 0)
- return;
-
- doPrognameEnv( pOpts, type );
-
- ct = pOpts->presetOptCt;
- st.pOD = pOpts->pOptDesc;
-
- pzFlagName = zEnvName
- + snprintf( zEnvName, sizeof( zEnvName ), "%s_", pOpts->pzPROGNAME );
- spaceLeft = AO_NAME_SIZE - (pzFlagName - zEnvName) - 1;
-
- for (;ct-- > 0; st.pOD++) {
- /*
- * If presetting is disallowed, then skip this entry
- */
- if ( ((st.pOD->fOptState & OPTST_NO_INIT) != 0)
- || (st.pOD->optEquivIndex != NO_EQUIVALENT) )
- continue;
-
- /*
- * IF there is no such environment variable,
- * THEN skip this entry, too.
- */
- if (strlen( st.pOD->pz_NAME ) >= spaceLeft)
- continue;
-
- /*
- * Set up the option state
- */
- strcpy( pzFlagName, st.pOD->pz_NAME );
- checkEnvOpt(&st, zEnvName, pOpts, type);
- }
-
- /*
- * Special handling for ${PROGNAME_LOAD_OPTS}
- */
- if ( (pOpts->specOptIdx.save_opts != NO_EQUIVALENT)
- && (pOpts->specOptIdx.save_opts != 0)) {
- st.pOD = pOpts->pOptDesc + pOpts->specOptIdx.save_opts + 1;
- strcpy( pzFlagName, st.pOD->pz_NAME );
- checkEnvOpt(&st, zEnvName, pOpts, type);
- }
-}
-
-/*
- * Local Variables:
- * mode: C
- * c-file-style: "stroustrup"
- * indent-tabs-mode: nil
- * End:
- * end of autoopts/environment.c */
+++ /dev/null
-
-/*
- * $Id: 1410aaa5f08a562e0cd6c28ffae5a49dc7a3164f $
- * Time-stamp: "2009-07-23 17:23:46 bkorb"
- *
- * This file is part of AutoOpts, a companion to AutoGen.
- * AutoOpts is free software.
- * AutoOpts is copyright (c) 1992-2009 by Bruce Korb - all rights reserved
- *
- * AutoOpts is available under any one of two licenses. The license
- * in use must be one of these two and the choice is under the control
- * of the user of the license.
- *
- * The GNU Lesser General Public License, version 3 or later
- * See the files "COPYING.lgplv3" and "COPYING.gplv3"
- *
- * The Modified Berkeley Software Distribution License
- * See the file "COPYING.mbsd"
- *
- * These files have the following md5sums:
- *
- * 43b91e8ca915626ed3818ffb1b71248b pkg/libopts/COPYING.gplv3
- * 06a1a2e4760c90ea5e1dad8dfaac4d39 pkg/libopts/COPYING.lgplv3
- * 66a5cedaf62c4b2637025f049f9b826f pkg/libopts/COPYING.mbsd
- */
-
-/*=export_func optionFileCheck
- * private:
- *
- * what: Decipher a boolean value
- * arg: + tOptions* + pOpts + program options descriptor +
- * arg: + tOptDesc* + pOptDesc + the descriptor for this arg +
- * arg: + teOptFileType + ftype + File handling type +
- * arg: + tuFileMode + mode + file open mode (if needed) +
- *
- * doc:
- * Make sure the named file conforms with the file type mode.
- * The mode specifies if the file must exist, must not exist or may
- * (or may not) exist. The mode may also specify opening the
- * file: don't, open just the descriptor (fd), or open as a stream
- * (FILE* pointer).
-=*/
-void
-optionFileCheck(tOptions* pOpts, tOptDesc* pOD,
- teOptFileType ftype, tuFileMode mode)
-{
- if (pOpts <= OPTPROC_EMIT_LIMIT) {
- if (pOpts != OPTPROC_EMIT_USAGE)
- return;
-
- switch (ftype & FTYPE_MODE_EXIST_MASK) {
- case FTYPE_MODE_MUST_NOT_EXIST:
- fputs(zFileCannotExist, option_usage_fp);
- break;
-
- case FTYPE_MODE_MUST_EXIST:
- fputs(zFileMustExist, option_usage_fp);
- break;
- }
- return;
- }
-
- if ((pOD->fOptState & OPTST_RESET) != 0) {
- if (pOD->optCookie != NULL)
- AGFREE(pOD->optCookie);
- return;
- }
-
- {
- struct stat sb;
-
- errno = 0;
-
- switch (ftype & FTYPE_MODE_EXIST_MASK) {
- case FTYPE_MODE_MUST_NOT_EXIST:
- if ( (stat(pOD->optArg.argString, &sb) == 0)
- || (errno != ENOENT) ){
- if (errno == 0)
- errno = EINVAL;
- fprintf(stderr, zFSOptError, errno, strerror(errno),
- zFSOptErrNoExist, pOD->optArg.argString, pOD->pz_Name);
- pOpts->pUsageProc(pOpts, EXIT_FAILURE);
- /* NOTREACHED */
- }
- /* FALLTHROUGH */
-
- default:
- case FTYPE_MODE_MAY_EXIST:
- {
- char * p = strrchr(pOD->optArg.argString, DIRCH);
- if (p != NULL)
- *p = NUL;
- if ( (stat(pOD->optArg.argString, &sb) != 0)
- || (errno = EINVAL, ! S_ISDIR(sb.st_mode)) ){
- fprintf(stderr, zFSOptError, errno, strerror(errno),
- zFSOptErrMayExist, pOD->optArg.argString, pOD->pz_Name);
- pOpts->pUsageProc(pOpts, EXIT_FAILURE);
- /* NOTREACHED */
- }
- if (p != NULL)
- *p = DIRCH;
- break;
- }
-
- case FTYPE_MODE_MUST_EXIST:
- if ( (stat(pOD->optArg.argString, &sb) != 0)
- || (errno = EINVAL, ! S_ISREG(sb.st_mode)) ){
- fprintf(stderr, zFSOptError, errno, strerror(errno),
- zFSOptErrMustExist, pOD->optArg.argString,
- pOD->pz_Name);
- pOpts->pUsageProc(pOpts, EXIT_FAILURE);
- /* NOTREACHED */
- }
- break;
- }
- }
-
- switch (ftype & FTYPE_MODE_OPEN_MASK) {
- default:
- case FTYPE_MODE_NO_OPEN:
- break;
-
- case FTYPE_MODE_OPEN_FD:
- {
- int fd = open(pOD->optArg.argString, mode.file_flags);
- if (fd < 0) {
- fprintf(stderr, zFSOptError, errno, strerror(errno),
- zFSOptErrOpen, pOD->optArg.argString, pOD->pz_Name);
- pOpts->pUsageProc(pOpts, EXIT_FAILURE);
- /* NOTREACHED */
- }
-
- if ((pOD->fOptState & OPTST_ALLOC_ARG) != 0)
- pOD->optCookie = (void *)pOD->optArg.argString;
- else
- AGDUPSTR(pOD->optCookie, pOD->optArg.argString, "file name");
-
- pOD->optArg.argFd = fd;
- pOD->fOptState &= ~OPTST_ALLOC_ARG;
- break;
- }
-
- case FTYPE_MODE_FOPEN_FP:
- {
- FILE* fp = fopen(pOD->optArg.argString, mode.file_mode);
- if (fp == NULL) {
- fprintf(stderr, zFSOptError, errno, strerror(errno),
- zFSOptErrFopen, pOD->optArg.argString, pOD->pz_Name);
- pOpts->pUsageProc(pOpts, EXIT_FAILURE);
- /* NOTREACHED */
- }
-
- if ((pOD->fOptState & OPTST_ALLOC_ARG) != 0)
- pOD->optCookie = (void *)pOD->optArg.argString;
- else
- AGDUPSTR(pOD->optCookie, pOD->optArg.argString, "file name");
-
- pOD->optArg.argFp = fp;
- pOD->fOptState &= ~OPTST_ALLOC_ARG;
- break;
- }
- }
-}
-/*
- * Local Variables:
- * mode: C
- * c-file-style: "stroustrup"
- * indent-tabs-mode: nil
- * End:
- * end of autoopts/file.c */
+++ /dev/null
-/* -*- buffer-read-only: t -*- vi: set ro:
- *
- * DO NOT EDIT THIS FILE (genshell.c)
- *
- * It has been AutoGen-ed November 8, 2009 at 08:41:09 AM by AutoGen 5.9.10pre13
- * From the definitions genshell.def
- * and the template file options
- *
- * Generated from AutoOpts @AO_CURRENT@:@AO_REVISION@:@AO_AGE@ templates.
- */
-
-/*
- * This file was produced by an AutoOpts template. AutoOpts is a
- * copyrighted work. This source file is not encumbered by AutoOpts
- * licensing, but is provided under the licensing terms chosen by the
- * genshellopt author or copyright holder. AutoOpts is licensed under
- * the terms of the LGPL. The redistributable library (``libopts'') is
- * licensed under the terms of either the LGPL or, at the users discretion,
- * the BSD license. See the AutoOpts and/or libopts sources for details.
- *
- * This source file is copyrighted and licensed under the following terms:
- *
- * genshellopt copyright (c) 1999-2009 Bruce Korb - all rights reserved
- *
- * genshellopt 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.
- *
- * genshellopt 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 <http://www.gnu.org/licenses/>.
- */
-
-#include <sys/types.h>
-#include <limits.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-#define OPTION_CODE_COMPILE 1
-#include "genshell.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* TRANSLATORS: choose the translation for option names wisely because you
- cannot ever change your mind. */
-tSCC zCopyright[] =
- "genshellopt copyright (c) 1999-2009 Bruce Korb, all rights reserved";
-tSCC zCopyrightNotice[610] =
-"genshellopt is free software: you can redistribute it and/or modify it under\n\
-the terms of the GNU General Public License as published by the Free Software\n\
-Foundation, either version 3 of the License, or (at your option) any later\n\
-version.\n\n\
-genshellopt is distributed in the hope that it will be useful, but WITHOUT ANY\n\
-WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A\n\
-PARTICULAR PURPOSE. See the GNU General Public License for more details.\n\n\
-You should have received a copy of the GNU General Public License along with\n\
-this program. If not, see <http://www.gnu.org/licenses/>.";
-
-extern tUsageProc genshelloptUsage;
-
-#ifndef NULL
-# define NULL 0
-#endif
-#ifndef EXIT_SUCCESS
-# define EXIT_SUCCESS 0
-#endif
-#ifndef EXIT_FAILURE
-# define EXIT_FAILURE 1
-#endif
-
-/*
- * Script option description:
- */
-tSCC zScriptText[] =
- "Output Script File";
-tSCC zScript_NAME[] = "SCRIPT";
-tSCC zScript_Name[] = "script";
-#define SCRIPT_FLAGS (OPTST_DISABLED \
- | OPTST_SET_ARGTYPE(OPARG_TYPE_STRING))
-
-/*
- * Shell option description:
- */
-tSCC zShellText[] =
- "Shell name (follows \"#!\" magic)";
-tSCC zShell_NAME[] = "SHELL";
-tSCC zNotShell_Name[] = "no-shell";
-tSCC zNotShell_Pfx[] = "no";
-#define zShell_Name (zNotShell_Name + 3)
-#define SHELL_FLAGS (OPTST_INITENABLED \
- | OPTST_SET_ARGTYPE(OPARG_TYPE_STRING))
-
-/*
- * Help/More_Help/Version option descriptions:
- */
-tSCC zHelpText[] = "Display extended usage information and exit";
-tSCC zHelp_Name[] = "help";
-#ifdef HAVE_WORKING_FORK
-#define OPTST_MORE_HELP_FLAGS (OPTST_IMM | OPTST_NO_INIT)
-tSCC zMore_Help_Name[] = "more-help";
-tSCC zMore_HelpText[] = "Extended usage information passed thru pager";
-#else
-#define OPTST_MORE_HELP_FLAGS (OPTST_OMITTED | OPTST_NO_INIT)
-#define zMore_Help_Name NULL
-#define zMore_HelpText NULL
-#endif
-#ifdef NO_OPTIONAL_OPT_ARGS
-# define OPTST_VERSION_FLAGS OPTST_IMM | OPTST_NO_INIT
-#else
-# define OPTST_VERSION_FLAGS OPTST_SET_ARGTYPE(OPARG_TYPE_STRING) | \
- OPTST_ARG_OPTIONAL | OPTST_IMM | OPTST_NO_INIT
-#endif
-
-tSCC zVersionText[] = "Output version information and exit";
-tSCC zVersion_Name[] = "version";
-/*
- * Declare option callback procedures
- */
-extern tOptProc
- optionPagedUsage, optionPrintVersion;
-static tOptProc
- doUsageOpt;
-
-/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
- *
- * Define the Genshellopt Option Descriptions.
- */
-static tOptDesc optDesc[ OPTION_CT ] = {
- { /* entry idx, value */ 0, VALUE_OPT_SCRIPT,
- /* equiv idx, value */ 0, VALUE_OPT_SCRIPT,
- /* equivalenced to */ NO_EQUIVALENT,
- /* min, max, act ct */ 0, 1, 0,
- /* opt state flags */ SCRIPT_FLAGS, 0,
- /* last opt argumnt */ { NULL },
- /* arg list/cookie */ NULL,
- /* must/cannot opts */ NULL, NULL,
- /* option proc */ NULL,
- /* desc, NAME, name */ zScriptText, zScript_NAME, zScript_Name,
- /* disablement strs */ NULL, NULL },
-
- { /* entry idx, value */ 1, VALUE_OPT_SHELL,
- /* equiv idx, value */ 1, VALUE_OPT_SHELL,
- /* equivalenced to */ NO_EQUIVALENT,
- /* min, max, act ct */ 0, 1, 0,
- /* opt state flags */ SHELL_FLAGS, 0,
- /* last opt argumnt */ { NULL },
- /* arg list/cookie */ NULL,
- /* must/cannot opts */ NULL, NULL,
- /* option proc */ NULL,
- /* desc, NAME, name */ zShellText, zShell_NAME, zShell_Name,
- /* disablement strs */ zNotShell_Name, zNotShell_Pfx },
-
- { /* entry idx, value */ INDEX_OPT_VERSION, VALUE_OPT_VERSION,
- /* equiv idx value */ NO_EQUIVALENT, 0,
- /* equivalenced to */ NO_EQUIVALENT,
- /* min, max, act ct */ 0, 1, 0,
- /* opt state flags */ OPTST_VERSION_FLAGS, 0,
- /* last opt argumnt */ { NULL },
- /* arg list/cookie */ NULL,
- /* must/cannot opts */ NULL, NULL,
- /* option proc */ optionPrintVersion,
- /* desc, NAME, name */ zVersionText, NULL, zVersion_Name,
- /* disablement strs */ NULL, NULL },
-
-
-
- { /* entry idx, value */ INDEX_OPT_HELP, VALUE_OPT_HELP,
- /* equiv idx value */ NO_EQUIVALENT, 0,
- /* equivalenced to */ NO_EQUIVALENT,
- /* min, max, act ct */ 0, 1, 0,
- /* opt state flags */ OPTST_IMM | OPTST_NO_INIT, 0,
- /* last opt argumnt */ { NULL },
- /* arg list/cookie */ NULL,
- /* must/cannot opts */ NULL, NULL,
- /* option proc */ doUsageOpt,
- /* desc, NAME, name */ zHelpText, NULL, zHelp_Name,
- /* disablement strs */ NULL, NULL },
-
- { /* entry idx, value */ INDEX_OPT_MORE_HELP, VALUE_OPT_MORE_HELP,
- /* equiv idx value */ NO_EQUIVALENT, 0,
- /* equivalenced to */ NO_EQUIVALENT,
- /* min, max, act ct */ 0, 1, 0,
- /* opt state flags */ OPTST_MORE_HELP_FLAGS, 0,
- /* last opt argumnt */ { NULL },
- /* arg list/cookie */ NULL,
- /* must/cannot opts */ NULL, NULL,
- /* option proc */ optionPagedUsage,
- /* desc, NAME, name */ zMore_HelpText, NULL, zMore_Help_Name,
- /* disablement strs */ NULL, NULL }
-};
-
-/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
- *
- * Define the Genshellopt Option Environment
- */
-tSCC zPROGNAME[] = "GENSHELLOPT";
-tSCC zUsageTitle[] =
-"genshellopt - Generate Shell Option Processing Script - Ver. 1\n\
-USAGE: %s [ -<flag> [<val>] | --<name>[{=| }<val>] ]...\n";
-#define zRcName NULL
-#define apzHomeList NULL
-
-tSCC zBugsAddr[] = "autogen-users@lists.sourceforge.net";
-tSCC zExplain[] = "\n\
-Note that `shell' is only useful if the output file does not already\n\
-exist. If it does, then the shell name and optional first argument\n\
-will be extracted from the script file.\n";
-tSCC zDetail[] = "\n\
-If the script file already exists and contains Automated Option Processing\n\
-text, the second line of the file through the ending tag will be replaced\n\
-by the newly generated text. The first `#!' line will be regenerated.\n";
-tSCC zFullVersion[] = GENSHELLOPT_FULL_VERSION;
-/* extracted from optcode.tpl near line 495 */
-
-#if defined(ENABLE_NLS)
-# define OPTPROC_BASE OPTPROC_TRANSLATE
- static tOptionXlateProc translate_option_strings;
-#else
-# define OPTPROC_BASE OPTPROC_NONE
-# define translate_option_strings NULL
-#endif /* ENABLE_NLS */
-
-
-#define genshellopt_full_usage NULL
-#define genshellopt_short_usage NULL
-tOptions genshelloptOptions = {
- OPTIONS_STRUCT_VERSION,
- 0, NULL, /* original argc + argv */
- ( OPTPROC_BASE
- + OPTPROC_ERRSTOP
- + OPTPROC_SHORTOPT
- + OPTPROC_LONGOPT
- + OPTPROC_NO_REQ_OPT
- + OPTPROC_NEGATIONS
- + OPTPROC_NO_ARGS ),
- 0, NULL, /* current option index, current option */
- NULL, NULL, zPROGNAME,
- zRcName, zCopyright, zCopyrightNotice,
- zFullVersion, apzHomeList, zUsageTitle,
- zExplain, zDetail, optDesc,
- zBugsAddr, /* address to send bugs to */
- NULL, NULL, /* extensions/saved state */
- genshelloptUsage, /* usage procedure */
- translate_option_strings, /* translation procedure */
- /*
- * Indexes to special options
- */
- { INDEX_OPT_MORE_HELP, /* more-help option index */
- NO_EQUIVALENT, /* save option index */
- NO_EQUIVALENT, /* '-#' option index */
- NO_EQUIVALENT /* index of default opt */
- },
- 5 /* full option count */, 2 /* user option count */,
- genshellopt_full_usage, genshellopt_short_usage,
- NULL, NULL
-};
-
-/*
- * Create the static procedure(s) declared above.
- */
-static void
-doUsageOpt(
- tOptions* pOptions,
- tOptDesc* pOptDesc )
-{
- (void)pOptions;
- USAGE( EXIT_SUCCESS );
-}
-/* extracted from optcode.tpl near line 627 */
-
-#if ENABLE_NLS
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-#include <autoopts/usage-txt.h>
-
-static char* AO_gettext( char const* pz );
-static void coerce_it(void** s);
-
-static char*
-AO_gettext( char const* pz )
-{
- char* pzRes;
- if (pz == NULL)
- return NULL;
- pzRes = _(pz);
- if (pzRes == pz)
- return pzRes;
- pzRes = strdup( pzRes );
- if (pzRes == NULL) {
- fputs( _("No memory for duping translated strings\n"), stderr );
- exit( EXIT_FAILURE );
- }
- return pzRes;
-}
-
-static void coerce_it(void** s) { *s = AO_gettext(*s); }
-#define COERSION(_f) \
- coerce_it((void*)&(genshelloptOptions._f))
-
-/*
- * This invokes the translation code (e.g. gettext(3)).
- */
-static void
-translate_option_strings( void )
-{
- /*
- * Guard against re-translation. It won't work. The strings will have
- * been changed by the first pass through this code. One shot only.
- */
- if (option_usage_text.field_ct != 0) {
-
- /*
- * Do the translations. The first pointer follows the field count
- * field. The field count field is the size of a pointer.
- */
- tOptDesc* pOD = genshelloptOptions.pOptDesc;
- char** ppz = (char**)(void*)&(option_usage_text);
- int ix = option_usage_text.field_ct;
-
- do {
- ppz++;
- *ppz = AO_gettext(*ppz);
- } while (--ix > 0);
-
- COERSION(pzCopyright);
- COERSION(pzCopyNotice);
- COERSION(pzFullVersion);
- COERSION(pzUsageTitle);
- COERSION(pzExplain);
- COERSION(pzDetail);
- option_usage_text.field_ct = 0;
-
- for (ix = genshelloptOptions.optCt; ix > 0; ix--, pOD++)
- coerce_it((void*)&(pOD->pzText));
- }
-
- if ((genshelloptOptions.fOptSet & OPTPROC_NXLAT_OPT_CFG) == 0) {
- tOptDesc* pOD = genshelloptOptions.pOptDesc;
- int ix;
-
- for (ix = genshelloptOptions.optCt; ix > 0; ix--, pOD++) {
- coerce_it((void*)&(pOD->pz_Name));
- coerce_it((void*)&(pOD->pz_DisableName));
- coerce_it((void*)&(pOD->pz_DisablePfx));
- }
- /* prevent re-translation */
- genshelloptOptions.fOptSet |= OPTPROC_NXLAT_OPT_CFG | OPTPROC_NXLAT_OPT;
- }
-}
-
-#endif /* ENABLE_NLS */
-
-#ifdef __cplusplus
-}
-#endif
-/* genshell.c ends here */
+++ /dev/null
-/* -*- buffer-read-only: t -*- vi: set ro:
- *
- * DO NOT EDIT THIS FILE (genshell.h)
- *
- * It has been AutoGen-ed November 8, 2009 at 08:41:09 AM by AutoGen 5.9.10pre13
- * From the definitions genshell.def
- * and the template file options
- *
- * Generated from AutoOpts @AO_CURRENT@:@AO_REVISION@:@AO_AGE@ templates.
- */
-
-/*
- * This file was produced by an AutoOpts template. AutoOpts is a
- * copyrighted work. This header file is not encumbered by AutoOpts
- * licensing, but is provided under the licensing terms chosen by the
- * genshellopt author or copyright holder. AutoOpts is licensed under
- * the terms of the LGPL. The redistributable library (``libopts'') is
- * licensed under the terms of either the LGPL or, at the users discretion,
- * the BSD license. See the AutoOpts and/or libopts sources for details.
- *
- * This source file is copyrighted and licensed under the following terms:
- *
- * genshellopt copyright (c) 1999-2009 Bruce Korb - all rights reserved
- *
- * genshellopt 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.
- *
- * genshellopt 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 <http://www.gnu.org/licenses/>.
- */
-/*
- * This file contains the programmatic interface to the Automated
- * Options generated for the genshellopt program.
- * These macros are documented in the AutoGen info file in the
- * "AutoOpts" chapter. Please refer to that doc for usage help.
- */
-#ifndef AUTOOPTS_GENSHELL_H_GUARD
-#define AUTOOPTS_GENSHELL_H_GUARD 1
-#include <autoopts/options.h>
-
-/*
- * Ensure that the library used for compiling this generated header is at
- * least as new as the version current when the header template was released
- * (not counting patch version increments). Also ensure that the oldest
- * tolerable version is at least as old as what was current when the header
- * template was released.
- */
-#define AO_TEMPLATE_VERSION 135168
-#if (AO_TEMPLATE_VERSION < OPTIONS_MINIMUM_VERSION) \
- || (AO_TEMPLATE_VERSION > OPTIONS_STRUCT_VERSION)
-# error option template version mismatches autoopts/options.h header
- Choke Me.
-#endif
-
-/*
- * Enumeration of each option:
- */
-typedef enum {
- INDEX_OPT_SCRIPT = 0,
- INDEX_OPT_SHELL = 1,
- INDEX_OPT_VERSION = 2,
- INDEX_OPT_HELP = 3,
- INDEX_OPT_MORE_HELP = 4
-} teOptIndex;
-
-#define OPTION_CT 5
-#define GENSHELLOPT_VERSION "1"
-#define GENSHELLOPT_FULL_VERSION "genshellopt - Generate Shell Option Processing Script - Ver. 1"
-
-/*
- * Interface defines for all options. Replace "n" with the UPPER_CASED
- * option name (as in the teOptIndex enumeration above).
- * e.g. HAVE_OPT( SCRIPT )
- */
-#define DESC(n) (genshelloptOptions.pOptDesc[INDEX_OPT_## n])
-#define HAVE_OPT(n) (! UNUSED_OPT(& DESC(n)))
-#define OPT_ARG(n) (DESC(n).optArg.argString)
-#define STATE_OPT(n) (DESC(n).fOptState & OPTST_SET_MASK)
-#define COUNT_OPT(n) (DESC(n).optOccCt)
-#define ISSEL_OPT(n) (SELECTED_OPT(&DESC(n)))
-#define ISUNUSED_OPT(n) (UNUSED_OPT(& DESC(n)))
-#define ENABLED_OPT(n) (! DISABLED_OPT(& DESC(n)))
-#define STACKCT_OPT(n) (((tArgList*)(DESC(n).optCookie))->useCt)
-#define STACKLST_OPT(n) (((tArgList*)(DESC(n).optCookie))->apzArgs)
-#define CLEAR_OPT(n) STMTS( \
- DESC(n).fOptState &= OPTST_PERSISTENT_MASK; \
- if ( (DESC(n).fOptState & OPTST_INITENABLED) == 0) \
- DESC(n).fOptState |= OPTST_DISABLED; \
- DESC(n).optCookie = NULL )
-
-/* * * * * *
- *
- * Interface defines for specific options.
- */
-#define VALUE_OPT_SCRIPT 'o'
-#define VALUE_OPT_SHELL 's'
-#define VALUE_OPT_HELP '?'
-#define VALUE_OPT_MORE_HELP '!'
-#define VALUE_OPT_VERSION 'v'
-/*
- * Interface defines not associated with particular options
- */
-#define ERRSKIP_OPTERR STMTS( genshelloptOptions.fOptSet &= ~OPTPROC_ERRSTOP )
-#define ERRSTOP_OPTERR STMTS( genshelloptOptions.fOptSet |= OPTPROC_ERRSTOP )
-#define RESTART_OPT(n) STMTS( \
- genshelloptOptions.curOptIdx = (n); \
- genshelloptOptions.pzCurOpt = NULL )
-#define START_OPT RESTART_OPT(1)
-#define USAGE(c) (*genshelloptOptions.pUsageProc)( &genshelloptOptions, c )
-/* extracted from opthead.tpl near line 409 */
-
-/* * * * * *
- *
- * Declare the genshellopt option descriptor.
- */
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-extern tOptions genshelloptOptions;
-
-#if defined(ENABLE_NLS)
-# ifndef _
-# include <stdio.h>
- static inline char* aoGetsText( char const* pz ) {
- if (pz == NULL) return NULL;
- return (char*)gettext( pz );
- }
-# define _(s) aoGetsText(s)
-# endif /* _() */
-
-# define OPT_NO_XLAT_CFG_NAMES STMTS(genshelloptOptions.fOptSet |= \
- OPTPROC_NXLAT_OPT_CFG;)
-# define OPT_NO_XLAT_OPT_NAMES STMTS(genshelloptOptions.fOptSet |= \
- OPTPROC_NXLAT_OPT|OPTPROC_NXLAT_OPT_CFG;)
-
-# define OPT_XLAT_CFG_NAMES STMTS(genshelloptOptions.fOptSet &= \
- ~(OPTPROC_NXLAT_OPT|OPTPROC_NXLAT_OPT_CFG);)
-# define OPT_XLAT_OPT_NAMES STMTS(genshelloptOptions.fOptSet &= \
- ~OPTPROC_NXLAT_OPT;)
-
-#else /* ENABLE_NLS */
-# define OPT_NO_XLAT_CFG_NAMES
-# define OPT_NO_XLAT_OPT_NAMES
-
-# define OPT_XLAT_CFG_NAMES
-# define OPT_XLAT_OPT_NAMES
-
-# ifndef _
-# define _(_s) _s
-# endif
-#endif /* ENABLE_NLS */
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* AUTOOPTS_GENSHELL_H_GUARD */
-/* genshell.h ends here */
+++ /dev/null
-#define AUTOOPTS_INTERNAL
-#include "compat/compat.h"
-#define LOCAL static
-#include "autoopts/options.h"
-#include "autoopts/usage-txt.h"
-#include "genshell.h"
-#include "xat-attribute.h"
-#include "value-type.h"
-#include "ag-char-map.h"
-#include "autoopts.h"
-#include "proto.h"
-#include "value-type.c"
-#include "xat-attribute.c"
-#include "autoopts.c"
-#include "boolean.c"
-#include "configfile.c"
-#include "cook.c"
-#include "enumeration.c"
-#include "environment.c"
-#include "file.c"
-#include "genshell.c"
-#include "load.c"
-#include "makeshell.c"
-#include "nested.c"
-#include "numeric.c"
-#include "pgusage.c"
-#include "putshell.c"
-#include "reset.c"
-#include "restore.c"
-#include "save.c"
-#include "sort.c"
-#include "stack.c"
-#include "streqvcmp.c"
-#include "text_mmap.c"
-#include "tokenize.c"
-#include "time.c"
-#include "usage.c"
-#include "version.c"
+++ /dev/null
-
-/*
- * $Id: f0ececd5fec43bacb417d7b50294accc2121923f $
- * Time-stamp: "2008-12-06 10:16:05 bkorb"
- *
- * This file contains the routines that deal with processing text strings
- * for options, either from a NUL-terminated string passed in or from an
- * rc/ini file.
- *
- * This file is part of AutoOpts, a companion to AutoGen.
- * AutoOpts is free software.
- * AutoOpts is copyright (c) 1992-2009 by Bruce Korb - all rights reserved
- *
- * AutoOpts is available under any one of two licenses. The license
- * in use must be one of these two and the choice is under the control
- * of the user of the license.
- *
- * The GNU Lesser General Public License, version 3 or later
- * See the files "COPYING.lgplv3" and "COPYING.gplv3"
- *
- * The Modified Berkeley Software Distribution License
- * See the file "COPYING.mbsd"
- *
- * These files have the following md5sums:
- *
- * 43b91e8ca915626ed3818ffb1b71248b pkg/libopts/COPYING.gplv3
- * 06a1a2e4760c90ea5e1dad8dfaac4d39 pkg/libopts/COPYING.lgplv3
- * 66a5cedaf62c4b2637025f049f9b826f pkg/libopts/COPYING.mbsd
- */
-
-tOptionLoadMode option_load_mode = OPTION_LOAD_UNCOOKED;
-
-/* = = = START-STATIC-FORWARD = = = */
-/* static forward declarations maintained by mk-fwd */
-static ag_bool
-insertProgramPath(
- char* pzBuf,
- int bufSize,
- tCC* pzName,
- tCC* pzProgPath );
-
-static ag_bool
-insertEnvVal(
- char* pzBuf,
- int bufSize,
- tCC* pzName,
- tCC* pzProgPath );
-
-static char*
-assembleArgValue( char* pzTxt, tOptionLoadMode mode );
-/* = = = END-STATIC-FORWARD = = = */
-
-/*=export_func optionMakePath
- * private:
- *
- * what: translate and construct a path
- * arg: + char* + pzBuf + The result buffer +
- * arg: + int + bufSize + The size of this buffer +
- * arg: + char const* + pzName + The input name +
- * arg: + char const* + pzProgPath + The full path of the current program +
- *
- * ret-type: ag_bool
- * ret-desc: AG_TRUE if the name was handled, otherwise AG_FALSE.
- * If the name does not start with ``$'', then it is handled
- * simply by copying the input name to the output buffer and
- * resolving the name with either
- * @code{canonicalize_file_name(3GLIBC)} or @code{realpath(3C)}.
- *
- * doc:
- *
- * This routine will copy the @code{pzName} input name into the @code{pzBuf}
- * output buffer, carefully not exceeding @code{bufSize} bytes. If the
- * first character of the input name is a @code{'$'} character, then there
- * is special handling:
- * @*
- * @code{$$} is replaced with the directory name of the @code{pzProgPath},
- * searching @code{$PATH} if necessary.
- * @*
- * @code{$@} is replaced with the AutoGen package data installation directory
- * (aka @code{pkgdatadir}).
- * @*
- * @code{$NAME} is replaced by the contents of the @code{NAME} environment
- * variable. If not found, the search fails.
- *
- * Please note: both @code{$$} and @code{$NAME} must be at the start of the
- * @code{pzName} string and must either be the entire string or be followed
- * by the @code{'/'} (backslash on windows) character.
- *
- * err: @code{AG_FALSE} is returned if:
- * @*
- * @bullet{} The input name exceeds @code{bufSize} bytes.
- * @*
- * @bullet{} @code{$$}, @code{$@@} or @code{$NAME} is not the full string
- * and the next character is not '/'.
- * @*
- * @bullet{} libopts was built without PKGDATADIR defined and @code{$@@}
- * was specified.
- * @*
- * @bullet{} @code{NAME} is not a known environment variable
- * @*
- * @bullet{} @code{canonicalize_file_name} or @code{realpath} return
- * errors (cannot resolve the resulting path).
-=*/
-ag_bool
-optionMakePath(
- char* pzBuf,
- int bufSize,
- tCC* pzName,
- tCC* pzProgPath )
-{
- size_t name_len = strlen( pzName );
-
-# ifndef PKGDATADIR
-# define PKGDATADIR ""
-# endif
-
- tSCC pkgdatadir[] = PKGDATADIR;
-
- ag_bool res = AG_TRUE;
-
- if (bufSize <= name_len)
- return AG_FALSE;
-
- /*
- * IF not an environment variable, just copy the data
- */
- if (*pzName != '$') {
- tCC* pzS = pzName;
- char* pzD = pzBuf;
- int ct = bufSize;
-
- for (;;) {
- if ( (*(pzD++) = *(pzS++)) == NUL)
- break;
- if (--ct <= 0)
- return AG_FALSE;
- }
- }
-
- /*
- * IF the name starts with "$$", then it must be "$$" or
- * it must start with "$$/". In either event, replace the "$$"
- * with the path to the executable and append a "/" character.
- */
- else switch (pzName[1]) {
- case NUL:
- return AG_FALSE;
-
- case '$':
- res = insertProgramPath( pzBuf, bufSize, pzName, pzProgPath );
- break;
-
- case '@':
- if (pkgdatadir[0] == NUL)
- return AG_FALSE;
-
- if (name_len + sizeof (pkgdatadir) > bufSize)
- return AG_FALSE;
-
- strcpy(pzBuf, pkgdatadir);
- strcpy(pzBuf + sizeof(pkgdatadir) - 1, pzName + 2);
- break;
-
- default:
- res = insertEnvVal( pzBuf, bufSize, pzName, pzProgPath );
- }
-
- if (! res)
- return AG_FALSE;
-
-#if defined(HAVE_CANONICALIZE_FILE_NAME)
- {
- char* pz = canonicalize_file_name(pzBuf);
- if (pz == NULL)
- return AG_FALSE;
- if (strlen(pz) < bufSize)
- strcpy(pzBuf, pz);
- free(pz);
- }
-
-#elif defined(HAVE_REALPATH)
- {
- char z[ PATH_MAX+1 ];
-
- if (realpath( pzBuf, z ) == NULL)
- return AG_FALSE;
-
- if (strlen(z) < bufSize)
- strcpy( pzBuf, z );
- }
-#endif
-
- return AG_TRUE;
-}
-
-
-static ag_bool
-insertProgramPath(
- char* pzBuf,
- int bufSize,
- tCC* pzName,
- tCC* pzProgPath )
-{
- tCC* pzPath;
- tCC* pz;
- int skip = 2;
-
- switch (pzName[2]) {
- case DIRCH:
- skip = 3;
- case NUL:
- break;
- default:
- return AG_FALSE;
- }
-
- /*
- * See if the path is included in the program name.
- * If it is, we're done. Otherwise, we have to hunt
- * for the program using "pathfind".
- */
- if (strchr( pzProgPath, DIRCH ) != NULL)
- pzPath = pzProgPath;
- else {
- pzPath = pathfind( getenv( "PATH" ), (char*)pzProgPath, "rx" );
-
- if (pzPath == NULL)
- return AG_FALSE;
- }
-
- pz = strrchr( pzPath, DIRCH );
-
- /*
- * IF we cannot find a directory name separator,
- * THEN we do not have a path name to our executable file.
- */
- if (pz == NULL)
- return AG_FALSE;
-
- pzName += skip;
-
- /*
- * Concatenate the file name to the end of the executable path.
- * The result may be either a file or a directory.
- */
- if ((pz - pzPath)+1 + strlen(pzName) >= bufSize)
- return AG_FALSE;
-
- memcpy( pzBuf, pzPath, (size_t)((pz - pzPath)+1) );
- strcpy( pzBuf + (pz - pzPath) + 1, pzName );
-
- /*
- * If the "pzPath" path was gotten from "pathfind()", then it was
- * allocated and we need to deallocate it.
- */
- if (pzPath != pzProgPath)
- AGFREE(pzPath);
- return AG_TRUE;
-}
-
-
-static ag_bool
-insertEnvVal(
- char* pzBuf,
- int bufSize,
- tCC* pzName,
- tCC* pzProgPath )
-{
- char* pzDir = pzBuf;
-
- for (;;) {
- int ch = (int)*++pzName;
- if (! IS_VALUE_NAME_CHAR(ch))
- break;
- *(pzDir++) = (char)ch;
- }
-
- if (pzDir == pzBuf)
- return AG_FALSE;
-
- *pzDir = NUL;
-
- pzDir = getenv( pzBuf );
-
- /*
- * Environment value not found -- skip the home list entry
- */
- if (pzDir == NULL)
- return AG_FALSE;
-
- if (strlen( pzDir ) + 1 + strlen( pzName ) >= bufSize)
- return AG_FALSE;
-
- sprintf( pzBuf, "%s%s", pzDir, pzName );
- return AG_TRUE;
-}
-
-
-LOCAL void
-mungeString( char* pzTxt, tOptionLoadMode mode )
-{
- char* pzE;
-
- if (mode == OPTION_LOAD_KEEP)
- return;
-
- if (IS_WHITESPACE_CHAR(*pzTxt)) {
- char* pzS = pzTxt;
- char* pzD = pzTxt;
- while (IS_WHITESPACE_CHAR(*++pzS)) ;
- while ((*(pzD++) = *(pzS++)) != NUL) ;
- pzE = pzD-1;
- } else
- pzE = pzTxt + strlen( pzTxt );
-
- while ((pzE > pzTxt) && IS_WHITESPACE_CHAR(pzE[-1])) pzE--;
- *pzE = NUL;
-
- if (mode == OPTION_LOAD_UNCOOKED)
- return;
-
- switch (*pzTxt) {
- default: return;
- case '"':
- case '\'': break;
- }
-
- switch (pzE[-1]) {
- default: return;
- case '"':
- case '\'': break;
- }
-
- (void)ao_string_cook( pzTxt, NULL );
-}
-
-
-static char*
-assembleArgValue( char* pzTxt, tOptionLoadMode mode )
-{
- tSCC zBrk[] = " \t\n:=";
- char* pzEnd = strpbrk( pzTxt, zBrk );
- int space_break;
-
- /*
- * Not having an argument to a configurable name is okay.
- */
- if (pzEnd == NULL)
- return pzTxt + strlen(pzTxt);
-
- /*
- * If we are keeping all whitespace, then the modevalue starts with the
- * character that follows the end of the configurable name, regardless
- * of which character caused it.
- */
- if (mode == OPTION_LOAD_KEEP) {
- *(pzEnd++) = NUL;
- return pzEnd;
- }
-
- /*
- * If the name ended on a white space character, remember that
- * because we'll have to skip over an immediately following ':' or '='
- * (and the white space following *that*).
- */
- space_break = IS_WHITESPACE_CHAR(*pzEnd);
- *(pzEnd++) = NUL;
- while (IS_WHITESPACE_CHAR(*pzEnd)) pzEnd++;
- if (space_break && ((*pzEnd == ':') || (*pzEnd == '=')))
- while (IS_WHITESPACE_CHAR(*++pzEnd)) ;
-
- return pzEnd;
-}
-
-
-/*
- * Load an option from a block of text. The text must start with the
- * configurable/option name and be followed by its associated value.
- * That value may be processed in any of several ways. See "tOptionLoadMode"
- * in autoopts.h.
- */
-LOCAL void
-loadOptionLine(
- tOptions* pOpts,
- tOptState* pOS,
- char* pzLine,
- tDirection direction,
- tOptionLoadMode load_mode )
-{
- while (IS_WHITESPACE_CHAR(*pzLine)) pzLine++;
-
- {
- char* pzArg = assembleArgValue( pzLine, load_mode );
-
- if (! SUCCESSFUL( longOptionFind( pOpts, pzLine, pOS )))
- return;
- if (pOS->flags & OPTST_NO_INIT)
- return;
- pOS->pzOptArg = pzArg;
- }
-
- switch (pOS->flags & (OPTST_IMM|OPTST_DISABLE_IMM)) {
- case 0:
- /*
- * The selected option has no immediate action.
- * THEREFORE, if the direction is PRESETTING
- * THEN we skip this option.
- */
- if (PRESETTING(direction))
- return;
- break;
-
- case OPTST_IMM:
- if (PRESETTING(direction)) {
- /*
- * We are in the presetting direction with an option we handle
- * immediately for enablement, but normally for disablement.
- * Therefore, skip if disabled.
- */
- if ((pOS->flags & OPTST_DISABLED) == 0)
- return;
- } else {
- /*
- * We are in the processing direction with an option we handle
- * immediately for enablement, but normally for disablement.
- * Therefore, skip if NOT disabled.
- */
- if ((pOS->flags & OPTST_DISABLED) != 0)
- return;
- }
- break;
-
- case OPTST_DISABLE_IMM:
- if (PRESETTING(direction)) {
- /*
- * We are in the presetting direction with an option we handle
- * immediately for disablement, but normally for disablement.
- * Therefore, skip if NOT disabled.
- */
- if ((pOS->flags & OPTST_DISABLED) != 0)
- return;
- } else {
- /*
- * We are in the processing direction with an option we handle
- * immediately for disablement, but normally for disablement.
- * Therefore, skip if disabled.
- */
- if ((pOS->flags & OPTST_DISABLED) == 0)
- return;
- }
- break;
-
- case OPTST_IMM|OPTST_DISABLE_IMM:
- /*
- * The selected option is always for immediate action.
- * THEREFORE, if the direction is PROCESSING
- * THEN we skip this option.
- */
- if (PROCESSING(direction))
- return;
- break;
- }
-
- /*
- * Fix up the args.
- */
- if (OPTST_GET_ARGTYPE(pOS->pOD->fOptState) == OPARG_TYPE_NONE) {
- if (*pOS->pzOptArg != NUL)
- return;
- pOS->pzOptArg = NULL;
-
- } else if (pOS->pOD->fOptState & OPTST_ARG_OPTIONAL) {
- if (*pOS->pzOptArg == NUL)
- pOS->pzOptArg = NULL;
- else {
- AGDUPSTR( pOS->pzOptArg, pOS->pzOptArg, "option argument" );
- pOS->flags |= OPTST_ALLOC_ARG;
- }
-
- } else {
- if (*pOS->pzOptArg == NUL)
- pOS->pzOptArg = zNil;
- else {
- AGDUPSTR( pOS->pzOptArg, pOS->pzOptArg, "option argument" );
- pOS->flags |= OPTST_ALLOC_ARG;
- }
- }
-
- {
- tOptionLoadMode sv = option_load_mode;
- option_load_mode = load_mode;
- handleOption( pOpts, pOS );
- option_load_mode = sv;
- }
-}
-
-
-/*=export_func optionLoadLine
- *
- * what: process a string for an option name and value
- *
- * arg: tOptions*, pOpts, program options descriptor
- * arg: char const*, pzLine, NUL-terminated text
- *
- * doc:
- *
- * This is a client program callable routine for setting options from, for
- * example, the contents of a file that they read in. Only one option may
- * appear in the text. It will be treated as a normal (non-preset) option.
- *
- * When passed a pointer to the option struct and a string, it will find
- * the option named by the first token on the string and set the option
- * argument to the remainder of the string. The caller must NUL terminate
- * the string. Any embedded new lines will be included in the option
- * argument. If the input looks like one or more quoted strings, then the
- * input will be "cooked". The "cooking" is identical to the string
- * formation used in AutoGen definition files (@pxref{basic expression}),
- * except that you may not use backquotes.
- *
- * err: Invalid options are silently ignored. Invalid option arguments
- * will cause a warning to print, but the function should return.
-=*/
-void
-optionLoadLine(
- tOptions* pOpts,
- tCC* pzLine )
-{
- tOptState st = OPTSTATE_INITIALIZER(SET);
- char* pz;
- AGDUPSTR( pz, pzLine, "user option line" );
- loadOptionLine( pOpts, &st, pz, DIRECTION_PROCESS, OPTION_LOAD_COOKED );
- AGFREE( pz );
-}
-/*
- * Local Variables:
- * mode: C
- * c-file-style: "stroustrup"
- * indent-tabs-mode: nil
- * End:
- * end of autoopts/load.c */
+++ /dev/null
-dnl -*- buffer-read-only: t -*- vi: set ro:
-dnl
-dnl DO NOT EDIT THIS FILE (libopts.m4)
-dnl
-dnl It has been AutoGen-ed November 8, 2009 at 08:41:10 AM by AutoGen 5.9.10pre13
-dnl From the definitions libopts.def
-dnl and the template file conftest.tpl
-dnl
-dnl do always before generated macros:
-dnl
-AC_DEFUN([INVOKE_LIBOPTS_MACROS_FIRST],[
-[if test X${INVOKE_LIBOPTS_MACROS_FIRST_done} != Xyes ; then]
- AC_HEADER_STDC
- AC_HEADER_DIRENT
-
- # =================
- # AC_CHECK_HEADERS
- # =================
- AC_CHECK_HEADERS(dlfcn.h errno.h fcntl.h libgen.h memory.h netinet/in.h \
- setjmp.h sys/mman.h sys/param.h sys/poll.h sys/procset.h sys/select.h \
- sys/socket.h sys/stropts.h sys/time.h sys/un.h sys/wait.h unistd.h \
- utime.h sysexits.h)
-
- # --------------------------------------------
- # Verify certain entries from AC_CHECK_HEADERS
- # --------------------------------------------
- [for f in sys_types sys_mman sys_param sys_stat sys_wait \
- string errno stdlib memory setjmp
- do eval as_ac_var=\${ac_cv_header_${f}_h+set}
- test "${as_ac_var}" = set] || \
- AC_MSG_ERROR([You must have ${f}.h on your system])
- done
-
- # ================================================
- # AC_CHECK_HEADERS: stdarg.h is present define HAVE_STDARG_H, otherwise
- # if varargs.h is present define HAVE_VARARGS_H.
- # ================================================
- AC_CHECK_HEADERS(stdarg.h varargs.h, break)
- [if test `eval echo '${'$as_ac_Header'}'` != yes; then]
- AC_MSG_ERROR([You must have stdarg.h or varargs.h on your system])
- fi
-
- # ================================================
- # Similarly for the string.h and strings.h headers
- # ================================================
- AC_CHECK_HEADERS(string.h strings.h, break)
- [if test `eval echo '${'$as_ac_Header'}'` != yes; then]
- AC_MSG_ERROR([You must have string.h or strings.h on your system])
- fi
-
- # =====================
- # ...and limits headers
- # =====================
- AC_CHECK_HEADERS(limits.h sys/limits.h values.h, break)
- [if test `eval echo '${'$as_ac_Header'}'` != yes; then]
- AC_MSG_ERROR([You must have one of limits.h, sys/limits.h or values.h])
- fi
-
- # ----------------------------------------------------------------------
- # check for various programs used during the build.
- # On OS/X, "wchar.h" needs "runetype.h" to work properly.
- # ----------------------------------------------------------------------
- AC_CHECK_HEADERS([runetype.h wchar.h], [], [],[
- AC_INCLUDES_DEFAULT
- #if HAVE_RUNETYPE_H
- # include <runetype.h>
- #endif
- ])
-
- # ----------------------------------------------------------------------
- # Checks for typedefs
- # ----------------------------------------------------------------------
- AC_CHECK_TYPES(wchar_t)
- AC_CHECK_TYPES(wint_t, [], [], [
- AC_INCLUDES_DEFAULT
- #if HAVE_RUNETYPE_H
- # include <runetype.h>
- #endif
- #if HAVE_WCHAR_H
- # include <wchar.h>
- #endif
- ])
-
- # ========================
- # ...and int types headers
- # ========================
- AC_CHECK_HEADERS(stdint.h inttypes.h, break)
- AC_CHECK_TYPES([int8_t, uint8_t, int16_t, uint16_t, int32_t, uint32_t,
- intptr_t, uintptr_t, uint_t, pid_t, size_t])
-
- # =====
- # sizes
- # =====
- AC_CHECK_SIZEOF(char*, 4)
- AC_CHECK_SIZEOF(int, 4)
- AC_CHECK_SIZEOF(long, 4)
- AC_CHECK_SIZEOF(short, 2)
-
- # ----------------------------------------------------------------------
- # AC_CHECK_LIB for SVR4 libgen, and use it if it defines pathfind.
- # ----------------------------------------------------------------------
- AC_CHECK_LIB(gen, pathfind)
- AC_FUNC_VPRINTF
- AC_FUNC_FORK
- AC_CHECK_FUNCS([mmap canonicalize_file_name snprintf strdup strchr \
- strrchr strsignal])
-[ INVOKE_LIBOPTS_MACROS_FIRST_done=yes
-fi]])
-
-dnl
-dnl @synopsis INVOKE_LIBOPTS_MACROS
-dnl
-dnl This macro will invoke the AutoConf macros specified in libopts.def
-dnl that have not been disabled with "omit-invocation".
-dnl
-AC_DEFUN([LIBOPTS_WITH_REGEX_HEADER],[
- AC_ARG_WITH([regex-header],
- AC_HELP_STRING([--with-regex-header], [a reg expr header is specified]),
- [libopts_cv_with_regex_header=${with_regex_header}],
- AC_CACHE_CHECK([whether a reg expr header is specified], libopts_cv_with_regex_header,
- libopts_cv_with_regex_header=no)
- ) # end of AC_ARG_WITH
-
- if test "X${libopts_cv_with_regex_header}" != Xno
- then
- AC_DEFINE_UNQUOTED([REGEX_HEADER],[<${libopts_cv_with_regex_header}>])
- else
- AC_DEFINE([REGEX_HEADER],[<regex.h>],[name of regex header file])
- fi
-
-]) # end of AC_DEFUN of LIBOPTS_WITH_REGEX_HEADER
-
-
-AC_DEFUN([LIBOPTS_WITHLIB_REGEX],[
- AC_ARG_WITH([libregex],
- AC_HELP_STRING([--with-libregex], [libregex installation prefix]),
- [libopts_cv_with_libregex_root=${with_libregex}],
- AC_CACHE_CHECK([whether with-libregex was specified], libopts_cv_with_libregex_root,
- libopts_cv_with_libregex_root=no)
- ) # end of AC_ARG_WITH libregex
-
- if test "${with_libguile+set}" = set && \
- test "${withval}" = no
- then ## disabled by request
- libopts_cv_with_libregex_root=no
- libopts_cv_with_libregex_cflags=no
- libopts_cv_with_libregex_libs=no
- else
-
- AC_ARG_WITH([libregex-cflags],
- AC_HELP_STRING([--with-libregex-cflags], [libregex compile flags]),
- [libopts_cv_with_libregex_cflags=${with_regex_cflags}],
- AC_CACHE_CHECK([whether with-libregex-cflags was specified], libopts_cv_with_libregex_cflags,
- libopts_cv_with_libregex_cflags=no)
- ) # end of AC_ARG_WITH libregex-cflags
-
- AC_ARG_WITH([libregex-libs],
- AC_HELP_STRING([--with-libregex-libs], [libregex link command arguments]),
- [libopts_cv_with_libregex_libs=${with_regex_libs}],
- AC_CACHE_CHECK([whether with-libregex-libs was specified], libopts_cv_with_libregex_libs,
- libopts_cv_with_libregex_libs=no)
- ) # end of AC_ARG_WITH libregex-libs
-
- case "X${libopts_cv_with_libregex_cflags}" in
- Xyes|Xno|X )
- case "X${libopts_cv_with_libregex_root}" in
- Xyes|Xno|X ) libopts_cv_with_libregex_cflags=no ;;
- * ) libopts_cv_with_libregex_cflags=-I${libopts_cv_with_libregex_root}/include ;;
- esac
- esac
- case "X${libopts_cv_with_libregex_libs}" in
- Xyes|Xno|X )
- case "X${libopts_cv_with_libregex_root}" in
- Xyes|Xno|X ) libopts_cv_with_libregex_libs=no ;;
- * ) libopts_cv_with_libregex_libs="-L${libopts_cv_with_libregex_root}/lib -lregex";;
- esac
- esac
- libopts_save_CPPFLAGS="${CPPFLAGS}"
- libopts_save_LIBS="${LIBS}"
- fi ## disabled by request
-
- case "X${libopts_cv_with_libregex_cflags}" in
- Xyes|Xno|X )
- libopts_cv_with_libregex_cflags="" ;;
- * ) CPPFLAGS="${CPPFLAGS} ${libopts_cv_with_libregex_cflags}" ;;
- esac
- case "X${libopts_cv_with_libregex_libs}" in
- Xyes|Xno|X )
- libopts_cv_with_libregex_libs="" ;;
- * )
- LIBS="${LIBS} ${libopts_cv_with_libregex_libs}" ;;
- esac
- LIBREGEX_CFLAGS=""
- LIBREGEX_LIBS=""
- AC_MSG_CHECKING([whether libregex functions properly])
- AC_CACHE_VAL([libopts_cv_with_libregex],[
- AC_TRY_RUN([@%:@include <stdio.h>
-@%:@include <stdlib.h>
-@%:@include <sys/types.h>
-@%:@include REGEX_HEADER
-static regex_t re;
-void comp_re( char const* pzPat ) {
- int res = regcomp( &re, pzPat, REG_EXTENDED|REG_ICASE|REG_NEWLINE );
- if (res == 0) return;
- exit( res ); }
-int main() {
- regmatch_t m@<:@2@:>@;
- comp_re( "^.*\@S|@" );
- comp_re( "()|no.*" );
- comp_re( "." );
- if (regexec( &re, "X", 2, m, 0 ) != 0) return 1;
- if ((m@<:@0@:>@.rm_so != 0) || (m@<:@0@:>@.rm_eo != 1)) {
- fputs( "error: regex -->.<-- did not match\n", stderr );
- return 1;
- }
- return 0; }],
- [libopts_cv_with_libregex=yes], [libopts_cv_with_libregex=no],
- [libopts_cv_with_libregex=no]) # end of AC_TRY_RUN
- ]) # end of AC_CACHE_VAL for libopts_cv_with_libregex
- AC_MSG_RESULT([${libopts_cv_with_libregex}])
-
- if test "X${libopts_cv_with_libregex}" != Xno
- then
- AC_DEFINE([WITH_LIBREGEX],[1],
- [Define this if a working libregex can be found])
- else
- CPPFLAGS="${libopts_save_CPPFLAGS}"
- LIBS="${libopts_save_LIBS}"
- fi
-
-]) # end of AC_DEFUN of LIBOPTS_WITHLIB_REGEX
-
-
-AC_DEFUN([LIBOPTS_RUN_PATHFIND],[
- AC_MSG_CHECKING([whether pathfind(3) works])
- AC_CACHE_VAL([libopts_cv_run_pathfind],[
- AC_TRY_RUN([@%:@include <string.h>
-@%:@include <stdlib.h>
-int main (int argc, char** argv) {
- char* pz = pathfind( getenv( "PATH" ), "sh", "x" );
- return (pz == 0) ? 1 : 0;
-}],
- [libopts_cv_run_pathfind=yes],[libopts_cv_run_pathfind=no],[libopts_cv_run_pathfind=no]
- ) # end of TRY_RUN
- ]) # end of AC_CACHE_VAL for libopts_cv_run_pathfind
- AC_MSG_RESULT([${libopts_cv_run_pathfind}])
-
- if test "X${libopts_cv_run_pathfind}" != Xno
- then
- AC_DEFINE([HAVE_PATHFIND],[1],
- [Define this if pathfind(3) works])
- fi
-
-]) # end of AC_DEFUN of LIBOPTS_RUN_PATHFIND
-
-
-AC_DEFUN([LIBOPTS_TEST_DEV_ZERO],[
- AC_MSG_CHECKING([whether /dev/zero is readable device])
- AC_CACHE_VAL([libopts_cv_test_dev_zero],[
- libopts_cv_test_dev_zero=`exec 2> /dev/null
-dzero=\`ls -lL /dev/zero | egrep ^c......r\`
-test -z "${dzero}" && exit 1
-echo ${dzero}`
- if test $? -ne 0
- then libopts_cv_test_dev_zero=no
- elif test -z "$libopts_cv_test_dev_zero"
- then libopts_cv_test_dev_zero=no
- fi
- ]) # end of CACHE_VAL of libopts_cv_test_dev_zero
- AC_MSG_RESULT([${libopts_cv_test_dev_zero}])
-
- if test "X${libopts_cv_test_dev_zero}" != Xno
- then
- AC_DEFINE([HAVE_DEV_ZERO],[1],
- [Define this if /dev/zero is readable device])
- fi
-
-]) # end of AC_DEFUN of LIBOPTS_TEST_DEV_ZERO
-
-
-AC_DEFUN([LIBOPTS_RUN_REALPATH],[
- AC_MSG_CHECKING([whether we have a functional realpath(3C)])
- AC_CACHE_VAL([libopts_cv_run_realpath],[
- AC_TRY_RUN([@%:@include <limits.h>
-@%:@include <stdlib.h>
-int main (int argc, char** argv) {
-@%:@ifndef PATH_MAX
-choke me!!
-@%:@else
- char zPath@<:@PATH_MAX+1@:>@;
-@%:@endif
- char *pz = realpath(argv@<:@0@:>@, zPath);
- return (pz == zPath) ? 0 : 1;
-}],
- [libopts_cv_run_realpath=yes],[libopts_cv_run_realpath=no],[libopts_cv_run_realpath=no]
- ) # end of TRY_RUN
- ]) # end of AC_CACHE_VAL for libopts_cv_run_realpath
- AC_MSG_RESULT([${libopts_cv_run_realpath}])
-
- if test "X${libopts_cv_run_realpath}" != Xno
- then
- AC_DEFINE([HAVE_REALPATH],[1],
- [Define this if we have a functional realpath(3C)])
- fi
-
-]) # end of AC_DEFUN of LIBOPTS_RUN_REALPATH
-
-
-AC_DEFUN([LIBOPTS_RUN_STRFTIME],[
- AC_MSG_CHECKING([whether strftime() works])
- AC_CACHE_VAL([libopts_cv_run_strftime],[
- AC_TRY_RUN([@%:@include <time.h>
-@%:@include <string.h>
-char t_buf@<:@ 64 @:>@;
-int main() {
- static char const z@<:@@:>@ = "Thursday Aug 28 240";
- struct tm tm;
- tm.tm_sec = 36; /* seconds after the minute @<:@0, 61@:>@ */
- tm.tm_min = 44; /* minutes after the hour @<:@0, 59@:>@ */
- tm.tm_hour = 12; /* hour since midnight @<:@0, 23@:>@ */
- tm.tm_mday = 28; /* day of the month @<:@1, 31@:>@ */
- tm.tm_mon = 7; /* months since January @<:@0, 11@:>@ */
- tm.tm_year = 86; /* years since 1900 */
- tm.tm_wday = 4; /* days since Sunday @<:@0, 6@:>@ */
- tm.tm_yday = 239; /* days since January 1 @<:@0, 365@:>@ */
- tm.tm_isdst = 1; /* flag for daylight savings time */
- strftime( t_buf, sizeof( t_buf ), "%A %b %d %j", &tm );
- return (strcmp( t_buf, z ) != 0); }],
- [libopts_cv_run_strftime=yes],[libopts_cv_run_strftime=no],[libopts_cv_run_strftime=no]
- ) # end of TRY_RUN
- ]) # end of AC_CACHE_VAL for libopts_cv_run_strftime
- AC_MSG_RESULT([${libopts_cv_run_strftime}])
-
- if test "X${libopts_cv_run_strftime}" != Xno
- then
- AC_DEFINE([HAVE_STRFTIME],[1],
- [Define this if strftime() works])
- fi
-
-]) # end of AC_DEFUN of LIBOPTS_RUN_STRFTIME
-
-
-AC_DEFUN([LIBOPTS_RUN_FOPEN_BINARY],[
- AC_MSG_CHECKING([whether fopen accepts "b" mode])
- AC_CACHE_VAL([libopts_cv_run_fopen_binary],[
- AC_TRY_RUN([@%:@include <stdio.h>
-int main (int argc, char** argv) {
-FILE* fp = fopen("conftest.@S|@ac_ext", "rb");
-return (fp == NULL) ? 1 : fclose(fp); }],
- [libopts_cv_run_fopen_binary=yes],[libopts_cv_run_fopen_binary=no],[libopts_cv_run_fopen_binary=no]
- ) # end of TRY_RUN
- ]) # end of AC_CACHE_VAL for libopts_cv_run_fopen_binary
- AC_MSG_RESULT([${libopts_cv_run_fopen_binary}])
-
- if test "X${libopts_cv_run_fopen_binary}" != Xno
- then
- AC_DEFINE([FOPEN_BINARY_FLAG],"b",
- [fopen(3) accepts a 'b' in the mode flag])
- else
- AC_DEFINE([FOPEN_BINARY_FLAG],"",
- [fopen(3) accepts a 'b' in the mode flag])
- fi
-
-]) # end of AC_DEFUN of LIBOPTS_RUN_FOPEN_BINARY
-
-
-AC_DEFUN([LIBOPTS_RUN_FOPEN_TEXT],[
- AC_MSG_CHECKING([whether fopen accepts "t" mode])
- AC_CACHE_VAL([libopts_cv_run_fopen_text],[
- AC_TRY_RUN([@%:@include <stdio.h>
-int main (int argc, char** argv) {
-FILE* fp = fopen("conftest.@S|@ac_ext", "rt");
-return (fp == NULL) ? 1 : fclose(fp); }],
- [libopts_cv_run_fopen_text=yes],[libopts_cv_run_fopen_text=no],[libopts_cv_run_fopen_text=no]
- ) # end of TRY_RUN
- ]) # end of AC_CACHE_VAL for libopts_cv_run_fopen_text
- AC_MSG_RESULT([${libopts_cv_run_fopen_text}])
-
- if test "X${libopts_cv_run_fopen_text}" != Xno
- then
- AC_DEFINE([FOPEN_TEXT_FLAG],"t",
- [fopen(3) accepts a 't' in the mode flag])
- else
- AC_DEFINE([FOPEN_TEXT_FLAG],"",
- [fopen(3) accepts a 't' in the mode flag])
- fi
-
-]) # end of AC_DEFUN of LIBOPTS_RUN_FOPEN_TEXT
-
-
-AC_DEFUN([LIBOPTS_DISABLE_OPTIONAL_ARGS],[
- AC_ARG_ENABLE([optional-args],
- AC_HELP_STRING([--disable-optional-args], [not wanting optional option args]),
- [libopts_cv_enable_optional_args=${enable_optional_args}],
- AC_CACHE_CHECK([whether not wanting optional option args], libopts_cv_enable_optional_args,
- libopts_cv_enable_optional_args=yes)
- ) # end of AC_ARG_ENABLE
-
- if test "X${libopts_cv_enable_optional_args}" = Xno
- then
- AC_DEFINE([NO_OPTIONAL_OPT_ARGS], [1],
- [Define this if optional arguments are disallowed])
- fi
-
-]) # end of AC_DEFUN of LIBOPTS_DISABLE_OPTIONAL_ARGS
-
-
-AC_DEFUN([INVOKE_LIBOPTS_MACROS],[
- INVOKE_LIBOPTS_MACROS_FIRST
- # Check to see if a reg expr header is specified.
- LIBOPTS_WITH_REGEX_HEADER
-
- # Check to see if a working libregex can be found.
- LIBOPTS_WITHLIB_REGEX
-
- # Check to see if pathfind(3) works.
- LIBOPTS_RUN_PATHFIND
-
- # Check to see if /dev/zero is readable device.
- LIBOPTS_TEST_DEV_ZERO
-
- # Check to see if we have a functional realpath(3C).
- LIBOPTS_RUN_REALPATH
-
- # Check to see if strftime() works.
- LIBOPTS_RUN_STRFTIME
-
- # Check to see if fopen accepts "b" mode.
- LIBOPTS_RUN_FOPEN_BINARY
-
- # Check to see if fopen accepts "t" mode.
- LIBOPTS_RUN_FOPEN_TEXT
-
- # Check to see if not wanting optional option args.
- LIBOPTS_DISABLE_OPTIONAL_ARGS
-
-]) # end AC_DEFUN of INVOKE_LIBOPTS_MACROS
-
-dnl @synopsis LIBOPTS_CHECK
-dnl
-dnl Time-stamp: "2009-07-22 18:50:49 bkorb"
-dnl
-dnl If autoopts-config works, add the linking information to LIBS.
-dnl Otherwise, add ``libopts-${ao_rev}'' to SUBDIRS and run all
-dnl the config tests that the library needs. Invoke the
-dnl "INVOKE_LIBOPTS_MACROS" macro iff we are building libopts.
-dnl
-dnl This file is part of AutoGen.
-dnl AutoGen copyright (c) 1992-2009 by Bruce Korb - all rights reserved
-dnl
-dnl AutoGen is free software: you can redistribute it and/or modify it
-dnl under the terms of the GNU General Public License as published by the
-dnl Free Software Foundation, either version 3 of the License, or
-dnl (at your option) any later version.
-dnl
-dnl AutoGen is distributed in the hope that it will be useful, but
-dnl WITHOUT ANY WARRANTY; without even the implied warranty of
-dnl MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-dnl See the GNU General Public License for more details.
-dnl
-dnl You should have received a copy of the GNU General Public License along
-dnl with this program. If not, see <http://www.gnu.org/licenses/>.
-dnl
-dnl Default to system libopts
-dnl
-AC_DEFUN([LIBOPTS_CHECK],[
- [NEED_LIBOPTS_DIR='']
- m4_pushdef([AO_Libopts_Dir],
- [ifelse($1, , [libopts], [$1])])
- AC_SUBST(LIBOPTS_DIR, AO_Libopts_Dir)
- AC_ARG_ENABLE([local-libopts],
- AC_HELP_STRING([--enable-local-libopts],
- [Force using the supplied libopts tearoff code]),[
- if test x$enableval = xyes ; then
- AC_MSG_NOTICE([Using supplied libopts tearoff])
- LIBOPTS_LDADD='$(top_builddir)/AO_Libopts_Dir/libopts.la'
- LIBOPTS_CFLAGS='-I$(top_srcdir)/AO_Libopts_Dir'
- NEED_LIBOPTS_DIR=true
- fi])
-
- AC_ARG_ENABLE([libopts-install],
- AC_HELP_STRING([--disable-libopts-install],
- [Do not install libopts with client installation]))
- AM_CONDITIONAL([INSTALL_LIBOPTS],[test "X${enable_libopts_install}" != Xno])
-
- [if test -z "${NEED_LIBOPTS_DIR}" ; then]
- AC_MSG_CHECKING([whether autoopts-config can be found])
- AC_ARG_WITH([autoopts-config],
- AC_HELP_STRING([--with-autoopts-config],
- [specify the config-info script]),
- [lo_cv_with_autoopts_config=${with_autoopts_config}],
- AC_CACHE_CHECK([whether autoopts-config is specified],
- [lo_cv_with_autoopts_config],
- [if autoopts-config --help 2>/dev/null 1>&2
- then lo_cv_with_autoopts_config=autoopts-config
- elif libopts-config --help 2>/dev/null 1>&2
- then lo_cv_with_autoopts_config=libopts-config
- else lo_cv_with_autoopts_config=no ; fi])
- ) # end of AC_ARG_WITH
-
- AC_CACHE_VAL([lo_cv_test_autoopts],[
- if test -z "${lo_cv_with_autoopts_config}" \
- -o X"${lo_cv_with_autoopts_config}" = Xno
- then
- if autoopts-config --help 2>/dev/null 1>&2
- then lo_cv_with_autoopts_config=autoopts-config
- elif libopts-config --help 2>/dev/null 1>&2
- then lo_cv_with_autoopts_config=libopts-config
- else lo_cv_with_autoopts_config=false ; fi
- fi
- lo_cv_test_autoopts=`
- ${lo_cv_with_autoopts_config} --libs` 2> /dev/null
- if test $? -ne 0 -o -z "${lo_cv_test_autoopts}"
- then lo_cv_test_autoopts=no ; fi
- ]) # end of CACHE_VAL
- AC_MSG_RESULT([${lo_cv_test_autoopts}])
-
- [if test "X${lo_cv_test_autoopts}" != Xno
- then
- LIBOPTS_LDADD="${lo_cv_test_autoopts}"
- LIBOPTS_CFLAGS="`${lo_cv_with_autoopts_config} --cflags`"
- else
- LIBOPTS_LDADD='$(top_builddir)/]AO_Libopts_Dir[/libopts.la'
- LIBOPTS_CFLAGS='-I$(top_srcdir)/]AO_Libopts_Dir['
- NEED_LIBOPTS_DIR=true
- fi
- fi # end of if test -z "${NEED_LIBOPTS_DIR}"]
-
- AM_CONDITIONAL([NEED_LIBOPTS], [test -n "${NEED_LIBOPTS_DIR}"])
- AC_SUBST(LIBOPTS_LDADD)
- AC_SUBST(LIBOPTS_CFLAGS)
- AC_SUBST(LIBOPTS_DIR, AO_Libopts_Dir)
- AC_CONFIG_FILES(AO_Libopts_Dir/Makefile)
- m4_popdef([AO_Libopts_Dir])
-
- [if test -n "${NEED_LIBOPTS_DIR}" ; then]
- INVOKE_LIBOPTS_MACROS
- else
- INVOKE_LIBOPTS_MACROS_FIRST
- [fi
-# end of AC_DEFUN of LIBOPTS_CHECK]
-])
+++ /dev/null
-# liboptschk.m4 serial 1 (autogen - 5.7.3)
-dnl copyright (c) 2005-2009 by Bruce Korb - all rights reserved
-dnl
-dnl This file is free software; the Free Software Foundation
-dnl gives unlimited permission to copy and/or distribute it,
-dnl with or without modifications, as long as this notice is preserved.
-
-dnl Time-stamp: "2009-07-22 18:53:27 bkorb"
-
-dnl This file can can be used in projects which are not available under
-dnl the GNU General Public License or the GNU Library General Public
-dnl License but which still want to provide support for the GNU gettext
-dnl functionality.
-dnl Please note that the actual code of the GNU gettext library is covered
-dnl by the GNU Library General Public License, and the rest of the GNU
-dnl gettext package package is covered by the GNU General Public License.
-dnl They are *not* in the public domain.
-
-dnl Authors:
-dnl Ulrich Drepper <drepper@cygnus.com>, 1995-2000.
-dnl Bruno Haible <haible@clisp.cons.org>, 2000-2003.
-
-AC_PREREQ(2.50)
-
-AC_DEFUN([ag_FIND_LIBOPTS],
- [if test "X${ac_cv_header_autoopts_options_h}" == Xno
- then
- :
- else
- f=`autoopts-config cflags` 2>/dev/null
- test X"${f}" = X && f=`libopts-config cflags` 2>/dev/null
- if test X"${f}" = X
- then
- :
- else
- AC_DEFINE([HAVE_LIBOPTS],[1],[define if we can find libopts])
- CFLAGS="${CFLAGS} ${f}"
- f=`autoopts-config ldflags` 2>/dev/null
- test X"${f}" = X && f=`libopts-config ldflags` 2>/dev/null
- LIBS="${LIBS} ${f}"
- fi
- fi])
+++ /dev/null
-
-/*
- * $Id: 7226344c6486a4eda395f893881080b7d80a2003 $
- * Time-stamp: "2009-11-01 11:52:37 bkorb"
- *
- * This module will interpret the options set in the tOptions
- * structure and create a Bourne shell script capable of parsing them.
- *
- * This file is part of AutoOpts, a companion to AutoGen.
- * AutoOpts is free software.
- * AutoOpts is copyright (c) 1992-2009 by Bruce Korb - all rights reserved
- *
- * AutoOpts is available under any one of two licenses. The license
- * in use must be one of these two and the choice is under the control
- * of the user of the license.
- *
- * The GNU Lesser General Public License, version 3 or later
- * See the files "COPYING.lgplv3" and "COPYING.gplv3"
- *
- * The Modified Berkeley Software Distribution License
- * See the file "COPYING.mbsd"
- *
- * These files have the following md5sums:
- *
- * 43b91e8ca915626ed3818ffb1b71248b pkg/libopts/COPYING.gplv3
- * 06a1a2e4760c90ea5e1dad8dfaac4d39 pkg/libopts/COPYING.lgplv3
- * 66a5cedaf62c4b2637025f049f9b826f pkg/libopts/COPYING.mbsd
- */
-
-tOptions* pShellParseOptions = NULL;
-
-/* * * * * * * * * * * * * * * * * * * * *
- *
- * Setup Format Strings
- */
-static char const zStartMarker[] =
-"# # # # # # # # # # -- do not modify this marker --\n#\n"
-"# DO NOT EDIT THIS SECTION";
-
-static char const zPreamble[] =
-"%s OF %s\n#\n"
-"# From here to the next `-- do not modify this marker --',\n"
-"# the text has been generated %s\n";
-
-static char const zEndPreamble[] =
-"# From the %s option definitions\n#\n";
-
-static char const zMultiDef[] = "\n"
-"if test -z \"${%1$s_%2$s}\"\n"
-"then\n"
-" %1$s_%2$s_CT=0\n"
-"else\n"
-" %1$s_%2$s_CT=1\n"
-" %1$s_%2$s_1=\"${%1$s_%2$s}\"\n"
-"fi\n"
-"export %1$s_%2$s_CT";
-
-static char const zSingleDef[] = "\n"
-"%1$s_%2$s=\"${%1$s_%2$s-'%3$s'}\"\n"
-"%1$s_%2$s_set=false\n"
-"export %1$s_%2$s\n";
-
-static char const zSingleNoDef[] = "\n"
-"%1$s_%2$s=\"${%1$s_%2$s}\"\n"
-"%1$s_%2$s_set=false\n"
-"export %1$s_%2$s\n";
-
-/* * * * * * * * * * * * * * * * * * * * *
- *
- * LOOP START
- *
- * The loop may run in either of two modes:
- * all options are named options (loop only)
- * regular, marked option processing.
- */
-static char const zLoopCase[] = "\n"
-"OPT_PROCESS=true\n"
-"OPT_ARG=\"$1\"\n\n"
-"while ${OPT_PROCESS} && [ $# -gt 0 ]\ndo\n"
-" OPT_ELEMENT=''\n"
-" OPT_ARG_VAL=''\n\n"
- /*
- * 'OPT_ARG' may or may not match the current $1
- */
-" case \"${OPT_ARG}\" in\n"
-" -- )\n"
-" OPT_PROCESS=false\n"
-" shift\n"
-" ;;\n\n";
-
-static char const zLoopOnly[] = "\n"
-"OPT_ARG=\"$1\"\n\n"
-"while [ $# -gt 0 ]\ndo\n"
-" OPT_ELEMENT=''\n"
-" OPT_ARG_VAL=''\n\n"
-" OPT_ARG=\"${1}\"\n";
-
-/* * * * * * * * * * * * * * * *
- *
- * CASE SELECTORS
- *
- * If the loop runs as a regular option loop,
- * then we must have selectors for each acceptable option
- * type (long option, flag character and non-option)
- */
-static char const zLongSelection[] =
-" --* )\n";
-
-static char const zFlagSelection[] =
-" -* )\n";
-
-static char const zEndSelection[] =
-" ;;\n\n";
-
-static char const zNoSelection[] =
-" * )\n"
-" OPT_PROCESS=false\n"
-" ;;\n"
-" esac\n\n";
-
-/* * * * * * * * * * * * * * * *
- *
- * LOOP END
- */
-static char const zLoopEnd[] =
-" if [ -n \"${OPT_ARG_VAL}\" ]\n"
-" then\n"
-" eval %1$s_${OPT_NAME}${OPT_ELEMENT}=\"'${OPT_ARG_VAL}'\"\n"
-" export %1$s_${OPT_NAME}${OPT_ELEMENT}\n"
-" fi\n"
-"done\n\n"
-"unset OPT_PROCESS || :\n"
-"unset OPT_ELEMENT || :\n"
-"unset OPT_ARG || :\n"
-"unset OPT_ARG_NEEDED || :\n"
-"unset OPT_NAME || :\n"
-"unset OPT_CODE || :\n"
-"unset OPT_ARG_VAL || :\n%2$s";
-
-static char const zTrailerMarker[] = "\n"
-"# # # # # # # # # #\n#\n"
-"# END OF AUTOMATED OPTION PROCESSING\n"
-"#\n# # # # # # # # # # -- do not modify this marker --\n";
-
-/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
- *
- * OPTION SELECTION
- */
-static char const zOptionCase[] =
-" case \"${OPT_CODE}\" in\n";
-
-static char const zOptionPartName[] =
-" '%s' | \\\n";
-
-static char const zOptionFullName[] =
-" '%s' )\n";
-
-static char const zOptionFlag[] =
-" '%c' )\n";
-
-static char const zOptionEndSelect[] =
-" ;;\n\n";
-
-static char const zOptionUnknown[] =
-" * )\n"
-" echo Unknown %s: \"${OPT_CODE}\" >&2\n"
-" echo \"$%s_USAGE_TEXT\"\n"
-" exit 1\n"
-" ;;\n"
-" esac\n\n";
-
-/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
- *
- * OPTION PROCESSING
- *
- * Formats for emitting the text for handling particular options
- */
-static char const zTextExit[] =
-" echo \"$%s_%s_TEXT\"\n"
-" exit 0\n";
-
-static char const zPagedUsageExit[] =
-" echo \"$%s_LONGUSAGE_TEXT\" | ${PAGER-more}\n"
-" exit 0\n";
-
-static char const zCmdFmt[] =
-" %s\n";
-
-static char const zCountTest[] =
-" if [ $%1$s_%2$s_CT -ge %3$d ] ; then\n"
-" echo Error: more than %3$d %2$s options >&2\n"
-" echo \"$%1$s_USAGE_TEXT\"\n"
-" exit 1 ; fi\n";
-
-static char const zMultiArg[] =
-" %1$s_%2$s_CT=`expr ${%1$s_%2$s_CT} + 1`\n"
-" OPT_ELEMENT=\"_${%1$s_%2$s_CT}\"\n"
-" OPT_NAME='%2$s'\n";
-
-static char const zSingleArg[] =
-" if [ -n \"${%1$s_%2$s}\" ] && ${%1$s_%2$s_set} ; then\n"
-" echo Error: duplicate %2$s option >&2\n"
-" echo \"$%1$s_USAGE_TEXT\"\n"
-" exit 1 ; fi\n"
-" %1$s_%2$s_set=true\n"
-" OPT_NAME='%2$s'\n";
-
-static char const zNoMultiArg[] =
-" %1$s_%2$s_CT=0\n"
-" OPT_ELEMENT=''\n"
-" %1$s_%2$s='%3$s'\n"
-" export %1$s_%2$s\n"
-" OPT_NAME='%2$s'\n";
-
-static char const zNoSingleArg[] =
-" if [ -n \"${%1$s_%2$s}\" ] && ${%1$s_%2$s_set} ; then\n"
-" echo Error: duplicate %2$s option >&2\n"
-" echo \"$%1$s_USAGE_TEXT\"\n"
-" exit 1 ; fi\n"
-" %1$s_%2$s_set=true\n"
-" %1$s_%2$s='%3$s'\n"
-" export %1$s_%2$s\n"
-" OPT_NAME='%2$s'\n";
-
-static char const zMayArg[] =
-" eval %1$s_%2$s${OPT_ELEMENT}=true\n"
-" export %1$s_%2$s${OPT_ELEMENT}\n"
-" OPT_ARG_NEEDED=OK\n";
-
-static char const zMustArg[] =
-" OPT_ARG_NEEDED=YES\n";
-
-static char const zCantArg[] =
-" eval %1$s_%2$s${OPT_ELEMENT}=true\n"
-" export %1$s_%2$s${OPT_ELEMENT}\n"
-" OPT_ARG_NEEDED=NO\n";
-
-/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
- *
- * LONG OPTION PROCESSING
- *
- * Formats for emitting the text for handling long option types
- */
-static char const zLongOptInit[] =
-" OPT_CODE=`echo \"X${OPT_ARG}\"|sed 's/^X-*//'`\n"
-" shift\n"
-" OPT_ARG=\"$1\"\n\n"
-" case \"${OPT_CODE}\" in *=* )\n"
-" OPT_ARG_VAL=`echo \"${OPT_CODE}\"|sed 's/^[^=]*=//'`\n"
-" OPT_CODE=`echo \"${OPT_CODE}\"|sed 's/=.*$//'` ;; esac\n\n";
-
-static char const zLongOptArg[] =
-" case \"${OPT_ARG_NEEDED}\" in\n"
-" NO )\n"
-" OPT_ARG_VAL=''\n"
-" ;;\n\n"
-" YES )\n"
-" if [ -z \"${OPT_ARG_VAL}\" ]\n"
-" then\n"
-" if [ $# -eq 0 ]\n"
-" then\n"
-" echo No argument provided for ${OPT_NAME} option >&2\n"
-" echo \"$%s_USAGE_TEXT\"\n"
-" exit 1\n"
-" fi\n\n"
-" OPT_ARG_VAL=\"${OPT_ARG}\"\n"
-" shift\n"
-" OPT_ARG=\"$1\"\n"
-" fi\n"
-" ;;\n\n"
-" OK )\n"
-" if [ -z \"${OPT_ARG_VAL}\" ] && [ $# -gt 0 ]\n"
-" then\n"
-" case \"${OPT_ARG}\" in -* ) ;; * )\n"
-" OPT_ARG_VAL=\"${OPT_ARG}\"\n"
-" shift\n"
-" OPT_ARG=\"$1\" ;; esac\n"
-" fi\n"
-" ;;\n"
-" esac\n";
-
-/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
- *
- * FLAG OPTION PROCESSING
- *
- * Formats for emitting the text for handling flag option types
- */
-static char const zFlagOptInit[] =
-" OPT_CODE=`echo \"X${OPT_ARG}\" | sed 's/X-\\(.\\).*/\\1/'`\n"
-" OPT_ARG=` echo \"X${OPT_ARG}\" | sed 's/X-.//'`\n\n";
-
-static char const zFlagOptArg[] =
-" case \"${OPT_ARG_NEEDED}\" in\n"
-" NO )\n"
-" if [ -n \"${OPT_ARG}\" ]\n"
-" then\n"
-" OPT_ARG=-\"${OPT_ARG}\"\n"
-" else\n"
-" shift\n"
-" OPT_ARG=\"$1\"\n"
-" fi\n"
-" ;;\n\n"
-" YES )\n"
-" if [ -n \"${OPT_ARG}\" ]\n"
-" then\n"
-" OPT_ARG_VAL=\"${OPT_ARG}\"\n\n"
-" else\n"
-" if [ $# -eq 0 ]\n"
-" then\n"
-" echo No argument provided for ${OPT_NAME} option >&2\n"
-" echo \"$%s_USAGE_TEXT\"\n"
-" exit 1\n"
-" fi\n"
-" shift\n"
-" OPT_ARG_VAL=\"$1\"\n"
-" fi\n\n"
-" shift\n"
-" OPT_ARG=\"$1\"\n"
-" ;;\n\n"
-" OK )\n"
-" if [ -n \"${OPT_ARG}\" ]\n"
-" then\n"
-" OPT_ARG_VAL=\"${OPT_ARG}\"\n"
-" shift\n"
-" OPT_ARG=\"$1\"\n\n"
-" else\n"
-" shift\n"
-" if [ $# -gt 0 ]\n"
-" then\n"
-" case \"$1\" in -* ) ;; * )\n"
-" OPT_ARG_VAL=\"$1\"\n"
-" shift ;; esac\n"
-" OPT_ARG=\"$1\"\n"
-" fi\n"
-" fi\n"
-" ;;\n"
-" esac\n";
-
-tSCC* pzShell = NULL;
-static char* pzLeader = NULL;
-static char* pzTrailer = NULL;
-
-/* = = = START-STATIC-FORWARD = = = */
-/* static forward declarations maintained by mk-fwd */
-static void
-textToVariable( tOptions* pOpts, teTextTo whichVar, tOptDesc* pOD );
-
-static void
-emitUsage( tOptions* pOpts );
-
-static void
-emitSetup( tOptions* pOpts );
-
-static void
-printOptionAction( tOptions* pOpts, tOptDesc* pOptDesc );
-
-static void
-printOptionInaction( tOptions* pOpts, tOptDesc* pOptDesc );
-
-static void
-emitFlag( tOptions* pOpts );
-
-static void
-emitMatchExpr( tCC* pzMatchName, tOptDesc* pCurOpt, tOptions* pOpts );
-
-static void
-emitLong( tOptions* pOpts );
-
-static void
-openOutput( char const* pzFile );
-/* = = = END-STATIC-FORWARD = = = */
-
-/*=export_func optionParseShell
- * private:
- *
- * what: Decipher a boolean value
- * arg: + tOptions* + pOpts + program options descriptor +
- *
- * doc:
- * Emit a shell script that will parse the command line options.
-=*/
-void
-optionParseShell( tOptions* pOpts )
-{
- /*
- * Check for our SHELL option now.
- * IF the output file contains the "#!" magic marker,
- * it will override anything we do here.
- */
- if (HAVE_OPT( SHELL ))
- pzShell = OPT_ARG( SHELL );
-
- else if (! ENABLED_OPT( SHELL ))
- pzShell = NULL;
-
- else if ((pzShell = getenv( "SHELL" )),
- pzShell == NULL)
-
- pzShell = "/bin/sh";
-
- /*
- * Check for a specified output file
- */
- if (HAVE_OPT( SCRIPT ))
- openOutput( OPT_ARG( SCRIPT ));
-
- emitUsage( pOpts );
- emitSetup( pOpts );
-
- /*
- * There are four modes of option processing.
- */
- switch (pOpts->fOptSet & (OPTPROC_LONGOPT|OPTPROC_SHORTOPT)) {
- case OPTPROC_LONGOPT:
- fputs( zLoopCase, stdout );
-
- fputs( zLongSelection, stdout );
- fputs( zLongOptInit, stdout );
- emitLong( pOpts );
- printf( zLongOptArg, pOpts->pzPROGNAME );
- fputs( zEndSelection, stdout );
-
- fputs( zNoSelection, stdout );
- break;
-
- case 0:
- fputs( zLoopOnly, stdout );
- fputs( zLongOptInit, stdout );
- emitLong( pOpts );
- printf( zLongOptArg, pOpts->pzPROGNAME );
- break;
-
- case OPTPROC_SHORTOPT:
- fputs( zLoopCase, stdout );
-
- fputs( zFlagSelection, stdout );
- fputs( zFlagOptInit, stdout );
- emitFlag( pOpts );
- printf( zFlagOptArg, pOpts->pzPROGNAME );
- fputs( zEndSelection, stdout );
-
- fputs( zNoSelection, stdout );
- break;
-
- case OPTPROC_LONGOPT|OPTPROC_SHORTOPT:
- fputs( zLoopCase, stdout );
-
- fputs( zLongSelection, stdout );
- fputs( zLongOptInit, stdout );
- emitLong( pOpts );
- printf( zLongOptArg, pOpts->pzPROGNAME );
- fputs( zEndSelection, stdout );
-
- fputs( zFlagSelection, stdout );
- fputs( zFlagOptInit, stdout );
- emitFlag( pOpts );
- printf( zFlagOptArg, pOpts->pzPROGNAME );
- fputs( zEndSelection, stdout );
-
- fputs( zNoSelection, stdout );
- break;
- }
-
- printf( zLoopEnd, pOpts->pzPROGNAME, zTrailerMarker );
- if ((pzTrailer != NULL) && (*pzTrailer != '\0'))
- fputs( pzTrailer, stdout );
- else if (ENABLED_OPT( SHELL ))
- printf( "\nenv | grep '^%s_'\n", pOpts->pzPROGNAME );
-
- fflush( stdout );
- fchmod( STDOUT_FILENO, 0755 );
- fclose( stdout );
-}
-
-
-static void
-textToVariable( tOptions* pOpts, teTextTo whichVar, tOptDesc* pOD )
-{
-# define _TT_(n) tSCC z ## n [] = #n;
- TEXTTO_TABLE
-# undef _TT_
-# define _TT_(n) z ## n ,
- static char const* apzTTNames[] = { TEXTTO_TABLE };
-# undef _TT_
-
-#if ! defined(HAVE_WORKING_FORK)
- printf( "%1$s_%2$s_TEXT='no %2$s text'\n",
- pOpts->pzPROGNAME, apzTTNames[ whichVar ]);
-#else
- int nlHoldCt = 0;
- int pipeFd[2];
- FILE* fp;
-
- printf( "%s_%s_TEXT='", pOpts->pzPROGNAME, apzTTNames[ whichVar ]);
- fflush( stdout );
-
- if (pipe( pipeFd ) != 0) {
- fprintf( stderr, zBadPipe, errno, strerror( errno ));
- exit( EXIT_FAILURE );
- }
-
- switch (fork()) {
- case -1:
- fprintf( stderr, zForkFail, errno, strerror(errno), pOpts->pzProgName);
- exit( EXIT_FAILURE );
- break;
-
- case 0:
- dup2( pipeFd[1], STDERR_FILENO );
- dup2( pipeFd[1], STDOUT_FILENO );
- close( pipeFd[0] );
-
- switch (whichVar) {
- case TT_LONGUSAGE:
- (*(pOpts->pUsageProc))( pOpts, EXIT_SUCCESS );
- /* NOTREACHED */
- exit( EXIT_FAILURE );
-
- case TT_USAGE:
- (*(pOpts->pUsageProc))( pOpts, EXIT_FAILURE );
- /* NOTREACHED */
- exit( EXIT_FAILURE );
-
- case TT_VERSION:
- if (pOD->fOptState & OPTST_ALLOC_ARG) {
- AGFREE(pOD->optArg.argString);
- pOD->fOptState &= ~OPTST_ALLOC_ARG;
- }
- pOD->optArg.argString = "c";
- optionPrintVersion( pOpts, pOD );
- /* NOTREACHED */
-
- default:
- exit( EXIT_FAILURE );
- }
-
- default:
- close( pipeFd[1] );
- fp = fdopen( pipeFd[0], "r" FOPEN_BINARY_FLAG );
- }
-
- for (;;) {
- int ch = fgetc( fp );
- switch (ch) {
-
- case '\n':
- nlHoldCt++;
- break;
-
- case '\'':
- while (nlHoldCt > 0) {
- fputc( '\n', stdout );
- nlHoldCt--;
- }
- fputs( "'\\''", stdout );
- break;
-
- case EOF:
- goto endCharLoop;
-
- default:
- while (nlHoldCt > 0) {
- fputc( '\n', stdout );
- nlHoldCt--;
- }
- fputc( ch, stdout );
- break;
- }
- } endCharLoop:;
-
- fputs( "'\n\n", stdout );
- close( pipeFd[0] );
-#endif
-}
-
-
-static void
-emitUsage( tOptions* pOpts )
-{
- char zTimeBuf[ AO_NAME_SIZE ];
-
- /*
- * First, switch stdout to the output file name.
- * Then, change the program name to the one defined
- * by the definitions (rather than the current
- * executable name). Down case the upper cased name.
- */
- if (pzLeader != NULL)
- fputs( pzLeader, stdout );
-
- {
- tSCC zStdout[] = "stdout";
- tCC* pzOutName;
-
- {
- time_t curTime = time( NULL );
- struct tm* pTime = localtime( &curTime );
- strftime(zTimeBuf, AO_NAME_SIZE, "%A %B %e, %Y at %r %Z", pTime );
- }
-
- if (HAVE_OPT( SCRIPT ))
- pzOutName = OPT_ARG( SCRIPT );
- else pzOutName = zStdout;
-
- if ((pzLeader == NULL) && (pzShell != NULL))
- printf( "#! %s\n", pzShell );
-
- printf( zPreamble, zStartMarker, pzOutName, zTimeBuf );
- }
-
- /*
- * Get a copy of the original program name in lower case
- */
- {
- char* pzPN = zTimeBuf;
- tCC* pz = pOpts->pzPROGNAME;
- for (;;) {
- if ((*pzPN++ = tolower( *pz++ )) == '\0')
- break;
- }
- }
-
- printf( zEndPreamble, pOpts->pzPROGNAME );
-
- pOpts->pzProgPath = pOpts->pzProgName = zTimeBuf;
- textToVariable( pOpts, TT_LONGUSAGE, NULL );
- textToVariable( pOpts, TT_USAGE, NULL );
-
- {
- tOptDesc* pOptDesc = pOpts->pOptDesc;
- int optionCt = pOpts->optCt;
-
- for (;;) {
- if (pOptDesc->pOptProc == optionPrintVersion) {
- textToVariable( pOpts, TT_VERSION, pOptDesc );
- break;
- }
-
- if (--optionCt <= 0)
- break;
- pOptDesc++;
- }
- }
-}
-
-
-static void
-emitSetup( tOptions* pOpts )
-{
- tOptDesc* pOptDesc = pOpts->pOptDesc;
- int optionCt = pOpts->presetOptCt;
- char const* pzFmt;
- char const* pzDefault;
-
- for (;optionCt > 0; pOptDesc++, --optionCt) {
- char zVal[16];
-
- /*
- * Options that are either usage documentation or are compiled out
- * are not to be processed.
- */
- if (SKIP_OPT(pOptDesc) || (pOptDesc->pz_NAME == NULL))
- continue;
-
- if (pOptDesc->optMaxCt > 1)
- pzFmt = zMultiDef;
- else pzFmt = zSingleDef;
-
- /*
- * IF this is an enumeration/bitmask option, then convert the value
- * to a string before printing the default value.
- */
- switch (OPTST_GET_ARGTYPE(pOptDesc->fOptState)) {
- case OPARG_TYPE_ENUMERATION:
- (*(pOptDesc->pOptProc))(OPTPROC_EMIT_SHELL, pOptDesc );
- pzDefault = pOptDesc->optArg.argString;
- break;
-
- /*
- * Numeric and membership bit options are just printed as a number.
- */
- case OPARG_TYPE_NUMERIC:
- snprintf( zVal, sizeof( zVal ), "%d",
- (int)pOptDesc->optArg.argInt );
- pzDefault = zVal;
- break;
-
- case OPARG_TYPE_MEMBERSHIP:
- snprintf( zVal, sizeof( zVal ), "%lu",
- (unsigned long)pOptDesc->optArg.argIntptr );
- pzDefault = zVal;
- break;
-
- case OPARG_TYPE_BOOLEAN:
- pzDefault = (pOptDesc->optArg.argBool) ? "true" : "false";
- break;
-
- default:
- if (pOptDesc->optArg.argString == NULL) {
- if (pzFmt == zSingleDef)
- pzFmt = zSingleNoDef;
- pzDefault = NULL;
- }
- else
- pzDefault = pOptDesc->optArg.argString;
- }
-
- printf( pzFmt, pOpts->pzPROGNAME, pOptDesc->pz_NAME, pzDefault );
- }
-}
-
-
-static void
-printOptionAction( tOptions* pOpts, tOptDesc* pOptDesc )
-{
- if (pOptDesc->pOptProc == optionPrintVersion)
- printf( zTextExit, pOpts->pzPROGNAME, "VERSION" );
-
- else if (pOptDesc->pOptProc == optionPagedUsage)
- printf( zPagedUsageExit, pOpts->pzPROGNAME );
-
- else if (pOptDesc->pOptProc == optionLoadOpt) {
- printf( zCmdFmt, "echo 'Warning: Cannot load options files' >&2" );
- printf( zCmdFmt, "OPT_ARG_NEEDED=YES" );
-
- } else if (pOptDesc->pz_NAME == NULL) {
-
- if (pOptDesc->pOptProc == NULL) {
- printf( zCmdFmt, "echo 'Warning: Cannot save options files' "
- ">&2" );
- printf( zCmdFmt, "OPT_ARG_NEEDED=OK" );
- } else
- printf( zTextExit, pOpts->pzPROGNAME, "LONGUSAGE" );
-
- } else {
- if (pOptDesc->optMaxCt == 1)
- printf( zSingleArg, pOpts->pzPROGNAME, pOptDesc->pz_NAME );
- else {
- if ((unsigned)pOptDesc->optMaxCt < NOLIMIT)
- printf( zCountTest, pOpts->pzPROGNAME,
- pOptDesc->pz_NAME, pOptDesc->optMaxCt );
-
- printf( zMultiArg, pOpts->pzPROGNAME, pOptDesc->pz_NAME );
- }
-
- /*
- * Fix up the args.
- */
- if (OPTST_GET_ARGTYPE(pOptDesc->fOptState) == OPARG_TYPE_NONE) {
- printf( zCantArg, pOpts->pzPROGNAME, pOptDesc->pz_NAME );
-
- } else if (pOptDesc->fOptState & OPTST_ARG_OPTIONAL) {
- printf( zMayArg, pOpts->pzPROGNAME, pOptDesc->pz_NAME );
-
- } else {
- fputs( zMustArg, stdout );
- }
- }
- fputs( zOptionEndSelect, stdout );
-}
-
-
-static void
-printOptionInaction( tOptions* pOpts, tOptDesc* pOptDesc )
-{
- if (pOptDesc->pOptProc == optionLoadOpt) {
- printf( zCmdFmt, "echo 'Warning: Cannot suppress the loading of "
- "options files' >&2" );
-
- } else if (pOptDesc->optMaxCt == 1)
- printf( zNoSingleArg, pOpts->pzPROGNAME,
- pOptDesc->pz_NAME, pOptDesc->pz_DisablePfx );
- else
- printf( zNoMultiArg, pOpts->pzPROGNAME,
- pOptDesc->pz_NAME, pOptDesc->pz_DisablePfx );
-
- printf( zCmdFmt, "OPT_ARG_NEEDED=NO" );
- fputs( zOptionEndSelect, stdout );
-}
-
-
-static void
-emitFlag( tOptions* pOpts )
-{
- tOptDesc* pOptDesc = pOpts->pOptDesc;
- int optionCt = pOpts->optCt;
-
- fputs( zOptionCase, stdout );
-
- for (;optionCt > 0; pOptDesc++, --optionCt) {
-
- if (SKIP_OPT(pOptDesc))
- continue;
-
- if (IS_GRAPHIC_CHAR(pOptDesc->optValue)) {
- printf( zOptionFlag, pOptDesc->optValue );
- printOptionAction( pOpts, pOptDesc );
- }
- }
- printf( zOptionUnknown, "flag", pOpts->pzPROGNAME );
-}
-
-
-/*
- * Emit the match text for a long option
- */
-static void
-emitMatchExpr( tCC* pzMatchName, tOptDesc* pCurOpt, tOptions* pOpts )
-{
- tOptDesc* pOD = pOpts->pOptDesc;
- int oCt = pOpts->optCt;
- int min = 1;
- char zName[ 256 ];
- char* pz = zName;
-
- for (;;) {
- int matchCt = 0;
-
- /*
- * Omit the current option, Documentation opts and compiled out opts.
- */
- if ((pOD == pCurOpt) || SKIP_OPT(pOD)){
- if (--oCt <= 0)
- break;
- pOD++;
- continue;
- }
-
- /*
- * Check each character of the name case insensitively.
- * They must not be the same. They cannot be, because it would
- * not compile correctly if they were.
- */
- while ( toupper( pOD->pz_Name[matchCt] )
- == toupper( pzMatchName[matchCt] ))
- matchCt++;
-
- if (matchCt > min)
- min = matchCt;
-
- /*
- * Check the disablement name, too.
- */
- if (pOD->pz_DisableName != NULL) {
- matchCt = 0;
- while ( toupper( pOD->pz_DisableName[matchCt] )
- == toupper( pzMatchName[matchCt] ))
- matchCt++;
- if (matchCt > min)
- min = matchCt;
- }
- if (--oCt <= 0)
- break;
- pOD++;
- }
-
- /*
- * IF the 'min' is all or one short of the name length,
- * THEN the entire string must be matched.
- */
- if ( (pzMatchName[min ] == NUL)
- || (pzMatchName[min+1] == NUL) )
- printf( zOptionFullName, pzMatchName );
-
- else {
- int matchCt = 0;
- for (; matchCt <= min; matchCt++)
- *pz++ = pzMatchName[matchCt];
-
- for (;;) {
- *pz = NUL;
- printf( zOptionPartName, zName );
- *pz++ = pzMatchName[matchCt++];
- if (pzMatchName[matchCt] == NUL) {
- *pz = NUL;
- printf( zOptionFullName, zName );
- break;
- }
- }
- }
-}
-
-
-/*
- * Emit GNU-standard long option handling code
- */
-static void
-emitLong( tOptions* pOpts )
-{
- tOptDesc* pOD = pOpts->pOptDesc;
- int ct = pOpts->optCt;
-
- fputs( zOptionCase, stdout );
-
- /*
- * do each option, ...
- */
- do {
- /*
- * Documentation & compiled-out options
- */
- if (SKIP_OPT(pOD))
- continue;
-
- emitMatchExpr( pOD->pz_Name, pOD, pOpts );
- printOptionAction( pOpts, pOD );
-
- /*
- * Now, do the same thing for the disablement version of the option.
- */
- if (pOD->pz_DisableName != NULL) {
- emitMatchExpr( pOD->pz_DisableName, pOD, pOpts );
- printOptionInaction( pOpts, pOD );
- }
- } while (pOD++, --ct > 0);
-
- printf( zOptionUnknown, "option", pOpts->pzPROGNAME );
-}
-
-
-static void
-openOutput( char const* pzFile )
-{
- FILE* fp;
- char* pzData = NULL;
- struct stat stbf;
-
- do {
- char* pzScan;
- size_t sizeLeft;
-
- /*
- * IF we cannot stat the file,
- * THEN assume we are creating a new file.
- * Skip the loading of the old data.
- */
- if (stat( pzFile, &stbf ) != 0)
- break;
-
- /*
- * The file must be a regular file
- */
- if (! S_ISREG( stbf.st_mode )) {
- fprintf( stderr, zNotFile, pzFile );
- exit( EXIT_FAILURE );
- }
-
- pzData = AGALOC(stbf.st_size + 1, "file data");
- fp = fopen( pzFile, "r" FOPEN_BINARY_FLAG );
-
- sizeLeft = (unsigned)stbf.st_size;
- pzScan = pzData;
-
- /*
- * Read in all the data as fast as our OS will let us.
- */
- for (;;) {
- int inct = fread( (void*)pzScan, (size_t)1, sizeLeft, fp);
- if (inct == 0)
- break;
-
- pzScan += inct;
- sizeLeft -= inct;
-
- if (sizeLeft == 0)
- break;
- }
-
- /*
- * NUL-terminate the leader and look for the trailer
- */
- *pzScan = '\0';
- fclose( fp );
- pzScan = strstr( pzData, zStartMarker );
- if (pzScan == NULL) {
- pzTrailer = pzData;
- break;
- }
-
- *(pzScan++) = NUL;
- pzScan = strstr( pzScan, zTrailerMarker );
- if (pzScan == NULL) {
- pzTrailer = pzData;
- break;
- }
-
- /*
- * Check to see if the data contains
- * our marker. If it does, then we will skip over it
- */
- pzTrailer = pzScan + sizeof( zTrailerMarker ) - 1;
- pzLeader = pzData;
- } while (AG_FALSE);
-
- freopen( pzFile, "w" FOPEN_BINARY_FLAG, stdout );
-}
-
-
-/*=export_func genshelloptUsage
- * private:
- * what: The usage function for the genshellopt generated program
- *
- * arg: + tOptions* + pOpts + program options descriptor +
- * arg: + int + exitCode + usage text type to produce +
- *
- * doc:
- * This function is used to create the usage strings for the option
- * processing shell script code. Two child processes are spawned
- * each emitting the usage text in either the short (error exit)
- * style or the long style. The generated program will capture this
- * and create shell script variables containing the two types of text.
-=*/
-void
-genshelloptUsage( tOptions* pOpts, int exitCode )
-{
-#if ! defined(HAVE_WORKING_FORK)
- optionUsage( pOpts, exitCode );
-#else
- /*
- * IF not EXIT_SUCCESS,
- * THEN emit the short form of usage.
- */
- if (exitCode != EXIT_SUCCESS)
- optionUsage( pOpts, exitCode );
- fflush( stderr );
- fflush( stdout );
-
- option_usage_fp = stdout;
-
- /*
- * First, print our usage
- */
- switch (fork()) {
- case -1:
- optionUsage( pOpts, EXIT_FAILURE );
- /* NOTREACHED */
- _exit( EXIT_FAILURE );
-
- case 0:
- pagerState = PAGER_STATE_CHILD;
- optionUsage( pOpts, EXIT_SUCCESS );
- /* NOTREACHED */
- _exit( EXIT_FAILURE );
-
- default:
- {
- int sts;
- wait( &sts );
- }
- }
-
- /*
- * Generate the pzProgName, since optionProcess() normally
- * gets it from the command line
- */
- {
- char* pz;
- AGDUPSTR( pz, pShellParseOptions->pzPROGNAME, "program name" );
- pShellParseOptions->pzProgName = pz;
- while (*pz != NUL) {
- *pz = tolower( *pz );
- pz++;
- }
- }
-
- /*
- * Separate the makeshell usage from the client usage
- */
- fprintf( option_usage_fp, zGenshell, pShellParseOptions->pzProgName );
- fflush( option_usage_fp );
-
- /*
- * Now, print the client usage.
- */
- switch (fork()) {
- case 0:
- pagerState = PAGER_STATE_CHILD;
- /*FALLTHROUGH*/
- case -1:
- optionUsage( pShellParseOptions, EXIT_FAILURE );
-
- default:
- {
- int sts;
- wait( &sts );
- }
- }
-
- exit( EXIT_SUCCESS );
-#endif
-}
-
-/*
- * Local Variables:
- * mode: C
- * c-file-style: "stroustrup"
- * indent-tabs-mode: nil
- * End:
- * end of autoopts/makeshell.c */
+++ /dev/null
-
-/*
- * $Id: 43877d3ade0b626b4bec87f2f340a8358c118333 $
- * Time-stamp: "2008-07-28 19:18:28 bkorb"
- *
- * Automated Options Nested Values module.
- *
- * This file is part of AutoOpts, a companion to AutoGen.
- * AutoOpts is free software.
- * AutoOpts is copyright (c) 1992-2009 by Bruce Korb - all rights reserved
- *
- * AutoOpts is available under any one of two licenses. The license
- * in use must be one of these two and the choice is under the control
- * of the user of the license.
- *
- * The GNU Lesser General Public License, version 3 or later
- * See the files "COPYING.lgplv3" and "COPYING.gplv3"
- *
- * The Modified Berkeley Software Distribution License
- * See the file "COPYING.mbsd"
- *
- * These files have the following md5sums:
- *
- * 43b91e8ca915626ed3818ffb1b71248b pkg/libopts/COPYING.gplv3
- * 06a1a2e4760c90ea5e1dad8dfaac4d39 pkg/libopts/COPYING.lgplv3
- * 66a5cedaf62c4b2637025f049f9b826f pkg/libopts/COPYING.mbsd
- */
-
-typedef struct {
- int xml_ch;
- int xml_len;
- char xml_txt[8];
-} xml_xlate_t;
-
-static xml_xlate_t const xml_xlate[] = {
- { '&', 4, "amp;" },
- { '<', 3, "lt;" },
- { '>', 3, "gt;" },
- { '"', 5, "quot;" },
- { '\'',5, "apos;" }
-};
-
-/* = = = START-STATIC-FORWARD = = = */
-/* static forward declarations maintained by mk-fwd */
-static void
-removeLineContinue( char* pzSrc );
-
-static char const*
-scanQuotedString( char const* pzTxt );
-
-static tOptionValue*
-addStringValue( void** pp, char const* pzName, size_t nameLen,
- char const* pzValue, size_t dataLen );
-
-static tOptionValue*
-addBoolValue( void** pp, char const* pzName, size_t nameLen,
- char const* pzValue, size_t dataLen );
-
-static tOptionValue*
-addNumberValue( void** pp, char const* pzName, size_t nameLen,
- char const* pzValue, size_t dataLen );
-
-static tOptionValue*
-addNestedValue( void** pp, char const* pzName, size_t nameLen,
- char* pzValue, size_t dataLen );
-
-static char const*
-scanNameEntry(char const* pzName, tOptionValue* pRes);
-
-static char const*
-scanXmlEntry( char const* pzName, tOptionValue* pRes );
-
-static void
-unloadNestedArglist( tArgList* pAL );
-
-static void
-sortNestedList( tArgList* pAL );
-/* = = = END-STATIC-FORWARD = = = */
-
-/* removeLineContinue
- *
- * Backslashes are used for line continuations. We keep the newline
- * characters, but trim out the backslash:
- */
-static void
-removeLineContinue( char* pzSrc )
-{
- char* pzD;
-
- do {
- while (*pzSrc == '\n') pzSrc++;
- pzD = strchr(pzSrc, '\n');
- if (pzD == NULL)
- return;
-
- /*
- * pzD has skipped at least one non-newline character and now
- * points to a newline character. It now becomes the source and
- * pzD goes to the previous character.
- */
- pzSrc = pzD--;
- if (*pzD != '\\')
- pzD++;
- } while (pzD == pzSrc);
-
- /*
- * Start shifting text.
- */
- for (;;) {
- char ch = ((*pzD++) = *(pzSrc++));
- switch (ch) {
- case NUL: return;
- case '\\':
- if (*pzSrc == '\n')
- --pzD; /* rewrite on next iteration */
- }
- }
-}
-
-
-/* scanQuotedString
- *
- * Find the end of a quoted string, skipping escaped quote characters.
- */
-static char const*
-scanQuotedString( char const* pzTxt )
-{
- char q = *(pzTxt++); /* remember the type of quote */
-
- for (;;) {
- char ch = *(pzTxt++);
- if (ch == NUL)
- return pzTxt-1;
-
- if (ch == q)
- return pzTxt;
-
- if (ch == '\\') {
- ch = *(pzTxt++);
- /*
- * IF the next character is NUL, drop the backslash, too.
- */
- if (ch == NUL)
- return pzTxt - 2;
-
- /*
- * IF the quote character or the escape character were escaped,
- * then skip both, as long as the string does not end.
- */
- if ((ch == q) || (ch == '\\')) {
- if (*(pzTxt++) == NUL)
- return pzTxt-1;
- }
- }
- }
-}
-
-
-/* addStringValue
- *
- * Associate a name with either a string or no value.
- */
-static tOptionValue*
-addStringValue( void** pp, char const* pzName, size_t nameLen,
- char const* pzValue, size_t dataLen )
-{
- tOptionValue* pNV;
- size_t sz = nameLen + dataLen + sizeof(*pNV);
-
- pNV = AGALOC( sz, "option name/str value pair" );
- if (pNV == NULL)
- return NULL;
-
- if (pzValue == NULL) {
- pNV->valType = OPARG_TYPE_NONE;
- pNV->pzName = pNV->v.strVal;
-
- } else {
- pNV->valType = OPARG_TYPE_STRING;
- if (dataLen > 0) {
- char const * pzSrc = pzValue;
- char * pzDst = pNV->v.strVal;
- int ct = dataLen;
- do {
- int ch = *(pzSrc++) & 0xFF;
- if (ch == NUL) goto data_copy_done;
- if (ch == '&')
- ch = get_special_char(&pzSrc, &ct);
- *(pzDst++) = ch;
- } while (--ct > 0);
- data_copy_done:
- *pzDst = NUL;
-
- } else {
- pNV->v.strVal[0] = NUL;
- }
-
- pNV->pzName = pNV->v.strVal + dataLen + 1;
- }
-
- memcpy( pNV->pzName, pzName, nameLen );
- pNV->pzName[ nameLen ] = NUL;
- addArgListEntry( pp, pNV );
- return pNV;
-}
-
-
-/* addBoolValue
- *
- * Associate a name with either a string or no value.
- */
-static tOptionValue*
-addBoolValue( void** pp, char const* pzName, size_t nameLen,
- char const* pzValue, size_t dataLen )
-{
- tOptionValue* pNV;
- size_t sz = nameLen + sizeof(*pNV) + 1;
-
- pNV = AGALOC( sz, "option name/bool value pair" );
- if (pNV == NULL)
- return NULL;
- while (IS_WHITESPACE_CHAR(*pzValue) && (dataLen > 0)) {
- dataLen--; pzValue++;
- }
- if (dataLen == 0)
- pNV->v.boolVal = 0;
-
- else if (IS_DEC_DIGIT_CHAR(*pzValue))
- pNV->v.boolVal = atoi(pzValue);
-
- else pNV->v.boolVal = ! IS_FALSE_TYPE_CHAR(*pzValue);
-
- pNV->valType = OPARG_TYPE_BOOLEAN;
- pNV->pzName = (char*)(pNV + 1);
- memcpy( pNV->pzName, pzName, nameLen );
- pNV->pzName[ nameLen ] = NUL;
- addArgListEntry( pp, pNV );
- return pNV;
-}
-
-
-/* addNumberValue
- *
- * Associate a name with either a string or no value.
- */
-static tOptionValue*
-addNumberValue( void** pp, char const* pzName, size_t nameLen,
- char const* pzValue, size_t dataLen )
-{
- tOptionValue* pNV;
- size_t sz = nameLen + sizeof(*pNV) + 1;
-
- pNV = AGALOC( sz, "option name/bool value pair" );
- if (pNV == NULL)
- return NULL;
- while (IS_WHITESPACE_CHAR(*pzValue) && (dataLen > 0)) {
- dataLen--; pzValue++;
- }
- if (dataLen == 0)
- pNV->v.longVal = 0;
- else
- pNV->v.longVal = strtol(pzValue, 0, 0);
-
- pNV->valType = OPARG_TYPE_NUMERIC;
- pNV->pzName = (char*)(pNV + 1);
- memcpy( pNV->pzName, pzName, nameLen );
- pNV->pzName[ nameLen ] = NUL;
- addArgListEntry( pp, pNV );
- return pNV;
-}
-
-
-/* addNestedValue
- *
- * Associate a name with either a string or no value.
- */
-static tOptionValue*
-addNestedValue( void** pp, char const* pzName, size_t nameLen,
- char* pzValue, size_t dataLen )
-{
- tOptionValue* pNV;
-
- if (dataLen == 0) {
- size_t sz = nameLen + sizeof(*pNV) + 1;
- pNV = AGALOC( sz, "empty nested value pair" );
- if (pNV == NULL)
- return NULL;
- pNV->v.nestVal = NULL;
- pNV->valType = OPARG_TYPE_HIERARCHY;
- pNV->pzName = (char*)(pNV + 1);
- memcpy( pNV->pzName, pzName, nameLen );
- pNV->pzName[ nameLen ] = NUL;
-
- } else {
- pNV = optionLoadNested( pzValue, pzName, nameLen );
- }
-
- if (pNV != NULL)
- addArgListEntry( pp, pNV );
-
- return pNV;
-}
-
-
-/* scanNameEntry
- *
- * We have an entry that starts with a name. Find the end of it, cook it
- * (if called for) and create the name/value association.
- */
-static char const*
-scanNameEntry(char const* pzName, tOptionValue* pRes)
-{
- tOptionValue* pNV;
- char const * pzScan = pzName+1; /* we know first char is a name char */
- char const * pzVal;
- size_t nameLen = 1;
- size_t dataLen = 0;
-
- /*
- * Scan over characters that name a value. These names may not end
- * with a colon, but they may contain colons.
- */
- while (IS_VALUE_NAME_CHAR(*pzScan)) { pzScan++; nameLen++; }
- if (pzScan[-1] == ':') { pzScan--; nameLen--; }
- while (IS_HORIZ_WHITE_CHAR(*pzScan)) pzScan++;
-
-re_switch:
- switch (*pzScan) {
- case '=':
- case ':':
- while (IS_HORIZ_WHITE_CHAR( (int)*++pzScan )) ;
- if ((*pzScan == '=') || (*pzScan == ':'))
- goto default_char;
- goto re_switch;
-
- case '\n':
- case ',':
- pzScan++;
- /* FALLTHROUGH */
-
- case NUL:
- addStringValue(&(pRes->v.nestVal), pzName, nameLen, NULL, (size_t)0);
- break;
-
- case '"':
- case '\'':
- pzVal = pzScan;
- pzScan = scanQuotedString( pzScan );
- dataLen = pzScan - pzVal;
- pNV = addStringValue( &(pRes->v.nestVal), pzName, nameLen, pzVal,
- dataLen );
- if ((pNV != NULL) && (option_load_mode == OPTION_LOAD_COOKED))
- ao_string_cook( pNV->v.strVal, NULL );
- break;
-
- default:
- default_char:
- /*
- * We have found some strange text value. It ends with a newline
- * or a comma.
- */
- pzVal = pzScan;
- for (;;) {
- char ch = *(pzScan++);
- switch (ch) {
- case NUL:
- pzScan--;
- dataLen = pzScan - pzVal;
- goto string_done;
- /* FALLTHROUGH */
-
- case '\n':
- if ( (pzScan > pzVal + 2)
- && (pzScan[-2] == '\\')
- && (pzScan[ 0] != NUL))
- continue;
- /* FALLTHROUGH */
-
- case ',':
- dataLen = (pzScan - pzVal) - 1;
- string_done:
- pNV = addStringValue( &(pRes->v.nestVal), pzName, nameLen,
- pzVal, dataLen );
- if (pNV != NULL)
- removeLineContinue( pNV->v.strVal );
- goto leave_scan_name;
- }
- }
- break;
- } leave_scan_name:;
-
- return pzScan;
-}
-
-
-/* scanXmlEntry
- *
- * We've found a '<' character. We ignore this if it is a comment or a
- * directive. If it is something else, then whatever it is we are looking
- * at is bogus. Returning NULL stops processing.
- */
-static char const*
-scanXmlEntry( char const* pzName, tOptionValue* pRes )
-{
- size_t nameLen = 1, valLen = 0;
- char const* pzScan = ++pzName;
- char const* pzVal;
- tOptionValue valu;
- tOptionValue* pNewVal;
- tOptionLoadMode save_mode = option_load_mode;
-
- if (! IS_VAR_FIRST_CHAR(*pzName)) {
- switch (*pzName) {
- default:
- pzName = NULL;
- break;
-
- case '!':
- pzName = strstr( pzName, "-->" );
- if (pzName != NULL)
- pzName += 3;
- break;
-
- case '?':
- pzName = strchr( pzName, '>' );
- if (pzName != NULL)
- pzName++;
- break;
- }
- return pzName;
- }
-
- pzScan++;
- while (IS_VALUE_NAME_CHAR( (int)*pzScan )) { pzScan++; nameLen++; }
- if (nameLen > 64)
- return NULL;
- valu.valType = OPARG_TYPE_STRING;
-
- switch (*pzScan) {
- case ' ':
- case '\t':
- pzScan = parseAttributes(
- NULL, (char*)pzScan, &option_load_mode, &valu );
- if (*pzScan == '>') {
- pzScan++;
- break;
- }
-
- if (*pzScan != '/') {
- option_load_mode = save_mode;
- return NULL;
- }
- /* FALLTHROUGH */
-
- case '/':
- if (*++pzScan != '>') {
- option_load_mode = save_mode;
- return NULL;
- }
- addStringValue(&(pRes->v.nestVal), pzName, nameLen, NULL, (size_t)0);
- option_load_mode = save_mode;
- return pzScan+1;
-
- default:
- option_load_mode = save_mode;
- return NULL;
-
- case '>':
- pzScan++;
- break;
- }
-
- pzVal = pzScan;
-
- {
- char z[68];
- char* pzD = z;
- int ct = nameLen;
- char const* pzS = pzName;
-
- *(pzD++) = '<';
- *(pzD++) = '/';
-
- do {
- *(pzD++) = *(pzS++);
- } while (--ct > 0);
- *(pzD++) = '>';
- *pzD = NUL;
-
- pzScan = strstr( pzScan, z );
- if (pzScan == NULL) {
- option_load_mode = save_mode;
- return NULL;
- }
- valLen = (pzScan - pzVal);
- pzScan += nameLen + 3;
- while (IS_WHITESPACE_CHAR(*pzScan)) pzScan++;
- }
-
- switch (valu.valType) {
- case OPARG_TYPE_NONE:
- addStringValue( &(pRes->v.nestVal), pzName, nameLen, NULL, (size_t)0);
- break;
-
- case OPARG_TYPE_STRING:
- pNewVal = addStringValue(
- &(pRes->v.nestVal), pzName, nameLen, pzVal, valLen);
-
- if (option_load_mode == OPTION_LOAD_KEEP)
- break;
- mungeString( pNewVal->v.strVal, option_load_mode );
- break;
-
- case OPARG_TYPE_BOOLEAN:
- addBoolValue( &(pRes->v.nestVal), pzName, nameLen, pzVal, valLen );
- break;
-
- case OPARG_TYPE_NUMERIC:
- addNumberValue( &(pRes->v.nestVal), pzName, nameLen, pzVal, valLen );
- break;
-
- case OPARG_TYPE_HIERARCHY:
- {
- char* pz = AGALOC( valLen+1, "hierarchical scan" );
- if (pz == NULL)
- break;
- memcpy( pz, pzVal, valLen );
- pz[valLen] = NUL;
- addNestedValue( &(pRes->v.nestVal), pzName, nameLen, pz, valLen );
- AGFREE(pz);
- break;
- }
-
- case OPARG_TYPE_ENUMERATION:
- case OPARG_TYPE_MEMBERSHIP:
- default:
- break;
- }
-
- option_load_mode = save_mode;
- return pzScan;
-}
-
-
-/* unloadNestedArglist
- *
- * Deallocate a list of option arguments. This must have been gotten from
- * a hierarchical option argument, not a stacked list of strings. It is
- * an internal call, so it is not validated. The caller is responsible for
- * knowing what they are doing.
- */
-static void
-unloadNestedArglist( tArgList* pAL )
-{
- int ct = pAL->useCt;
- tCC** ppNV = pAL->apzArgs;
-
- while (ct-- > 0) {
- tOptionValue* pNV = (tOptionValue*)(void*)*(ppNV++);
- if (pNV->valType == OPARG_TYPE_HIERARCHY)
- unloadNestedArglist( pNV->v.nestVal );
- AGFREE( pNV );
- }
-
- AGFREE( (void*)pAL );
-}
-
-
-/*=export_func optionUnloadNested
- *
- * what: Deallocate the memory for a nested value
- * arg: + tOptionValue const * + pOptVal + the hierarchical value +
- *
- * doc:
- * A nested value needs to be deallocated. The pointer passed in should
- * have been gotten from a call to @code{configFileLoad()} (See
- * @pxref{libopts-configFileLoad}).
-=*/
-void
-optionUnloadNested( tOptionValue const * pOV )
-{
- if (pOV == NULL) return;
- if (pOV->valType != OPARG_TYPE_HIERARCHY) {
- errno = EINVAL;
- return;
- }
-
- unloadNestedArglist( pOV->v.nestVal );
-
- AGFREE( (void*)pOV );
-}
-
-
-/* sortNestedList
- *
- * This is a _stable_ sort. The entries are sorted alphabetically,
- * but within entries of the same name the ordering is unchanged.
- * Typically, we also hope the input is sorted.
- */
-static void
-sortNestedList( tArgList* pAL )
-{
- int ix;
- int lm = pAL->useCt;
-
- /*
- * This loop iterates "useCt" - 1 times.
- */
- for (ix = 0; ++ix < lm;) {
- int iy = ix-1;
- tOptionValue* pNewNV = (tOptionValue*)(void*)(pAL->apzArgs[ix]);
- tOptionValue* pOldNV = (tOptionValue*)(void*)(pAL->apzArgs[iy]);
-
- /*
- * For as long as the new entry precedes the "old" entry,
- * move the old pointer. Stop before trying to extract the
- * "-1" entry.
- */
- while (strcmp( pOldNV->pzName, pNewNV->pzName ) > 0) {
- pAL->apzArgs[iy+1] = (void*)pOldNV;
- pOldNV = (tOptionValue*)(void*)(pAL->apzArgs[--iy]);
- if (iy < 0)
- break;
- }
-
- /*
- * Always store the pointer. Sometimes it is redundant,
- * but the redundancy is cheaper than a test and branch sequence.
- */
- pAL->apzArgs[iy+1] = (void*)pNewNV;
- }
-}
-
-
-/* optionLoadNested
- * private:
- *
- * what: parse a hierarchical option argument
- * arg: + char const* + pzTxt + the text to scan +
- * arg: + char const* + pzName + the name for the text +
- * arg: + size_t + nameLen + the length of "name" +
- *
- * ret_type: tOptionValue*
- * ret_desc: An allocated, compound value structure
- *
- * doc:
- * A block of text represents a series of values. It may be an
- * entire configuration file, or it may be an argument to an
- * option that takes a hierarchical value.
- */
-LOCAL tOptionValue*
-optionLoadNested(char const* pzTxt, char const* pzName, size_t nameLen)
-{
- tOptionValue* pRes;
- tArgList* pAL;
-
- /*
- * Make sure we have some data and we have space to put what we find.
- */
- if (pzTxt == NULL) {
- errno = EINVAL;
- return NULL;
- }
- while (IS_WHITESPACE_CHAR(*pzTxt)) pzTxt++;
- if (*pzTxt == NUL) {
- errno = ENOENT;
- return NULL;
- }
- pRes = AGALOC( sizeof(*pRes) + nameLen + 1, "nested args" );
- if (pRes == NULL) {
- errno = ENOMEM;
- return NULL;
- }
- pRes->valType = OPARG_TYPE_HIERARCHY;
- pRes->pzName = (char*)(pRes + 1);
- memcpy( pRes->pzName, pzName, nameLen );
- pRes->pzName[ nameLen ] = NUL;
-
- pAL = AGALOC( sizeof(*pAL), "nested arg list" );
- if (pAL == NULL) {
- AGFREE( pRes );
- return NULL;
- }
- pRes->v.nestVal = pAL;
- pAL->useCt = 0;
- pAL->allocCt = MIN_ARG_ALLOC_CT;
-
- /*
- * Scan until we hit a NUL.
- */
- do {
- while (IS_WHITESPACE_CHAR( (int)*pzTxt )) pzTxt++;
- if (IS_VAR_FIRST_CHAR( (int)*pzTxt )) {
- pzTxt = scanNameEntry( pzTxt, pRes );
- }
- else switch (*pzTxt) {
- case NUL: goto scan_done;
- case '<': pzTxt = scanXmlEntry( pzTxt, pRes );
- if (pzTxt == NULL) goto woops;
- if (*pzTxt == ',') pzTxt++; break;
- case '#': pzTxt = strchr( pzTxt, '\n' ); break;
- default: goto woops;
- }
- } while (pzTxt != NULL); scan_done:;
-
- pAL = pRes->v.nestVal;
- if (pAL->useCt != 0) {
- sortNestedList( pAL );
- return pRes;
- }
-
- woops:
- AGFREE( pRes->v.nestVal );
- AGFREE( pRes );
- return NULL;
-}
-
-
-/*=export_func optionNestedVal
- * private:
- *
- * what: parse a hierarchical option argument
- * arg: + tOptions* + pOpts + program options descriptor +
- * arg: + tOptDesc* + pOptDesc + the descriptor for this arg +
- *
- * doc:
- * Nested value was found on the command line
-=*/
-void
-optionNestedVal(tOptions* pOpts, tOptDesc* pOD)
-{
- if (pOpts < OPTPROC_EMIT_LIMIT)
- return;
-
- if (pOD->fOptState & OPTST_RESET) {
- tArgList* pAL = pOD->optCookie;
- int ct;
- tCC ** av;
-
- if (pAL == NULL)
- return;
- ct = pAL->useCt;
- av = pAL->apzArgs;
-
- while (--ct >= 0) {
- void * p = (void *)*(av++);
- optionUnloadNested((tOptionValue const *)p);
- }
-
- AGFREE(pOD->optCookie);
-
- } else {
- tOptionValue* pOV = optionLoadNested(
- pOD->optArg.argString, pOD->pz_Name, strlen(pOD->pz_Name));
-
- if (pOV != NULL)
- addArgListEntry( &(pOD->optCookie), (void*)pOV );
- }
-}
-
-
-/*
- * get_special_char
- */
-LOCAL int
-get_special_char(char const ** ppz, int * ct)
-{
- char const * pz = *ppz;
-
- if (*ct < 3)
- return '&';
-
- if (*pz == '#') {
- int base = 10;
- int retch;
-
- pz++;
- if (*pz == 'x') {
- base = 16;
- pz++;
- }
- retch = (int)strtoul(pz, (char **)&pz, base);
- if (*pz != ';')
- return '&';
- base = ++pz - *ppz;
- if (base > *ct)
- return '&';
-
- *ct -= base;
- *ppz = pz;
- return retch;
- }
-
- {
- int ctr = sizeof(xml_xlate) / sizeof(xml_xlate[0]);
- xml_xlate_t const * xlatp = xml_xlate;
-
- for (;;) {
- if ( (*ct >= xlatp->xml_len)
- && (strncmp(pz, xlatp->xml_txt, xlatp->xml_len) == 0)) {
- *ppz += xlatp->xml_len;
- *ct -= xlatp->xml_len;
- return xlatp->xml_ch;
- }
-
- if (--ctr <= 0)
- break;
- xlatp++;
- }
- }
- return '&';
-}
-
-
-/*
- * emit_special_char
- */
-LOCAL void
-emit_special_char(FILE * fp, int ch)
-{
- int ctr = sizeof(xml_xlate) / sizeof(xml_xlate[0]);
- xml_xlate_t const * xlatp = xml_xlate;
-
- putc('&', fp);
- for (;;) {
- if (ch == xlatp->xml_ch) {
- fputs(xlatp->xml_txt, fp);
- return;
- }
- if (--ctr <= 0)
- break;
- xlatp++;
- }
- fprintf(fp, "#x%02X;", (ch & 0xFF));
-}
-
-/*
- * Local Variables:
- * mode: C
- * c-file-style: "stroustrup"
- * indent-tabs-mode: nil
- * End:
- * end of autoopts/nested.c */
+++ /dev/null
-
-/*
- * $Id: 52d772d69bed7f2911d88ff17b9a44308d6ca0b1 $
- * Time-stamp: "2009-07-23 17:25:39 bkorb"
- *
- * This file is part of AutoOpts, a companion to AutoGen.
- * AutoOpts is free software.
- * AutoOpts is copyright (c) 1992-2009 by Bruce Korb - all rights reserved
- *
- * AutoOpts is available under any one of two licenses. The license
- * in use must be one of these two and the choice is under the control
- * of the user of the license.
- *
- * The GNU Lesser General Public License, version 3 or later
- * See the files "COPYING.lgplv3" and "COPYING.gplv3"
- *
- * The Modified Berkeley Software Distribution License
- * See the file "COPYING.mbsd"
- *
- * These files have the following md5sums:
- *
- * 43b91e8ca915626ed3818ffb1b71248b pkg/libopts/COPYING.gplv3
- * 06a1a2e4760c90ea5e1dad8dfaac4d39 pkg/libopts/COPYING.lgplv3
- * 66a5cedaf62c4b2637025f049f9b826f pkg/libopts/COPYING.mbsd
- */
-
-/*=export_func optionShowRange
- * private:
- *
- * what:
- * arg: + tOptions* + pOpts + program options descriptor +
- * arg: + tOptDesc* + pOptDesc + the descriptor for this arg +
- * arg: + void * + rng_table + the value range tables +
- * arg: + int + rng_count + the number of entries +
- *
- * doc:
- * Show information about a numeric option with range constraints.
-=*/
-void
-optionShowRange(tOptions* pOpts, tOptDesc* pOD, void * rng_table, int rng_ct)
-{
- static char const bullet[] = "\t\t\t\t- ";
- static char const deepin[] = "\t\t\t\t ";
- static char const onetab[] = "\t";
-
- const struct {long const rmin, rmax;} * rng = rng_table;
-
- char const * pz_indent =
- (pOpts != OPTPROC_EMIT_USAGE) ? onetab : bullet;
-
- if ((pOpts == OPTPROC_EMIT_USAGE) || (pOpts > OPTPROC_EMIT_LIMIT)) {
- char const * lie_in_range = zRangeLie;
-
- if (pOpts > OPTPROC_EMIT_LIMIT) {
- fprintf(option_usage_fp, zRangeErr,
- pOpts->pzProgName, pOD->pz_Name, pOD->optArg.argString);
- fprintf(option_usage_fp, "The %s option:\n", pOD->pz_Name);
- lie_in_range = zRangeBadLie;
- pz_indent = "";
- }
-
- if (pOD->fOptState & OPTST_SCALED_NUM)
- fprintf(option_usage_fp, zRangeScaled, pz_indent);
-
- if (rng_ct > 1) {
- fprintf(option_usage_fp, lie_in_range, pz_indent);
- pz_indent =
- (pOpts != OPTPROC_EMIT_USAGE) ? onetab : deepin;
-
- } else {
- fprintf(option_usage_fp, zRangeOnly, pz_indent);
- pz_indent = onetab + 1; /* empty string */
- }
-
- for (;;) {
- if (rng->rmax == LONG_MIN)
- fprintf(option_usage_fp, zRangeExact, pz_indent, rng->rmin);
- else if (rng->rmin == LONG_MIN)
- fprintf(option_usage_fp, zRangeUpto, pz_indent, rng->rmax);
- else if (rng->rmax == LONG_MAX)
- fprintf(option_usage_fp, zRangeAbove, pz_indent, rng->rmin);
- else
- fprintf(option_usage_fp, zRange, pz_indent, rng->rmin,
- rng->rmax);
-
- if (--rng_ct <= 0) {
- fputc('\n', option_usage_fp);
- break;
- }
- fputs(zRangeOr, option_usage_fp);
- rng++;
- pz_indent =
- (pOpts != OPTPROC_EMIT_USAGE) ? onetab : deepin;
- }
-
- if (pOpts > OPTPROC_EMIT_LIMIT)
- pOpts->pUsageProc(pOpts, EXIT_FAILURE);
- }
-}
-
-
-/*=export_func optionNumericVal
- * private:
- *
- * what: process an option with a numeric value.
- * arg: + tOptions* + pOpts + program options descriptor +
- * arg: + tOptDesc* + pOptDesc + the descriptor for this arg +
- *
- * doc:
- * Decipher a numeric value.
-=*/
-void
-optionNumericVal(tOptions* pOpts, tOptDesc* pOD )
-{
- char* pz;
- long val;
-
- /*
- * Numeric options may have a range associated with it.
- * If it does, the usage procedure requests that it be
- * emitted by passing a NULL pOD pointer. Also bail out
- * if there is no option argument or if we are being reset.
- */
- if ( (pOD == NULL)
- || (pOD->optArg.argString == NULL)
- || ((pOD->fOptState & OPTST_RESET) != 0))
- return;
-
- errno = 0;
- val = strtol(pOD->optArg.argString, &pz, 0);
- if ((pz == pOD->optArg.argString) || (errno != 0))
- goto bad_number;
-
- if ((pOD->fOptState & OPTST_SCALED_NUM) != 0)
- switch (*(pz++)) {
- case '\0': pz--; break;
- case 't': val *= 1000;
- case 'g': val *= 1000;
- case 'm': val *= 1000;
- case 'k': val *= 1000; break;
-
- case 'T': val *= 1024;
- case 'G': val *= 1024;
- case 'M': val *= 1024;
- case 'K': val *= 1024; break;
-
- default: goto bad_number;
- }
-
- if (*pz != NUL)
- goto bad_number;
-
- if (pOD->fOptState & OPTST_ALLOC_ARG) {
- AGFREE(pOD->optArg.argString);
- pOD->fOptState &= ~OPTST_ALLOC_ARG;
- }
-
- pOD->optArg.argInt = val;
- return;
-
- bad_number:
-
- fprintf( stderr, zNotNumber, pOpts->pzProgName, pOD->optArg.argString );
- if ((pOpts->fOptSet & OPTPROC_ERRSTOP) != 0)
- (*(pOpts->pUsageProc))(pOpts, EXIT_FAILURE);
-
- pOD->optArg.argInt = ~0;
-}
-
-/*
- * Local Variables:
- * mode: C
- * c-file-style: "stroustrup"
- * indent-tabs-mode: nil
- * End:
- * end of autoopts/numeric.c */
+++ /dev/null
-/* Parse a time duration and return a seconds count
- Copyright (C) 2008 Free Software Foundation, Inc.
- Written by Bruce Korb <bkorb@gnu.org>, 2008.
-
- 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 <http://www.gnu.org/licenses/>. */
-
-#include <config.h>
-
-#include <ctype.h>
-#include <errno.h>
-#include <limits.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "parse-duration.h"
-
-#ifndef _
-#define _(_s) _s
-#endif
-
-#ifndef NUL
-#define NUL '\0'
-#endif
-
-#define cch_t char const
-
-typedef enum {
- NOTHING_IS_DONE,
- YEAR_IS_DONE,
- MONTH_IS_DONE,
- WEEK_IS_DONE,
- DAY_IS_DONE,
- HOUR_IS_DONE,
- MINUTE_IS_DONE,
- SECOND_IS_DONE
-} whats_done_t;
-
-#define SEC_PER_MIN 60
-#define SEC_PER_HR (SEC_PER_MIN * 60)
-#define SEC_PER_DAY (SEC_PER_HR * 24)
-#define SEC_PER_WEEK (SEC_PER_DAY * 7)
-#define SEC_PER_MONTH (SEC_PER_DAY * 30)
-#define SEC_PER_YEAR (SEC_PER_DAY * 365)
-
-#define TIME_MAX 0x7FFFFFFF
-
-static unsigned long inline
-str_const_to_ul (cch_t * str, cch_t ** ppz, int base)
-{
- return strtoul (str, (char **)ppz, base);
-}
-
-static long inline
-str_const_to_l (cch_t * str, cch_t ** ppz, int base)
-{
- return strtol (str, (char **)ppz, base);
-}
-
-static time_t inline
-scale_n_add (time_t base, time_t val, int scale)
-{
- if (base == BAD_TIME)
- {
- if (errno == 0)
- errno = EINVAL;
- return BAD_TIME;
- }
-
- if (val > TIME_MAX / scale)
- {
- errno = ERANGE;
- return BAD_TIME;
- }
-
- val *= scale;
- if (base > TIME_MAX - val)
- {
- errno = ERANGE;
- return BAD_TIME;
- }
-
- return base + val;
-}
-
-static time_t
-parse_hr_min_sec (time_t start, cch_t * pz)
-{
- int lpct = 0;
-
- errno = 0;
-
- /* For as long as our scanner pointer points to a colon *AND*
- we've not looped before, then keep looping. (two iterations max) */
- while ((*pz == ':') && (lpct++ <= 1))
- {
- unsigned long v = str_const_to_ul (pz+1, &pz, 10);
-
- if (errno != 0)
- return BAD_TIME;
-
- start = scale_n_add (v, start, 60);
-
- if (errno != 0)
- return BAD_TIME;
- }
-
- /* allow for trailing spaces */
- while (isspace ((unsigned char)*pz)) pz++;
- if (*pz != NUL)
- {
- errno = EINVAL;
- return BAD_TIME;
- }
-
- return start;
-}
-
-static time_t
-parse_scaled_value (time_t base, cch_t ** ppz, cch_t * endp, int scale)
-{
- cch_t * pz = *ppz;
- time_t val;
-
- if (base == BAD_TIME)
- return base;
-
- errno = 0;
- val = str_const_to_ul (pz, &pz, 10);
- if (errno != 0)
- return BAD_TIME;
- while (isspace ((unsigned char)*pz)) pz++;
- if (pz != endp)
- {
- errno = EINVAL;
- return BAD_TIME;
- }
-
- *ppz = pz;
- return scale_n_add (base, val, scale);
-}
-
-static time_t
-parse_year_month_day (cch_t * pz, cch_t * ps)
-{
- time_t res = 0;
-
- res = parse_scaled_value (0, &pz, ps, SEC_PER_YEAR);
-
- ps = strchr (++pz, '-');
- if (ps == NULL)
- {
- errno = EINVAL;
- return BAD_TIME;
- }
- res = parse_scaled_value (res, &pz, ps, SEC_PER_MONTH);
-
- pz++;
- ps = pz + strlen (pz);
- return parse_scaled_value (res, &pz, ps, SEC_PER_DAY);
-}
-
-static time_t
-parse_yearmonthday (cch_t * in_pz)
-{
- time_t res = 0;
- char buf[8];
- cch_t * pz;
-
- if (strlen (in_pz) != 8)
- {
- errno = EINVAL;
- return BAD_TIME;
- }
-
- memcpy (buf, in_pz, 4);
- buf[4] = NUL;
- pz = buf;
- res = parse_scaled_value (0, &pz, buf + 4, SEC_PER_YEAR);
-
- memcpy (buf, in_pz + 4, 2);
- buf[2] = NUL;
- pz = buf;
- res = parse_scaled_value (res, &pz, buf + 2, SEC_PER_MONTH);
-
- memcpy (buf, in_pz + 6, 2);
- buf[2] = NUL;
- pz = buf;
- return parse_scaled_value (res, &pz, buf + 2, SEC_PER_DAY);
-}
-
-static time_t
-parse_YMWD (cch_t * pz)
-{
- time_t res = 0;
- cch_t * ps = strchr (pz, 'Y');
- if (ps != NULL)
- {
- res = parse_scaled_value (0, &pz, ps, SEC_PER_YEAR);
- pz++;
- }
-
- ps = strchr (pz, 'M');
- if (ps != NULL)
- {
- res = parse_scaled_value (res, &pz, ps, SEC_PER_MONTH);
- pz++;
- }
-
- ps = strchr (pz, 'W');
- if (ps != NULL)
- {
- res = parse_scaled_value (res, &pz, ps, SEC_PER_WEEK);
- pz++;
- }
-
- ps = strchr (pz, 'D');
- if (ps != NULL)
- {
- res = parse_scaled_value (res, &pz, ps, SEC_PER_DAY);
- pz++;
- }
-
- while (isspace ((unsigned char)*pz)) pz++;
- if (*pz != NUL)
- {
- errno = EINVAL;
- return BAD_TIME;
- }
-
- return res;
-}
-
-static time_t
-parse_hour_minute_second (cch_t * pz, cch_t * ps)
-{
- time_t res = 0;
-
- res = parse_scaled_value (0, &pz, ps, SEC_PER_HR);
-
- ps = strchr (++pz, ':');
- if (ps == NULL)
- {
- errno = EINVAL;
- return BAD_TIME;
- }
-
- res = parse_scaled_value (res, &pz, ps, SEC_PER_MIN);
-
- pz++;
- ps = pz + strlen (pz);
- return parse_scaled_value (res, &pz, ps, 1);
-}
-
-static time_t
-parse_hourminutesecond (cch_t * in_pz)
-{
- time_t res = 0;
- char buf[4];
- cch_t * pz;
-
- if (strlen (in_pz) != 6)
- {
- errno = EINVAL;
- return BAD_TIME;
- }
-
- memcpy (buf, in_pz, 2);
- buf[2] = NUL;
- pz = buf;
- res = parse_scaled_value (0, &pz, buf + 2, SEC_PER_HR);
-
- memcpy (buf, in_pz + 2, 2);
- buf[2] = NUL;
- pz = buf;
- res = parse_scaled_value (res, &pz, buf + 2, SEC_PER_MIN);
-
- memcpy (buf, in_pz + 4, 2);
- buf[2] = NUL;
- pz = buf;
- return parse_scaled_value (res, &pz, buf + 2, 1);
-}
-
-static time_t
-parse_HMS (cch_t * pz)
-{
- time_t res = 0;
- cch_t * ps = strchr (pz, 'H');
- if (ps != NULL)
- {
- res = parse_scaled_value (0, &pz, ps, SEC_PER_HR);
- pz++;
- }
-
- ps = strchr (pz, 'M');
- if (ps != NULL)
- {
- res = parse_scaled_value (res, &pz, ps, SEC_PER_MIN);
- pz++;
- }
-
- ps = strchr (pz, 'S');
- if (ps != NULL)
- {
- res = parse_scaled_value (res, &pz, ps, 1);
- pz++;
- }
-
- while (isspace ((unsigned char)*pz)) pz++;
- if (*pz != NUL)
- {
- errno = EINVAL;
- return BAD_TIME;
- }
-
- return res;
-}
-
-static time_t
-parse_time (cch_t * pz)
-{
- cch_t * ps;
- time_t res = 0;
-
- /*
- * Scan for a hyphen
- */
- ps = strchr (pz, ':');
- if (ps != NULL)
- {
- res = parse_hour_minute_second (pz, ps);
- }
-
- /*
- * Try for a 'H', 'M' or 'S' suffix
- */
- else if (ps = strpbrk (pz, "HMS"),
- ps == NULL)
- {
- /* Its a YYYYMMDD format: */
- res = parse_hourminutesecond (pz);
- }
-
- else
- res = parse_HMS (pz);
-
- return res;
-}
-
-static char *
-trim(char * pz)
-{
- /* trim leading white space */
- while (isspace ((unsigned char)*pz)) pz++;
-
- /* trim trailing white space */
- {
- char * pe = pz + strlen (pz);
- while ((pe > pz) && isspace ((unsigned char)pe[-1])) pe--;
- *pe = NUL;
- }
-
- return pz;
-}
-
-/*
- * Parse the year/months/days of a time period
- */
-static time_t
-parse_period (cch_t * in_pz)
-{
- char * pz = xstrdup (in_pz);
- char * pT = strchr (pz, 'T');
- char * ps;
- void * fptr = pz;
- time_t res = 0;
-
- if (pT != NUL)
- {
- *(pT++) = NUL;
- pz = trim (pz);
- pT = trim (pT);
- }
-
- /*
- * Scan for a hyphen
- */
- ps = strchr (pz, '-');
- if (ps != NULL)
- {
- res = parse_year_month_day (pz, ps);
- }
-
- /*
- * Try for a 'Y', 'M' or 'D' suffix
- */
- else if (ps = strpbrk (pz, "YMWD"),
- ps == NULL)
- {
- /* Its a YYYYMMDD format: */
- res = parse_yearmonthday (pz);
- }
-
- else
- res = parse_YMWD (pz);
-
- if ((errno == 0) && (pT != NULL))
- {
- time_t val = parse_time (pT);
- res = scale_n_add (res, val, 1);
- }
-
- free (fptr);
- return res;
-}
-
-static time_t
-parse_non_iso8601(cch_t * pz)
-{
- whats_done_t whatd_we_do = NOTHING_IS_DONE;
-
- time_t res = 0;
-
- do {
- time_t val;
-
- errno = 0;
- val = str_const_to_l (pz, &pz, 10);
- if (errno != 0)
- goto bad_time;
-
- /* IF we find a colon, then we're going to have a seconds value.
- We will not loop here any more. We cannot already have parsed
- a minute value and if we've parsed an hour value, then the result
- value has to be less than an hour. */
- if (*pz == ':')
- {
- if (whatd_we_do >= MINUTE_IS_DONE)
- break;
-
- val = parse_hr_min_sec (val, pz);
-
- if ((whatd_we_do == HOUR_IS_DONE) && (val >= SEC_PER_HR))
- break;
-
- return scale_n_add (res, val, 1);
- }
-
- {
- unsigned int mult;
-
- /* Skip over white space following the number we just parsed. */
- while (isspace ((unsigned char)*pz)) pz++;
-
- switch (*pz)
- {
- default: goto bad_time;
- case NUL:
- return scale_n_add (res, val, 1);
-
- case 'y': case 'Y':
- if (whatd_we_do >= YEAR_IS_DONE)
- goto bad_time;
- mult = SEC_PER_YEAR;
- whatd_we_do = YEAR_IS_DONE;
- break;
-
- case 'M':
- if (whatd_we_do >= MONTH_IS_DONE)
- goto bad_time;
- mult = SEC_PER_MONTH;
- whatd_we_do = MONTH_IS_DONE;
- break;
-
- case 'W':
- if (whatd_we_do >= WEEK_IS_DONE)
- goto bad_time;
- mult = SEC_PER_WEEK;
- whatd_we_do = WEEK_IS_DONE;
- break;
-
- case 'd': case 'D':
- if (whatd_we_do >= DAY_IS_DONE)
- goto bad_time;
- mult = SEC_PER_DAY;
- whatd_we_do = DAY_IS_DONE;
- break;
-
- case 'h':
- if (whatd_we_do >= HOUR_IS_DONE)
- goto bad_time;
- mult = SEC_PER_HR;
- whatd_we_do = HOUR_IS_DONE;
- break;
-
- case 'm':
- if (whatd_we_do >= MINUTE_IS_DONE)
- goto bad_time;
- mult = SEC_PER_MIN;
- whatd_we_do = MINUTE_IS_DONE;
- break;
-
- case 's':
- mult = 1;
- whatd_we_do = SECOND_IS_DONE;
- break;
- }
-
- res = scale_n_add (res, val, mult);
-
- while (isspace ((unsigned char)*++pz)) ;
- if (*pz == NUL)
- return res;
-
- if (! isdigit ((unsigned char)*pz))
- break;
- }
-
- } while (whatd_we_do < SECOND_IS_DONE);
-
- bad_time:
- errno = EINVAL;
- return BAD_TIME;
-}
-
-time_t
-parse_duration (char const * pz)
-{
- time_t res = 0;
-
- while (isspace ((unsigned char)*pz)) pz++;
-
- do {
- if (*pz == 'P')
- {
- res = parse_period (pz + 1);
- if ((errno != 0) || (res == BAD_TIME))
- break;
- return res;
- }
-
- if (*pz == 'T')
- {
- res = parse_time (pz + 1);
- if ((errno != 0) || (res == BAD_TIME))
- break;
- return res;
- }
-
- if (! isdigit ((unsigned char)*pz))
- break;
-
- res = parse_non_iso8601 (pz);
- if ((errno == 0) && (res != BAD_TIME))
- return res;
-
- } while (0);
-
- fprintf (stderr, _("Invalid time duration: %s\n"), pz);
- if (errno == 0)
- errno = EINVAL;
- return BAD_TIME;
-}
-
-/*
- * Local Variables:
- * mode: C
- * c-file-style: "gnu"
- * indent-tabs-mode: nil
- * End:
- * end of parse-duration.c */
+++ /dev/null
-/* Parse a time duration and return a seconds count
- Copyright (C) 2008 Free Software Foundation, Inc.
- Written by Bruce Korb <bkorb@gnu.org>, 2008.
-
- 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 <http://www.gnu.org/licenses/>. */
-
-/*
-
- Readers and users of this function are referred to the ISO-8601
- specification, with particular attention to "Durations".
-
- At the time of writing, this worked:
-
- http://en.wikipedia.org/wiki/ISO_8601#Durations
-
- The string must start with a 'P', 'T' or a digit.
-
- ==== if it is a digit
-
- the string may contain: NNN d NNN h NNN m NNN s
- This represents NNN days, NNN hours, NNN minutes and NNN seconds.
- The embeded white space is optional.
- These terms must appear in this order.
- The final "s" is optional.
- All of the terms ("NNN" plus designator) are optional.
- Minutes and seconds may optionally be represented as NNN:NNN.
- Also, hours, minute and seconds may be represented as NNN:NNN:NNN.
- There is no limitation on the value of any of the terms, except
- that the final result must fit in a time_t value.
-
- ==== if it is a 'P' or 'T', please see ISO-8601 for a rigorous definition.
-
- The 'P' term may be followed by any of three formats:
- yyyymmdd
- yy-mm-dd
- yy Y mm M ww W dd D
-
- or it may be empty and followed by a 'T'. The "yyyymmdd" must be eight
- digits long. Note: months are always 30 days and years are always 365
- days long. 5 years is always 1825, not 1826 or 1827 depending on leap
- year considerations. 3 months is always 90 days. There is no consideration
- for how many days are in the current, next or previous months.
-
- For the final format:
- * Embedded white space is allowed, but it is optional.
- * All of the terms are optional. Any or all-but-one may be omitted.
- * The meanings are yy years, mm months, ww weeks and dd days.
- * The terms must appear in this order.
-
- ==== The 'T' term may be followed by any of these formats:
-
- hhmmss
- hh:mm:ss
- hh H mm M ss S
-
- For the final format:
- * Embedded white space is allowed, but it is optional.
- * All of the terms are optional. Any or all-but-one may be omitted.
- * The terms must appear in this order.
-
- */
-#ifndef GNULIB_PARSE_DURATION_H
-#define GNULIB_PARSE_DURATION_H
-
-#include <time.h>
-
-#define BAD_TIME ((time_t)~0)
-
-extern time_t parse_duration(char const * in_pz);
-
-#endif /* GNULIB_PARSE_DURATION_H */
+++ /dev/null
-
-/*
- * $Id: da09fc943da953195b243b7697fdbf5127f5b6c2 $
- * Time-stamp: "2009-11-01 11:52:51 bkorb"
- *
- * Automated Options Paged Usage module.
- *
- * This routine will run run-on options through a pager so the
- * user may examine, print or edit them at their leisure.
- *
- * This file is part of AutoOpts, a companion to AutoGen.
- * AutoOpts is free software.
- * AutoOpts is copyright (c) 1992-2009 by Bruce Korb - all rights reserved
- *
- * AutoOpts is available under any one of two licenses. The license
- * in use must be one of these two and the choice is under the control
- * of the user of the license.
- *
- * The GNU Lesser General Public License, version 3 or later
- * See the files "COPYING.lgplv3" and "COPYING.gplv3"
- *
- * The Modified Berkeley Software Distribution License
- * See the file "COPYING.mbsd"
- *
- * These files have the following md5sums:
- *
- * 43b91e8ca915626ed3818ffb1b71248b pkg/libopts/COPYING.gplv3
- * 06a1a2e4760c90ea5e1dad8dfaac4d39 pkg/libopts/COPYING.lgplv3
- * 66a5cedaf62c4b2637025f049f9b826f pkg/libopts/COPYING.mbsd
- */
-
-tePagerState pagerState = PAGER_STATE_INITIAL;
-
-/*=export_func optionPagedUsage
- * private:
- *
- * what: Decipher a boolean value
- * arg: + tOptions* + pOpts + program options descriptor +
- * arg: + tOptDesc* + pOptDesc + the descriptor for this arg +
- *
- * doc:
- * Run the usage output through a pager.
- * This is very handy if it is very long.
- * This is disabled on platforms without a working fork() function.
-=*/
-void
-optionPagedUsage( tOptions* pOptions, tOptDesc* pOD )
-{
-#if ! defined(HAVE_WORKING_FORK)
- if ((pOD->fOptState & OPTST_RESET) != 0)
- return;
-
- (*pOptions->pUsageProc)( pOptions, EXIT_SUCCESS );
-#else
- static pid_t my_pid;
- char zPageUsage[ 1024 ];
-
- /*
- * IF we are being called after the usage proc is done
- * (and thus has called "exit(2)")
- * THEN invoke the pager to page through the usage file we created.
- */
- switch (pagerState) {
- case PAGER_STATE_INITIAL:
- {
- if ((pOD->fOptState & OPTST_RESET) != 0)
- return;
-
- my_pid = getpid();
-#ifdef HAVE_SNPRINTF
- snprintf(zPageUsage, sizeof(zPageUsage), "/tmp/use.%lu", (tAoUL)my_pid);
-#else
- sprintf( zPageUsage, "/tmp/use.%lu", (tAoUL)my_pid );
-#endif
- unlink( zPageUsage );
-
- /*
- * Set usage output to this temporary file
- */
- option_usage_fp = fopen( zPageUsage, "w" FOPEN_BINARY_FLAG );
- if (option_usage_fp == NULL)
- _exit( EXIT_FAILURE );
-
- pagerState = PAGER_STATE_READY;
-
- /*
- * Set up so this routine gets called during the exit logic
- */
- atexit( (void(*)(void))optionPagedUsage );
-
- /*
- * The usage procedure will now put the usage information into
- * the temporary file we created above.
- */
- (*pOptions->pUsageProc)( pOptions, EXIT_SUCCESS );
-
- /* NOTREACHED */
- _exit( EXIT_FAILURE );
- }
-
- case PAGER_STATE_READY:
- {
- tSCC zPage[] = "%1$s /tmp/use.%2$lu ; rm -f /tmp/use.%2$lu";
- tCC* pzPager = (tCC*)getenv( "PAGER" );
-
- /*
- * Use the "more(1)" program if "PAGER" has not been defined
- */
- if (pzPager == NULL)
- pzPager = "more";
-
- /*
- * Page the file and remove it when done.
- */
-#ifdef HAVE_SNPRINTF
- snprintf(zPageUsage, sizeof(zPageUsage), zPage, pzPager, (tAoUL)my_pid);
-#else
- sprintf( zPageUsage, zPage, pzPager, (tAoUL)my_pid );
-#endif
- fclose( stderr );
- dup2( STDOUT_FILENO, STDERR_FILENO );
-
- (void)system( zPageUsage );
- }
-
- case PAGER_STATE_CHILD:
- /*
- * This is a child process used in creating shell script usage.
- */
- break;
- }
-#endif
-}
-
-/*
- * Local Variables:
- * mode: C
- * c-file-style: "stroustrup"
- * indent-tabs-mode: nil
- * End:
- * end of autoopts/pgusage.c */
+++ /dev/null
-/* -*- buffer-read-only: t -*- vi: set ro:
- *
- * Prototypes for autoopts
- * Generated Sun Nov 8 08:41:10 PST 2009
- */
-#ifndef AUTOOPTS_PROTO_H_GUARD
-#define AUTOOPTS_PROTO_H_GUARD 1
-
-#ifndef LOCAL
-# define LOCAL extern
-# define REDEF_LOCAL 1
-#else
-# undef REDEF_LOCAL
-#endif
-/*
- * Extracted from autoopts.c
- */
-LOCAL void *
-ao_malloc( size_t sz );
-
-LOCAL void *
-ao_realloc( void *p, size_t sz );
-
-LOCAL void
-ao_free( void *p );
-
-LOCAL char *
-ao_strdup( char const *str );
-
-LOCAL tSuccess
-handleOption( tOptions* pOpts, tOptState* pOptState );
-
-LOCAL tSuccess
-longOptionFind( tOptions* pOpts, char* pzOptName, tOptState* pOptState );
-
-LOCAL tSuccess
-shortOptionFind( tOptions* pOpts, uint_t optValue, tOptState* pOptState );
-
-LOCAL tSuccess
-doImmediateOpts( tOptions* pOpts );
-
-LOCAL tSuccess
-doRegularOpts( tOptions* pOpts );
-
-/*
- * Extracted from configfile.c
- */
-LOCAL void
-internalFileLoad( tOptions* pOpts );
-
-LOCAL char*
-parseAttributes(
- tOptions* pOpts,
- char* pzText,
- tOptionLoadMode* pMode,
- tOptionValue* pType );
-
-LOCAL tSuccess
-validateOptionsStruct( tOptions* pOpts, char const* pzProgram );
-
-/*
- * Extracted from environment.c
- */
-LOCAL void
-doPrognameEnv( tOptions* pOpts, teEnvPresetType type );
-
-LOCAL void
-doEnvPresets( tOptions* pOpts, teEnvPresetType type );
-
-/*
- * Extracted from load.c
- */
-LOCAL void
-mungeString( char* pzTxt, tOptionLoadMode mode );
-
-LOCAL void
-loadOptionLine(
- tOptions* pOpts,
- tOptState* pOS,
- char* pzLine,
- tDirection direction,
- tOptionLoadMode load_mode );
-
-/*
- * Extracted from nested.c
- */
-LOCAL tOptionValue*
-optionLoadNested(char const* pzTxt, char const* pzName, size_t nameLen);
-
-LOCAL int
-get_special_char(char const ** ppz, int * ct);
-
-LOCAL void
-emit_special_char(FILE * fp, int ch);
-
-/*
- * Extracted from sort.c
- */
-LOCAL void
-optionSort( tOptions* pOpts );
-
-/*
- * Extracted from stack.c
- */
-LOCAL void
-addArgListEntry( void** ppAL, void* entry );
-
-#ifdef REDEF_LOCAL
-# undef LOCAL
-# define LOCAL
-#endif
-#endif /* AUTOOPTS_PROTO_H_GUARD */
+++ /dev/null
-
-/*
- * $Id: 5d14243d5d32d234f05bc8a20b1a6464716b30aa $
- * Time-stamp: "2008-07-27 12:14:38 bkorb"
- *
- * This module will interpret the options set in the tOptions
- * structure and print them to standard out in a fashion that
- * will allow them to be interpreted by the Bourne or Korn shells.
- *
- * This file is part of AutoOpts, a companion to AutoGen.
- * AutoOpts is free software.
- * AutoOpts is copyright (c) 1992-2009 by Bruce Korb - all rights reserved
- *
- * AutoOpts is available under any one of two licenses. The license
- * in use must be one of these two and the choice is under the control
- * of the user of the license.
- *
- * The GNU Lesser General Public License, version 3 or later
- * See the files "COPYING.lgplv3" and "COPYING.gplv3"
- *
- * The Modified Berkeley Software Distribution License
- * See the file "COPYING.mbsd"
- *
- * These files have the following md5sums:
- *
- * 43b91e8ca915626ed3818ffb1b71248b pkg/libopts/COPYING.gplv3
- * 06a1a2e4760c90ea5e1dad8dfaac4d39 pkg/libopts/COPYING.lgplv3
- * 66a5cedaf62c4b2637025f049f9b826f pkg/libopts/COPYING.mbsd
- */
-
-/* = = = START-STATIC-FORWARD = = = */
-/* static forward declarations maintained by mk-fwd */
-static void
-putQuotedStr( tCC* pzStr );
-/* = = = END-STATIC-FORWARD = = = */
-
-/*
- * Make sure embedded single quotes come out okay. The initial quote has
- * been emitted and the closing quote will be upon return.
- */
-static void
-putQuotedStr( tCC* pzStr )
-{
- /*
- * Handle empty strings to make the rest of the logic simpler.
- */
- if ((pzStr == NULL) || (*pzStr == NUL)) {
- fputs( "''", stdout );
- return;
- }
-
- /*
- * Emit any single quotes/apostrophes at the start of the string and
- * bail if that is all we need to do.
- */
- while (*pzStr == '\'') {
- fputs( "\\'", stdout );
- pzStr++;
- }
- if (*pzStr == NUL)
- return;
-
- /*
- * Start the single quote string
- */
- fputc( '\'', stdout );
- for (;;) {
- tCC* pz = strchr( pzStr, '\'' );
- if (pz == NULL)
- break;
-
- /*
- * Emit the string up to the single quote (apostrophe) we just found.
- */
- (void)fwrite( pzStr, (size_t)(pz - pzStr), (size_t)1, stdout );
- fputc( '\'', stdout );
- pzStr = pz;
-
- /*
- * Emit an escaped apostrophe for every one we find.
- * If that ends the string, do not re-open the single quotes.
- */
- while (*++pzStr == '\'') fputs( "\\'", stdout );
- if (*pzStr == NUL)
- return;
-
- fputc( '\'', stdout );
- }
-
- /*
- * If we broke out of the loop, we must still emit the remaining text
- * and then close the single quote string.
- */
- fputs( pzStr, stdout );
- fputc( '\'', stdout );
-}
-
-
-/*=export_func optionPutShell
- * what: write a portable shell script to parse options
- * private:
- * arg: tOptions*, pOpts, the program options descriptor
- * doc: This routine will emit portable shell script text for parsing
- * the options described in the option definitions.
-=*/
-void
-optionPutShell( tOptions* pOpts )
-{
- int optIx = 0;
- tSCC zOptCtFmt[] = "OPTION_CT=%d\nexport OPTION_CT\n";
- tSCC zOptNumFmt[] = "%1$s_%2$s=%3$d # 0x%3$X\nexport %1$s_%2$s\n";
- tSCC zOptDisabl[] = "%1$s_%2$s=%3$s\nexport %1$s_%2$s\n";
- tSCC zOptValFmt[] = "%s_%s=";
- tSCC zOptEnd[] = "\nexport %s_%s\n";
- tSCC zFullOptFmt[]= "%1$s_%2$s='%3$s'\nexport %1$s_%2$s\n";
- tSCC zEquivMode[] = "%1$s_%2$s_MODE='%3$s'\nexport %1$s_%2$s_MODE\n";
-
- printf( zOptCtFmt, pOpts->curOptIdx-1 );
-
- do {
- tOptDesc* pOD = pOpts->pOptDesc + optIx;
-
- if (SKIP_OPT(pOD))
- continue;
-
- /*
- * Equivalence classes are hard to deal with. Where the
- * option data wind up kind of squishes around. For the purposes
- * of emitting shell state, they are not recommended, but we'll
- * do something. I guess we'll emit the equivalenced-to option
- * at the point in time when the base option is found.
- */
- if (pOD->optEquivIndex != NO_EQUIVALENT)
- continue; /* equivalence to a different option */
-
- /*
- * Equivalenced to a different option. Process the current option
- * as the equivalenced-to option. Keep the persistent state bits,
- * but copy over the set-state bits.
- */
- if (pOD->optActualIndex != optIx) {
- tOptDesc* p = pOpts->pOptDesc + pOD->optActualIndex;
- p->optArg = pOD->optArg;
- p->fOptState &= OPTST_PERSISTENT_MASK;
- p->fOptState |= pOD->fOptState & ~OPTST_PERSISTENT_MASK;
- printf( zEquivMode, pOpts->pzPROGNAME, pOD->pz_NAME, p->pz_NAME );
- pOD = p;
- }
-
- /*
- * If the argument type is a set membership bitmask, then we always
- * emit the thing. We do this because it will always have some sort
- * of bitmask value and we need to emit the bit values.
- */
- if (OPTST_GET_ARGTYPE(pOD->fOptState) == OPARG_TYPE_MEMBERSHIP) {
- char const * pz;
- uintptr_t val = 1;
- printf( zOptNumFmt, pOpts->pzPROGNAME, pOD->pz_NAME,
- (int)(uintptr_t)(pOD->optCookie) );
- pOD->optCookie = (void*)(uintptr_t)~0UL;
- (*(pOD->pOptProc))(OPTPROC_RETURN_VALNAME, pOD);
-
- /*
- * We are building the typeset list. The list returned starts with
- * 'none + ' for use by option saving stuff. We must ignore that.
- */
- pz = pOD->optArg.argString + 7;
- while (*pz != NUL) {
- printf( "typeset -x -i %s_", pOD->pz_NAME );
- while (IS_PLUS_N_SPACE_CHAR(*pz)) pz++;
-
- for (;;) {
- int ch = *(pz++);
- if (IS_LOWER_CASE_CHAR(ch)) fputc(toupper(ch), stdout);
- else if (IS_UPPER_CASE_CHAR(ch)) fputc(ch, stdout);
- else if (IS_PLUS_N_SPACE_CHAR(ch)) goto name_done;
- else if (ch == NUL) { pz--; goto name_done; }
- else fputc( '_', stdout );
- } name_done:;
- printf( "=%1$lu # 0x%1$lX\n", (unsigned long)val );
- val <<= 1;
- }
-
- AGFREE(pOD->optArg.argString);
- pOD->optArg.argString = NULL;
- pOD->fOptState &= ~OPTST_ALLOC_ARG;
- continue;
- }
-
- /*
- * IF the option was either specified or it wakes up enabled,
- * then we will emit information. Otherwise, skip it.
- * The idea is that if someone defines an option to initialize
- * enabled, we should tell our shell script that it is enabled.
- */
- if (UNUSED_OPT( pOD ) && DISABLED_OPT( pOD ))
- continue;
-
- /*
- * Handle stacked arguments
- */
- if ( (pOD->fOptState & OPTST_STACKED)
- && (pOD->optCookie != NULL) ) {
- tSCC zOptCookieCt[] = "%1$s_%2$s_CT=%3$d\nexport %1$s_%2$s_CT\n";
-
- tArgList* pAL = (tArgList*)pOD->optCookie;
- tCC** ppz = pAL->apzArgs;
- int ct = pAL->useCt;
-
- printf( zOptCookieCt, pOpts->pzPROGNAME, pOD->pz_NAME, ct );
-
- while (--ct >= 0) {
- tSCC numarg_z[] = "%s_%s_%d=";
- tSCC end_z[] = "\nexport %s_%s_%d\n";
-
- printf( numarg_z, pOpts->pzPROGNAME, pOD->pz_NAME,
- pAL->useCt - ct );
- putQuotedStr( *(ppz++) );
- printf( end_z, pOpts->pzPROGNAME, pOD->pz_NAME,
- pAL->useCt - ct );
- }
- }
-
- /*
- * If the argument has been disabled,
- * Then set its value to the disablement string
- */
- else if ((pOD->fOptState & OPTST_DISABLED) != 0)
- printf( zOptDisabl, pOpts->pzPROGNAME, pOD->pz_NAME,
- (pOD->pz_DisablePfx != NULL)
- ? pOD->pz_DisablePfx : "false" );
-
- /*
- * If the argument type is numeric, the last arg pointer
- * is really the VALUE of the string that was pointed to.
- */
- else if (OPTST_GET_ARGTYPE(pOD->fOptState) == OPARG_TYPE_NUMERIC)
- printf( zOptNumFmt, pOpts->pzPROGNAME, pOD->pz_NAME,
- (int)pOD->optArg.argInt );
-
- /*
- * If the argument type is an enumeration, then it is much
- * like a text value, except we call the callback function
- * to emit the value corresponding to the "optArg" number.
- */
- else if (OPTST_GET_ARGTYPE(pOD->fOptState) == OPARG_TYPE_ENUMERATION) {
- uintptr_t e_val = pOD->optArg.argEnum;
- printf( zOptValFmt, pOpts->pzPROGNAME, pOD->pz_NAME );
-
- /*
- * Convert value to string, print that and restore numeric value.
- */
- (*(pOD->pOptProc))(OPTPROC_RETURN_VALNAME, pOD);
- printf("'%s'", pOD->optArg.argString);
- if (pOD->fOptState & OPTST_ALLOC_ARG)
- AGFREE(pOD->optArg.argString);
- pOD->optArg.argEnum = e_val;
-
- printf(zOptEnd, pOpts->pzPROGNAME, pOD->pz_NAME);
- }
-
- /*
- * If the argument type is numeric, the last arg pointer
- * is really the VALUE of the string that was pointed to.
- */
- else if (OPTST_GET_ARGTYPE(pOD->fOptState) == OPARG_TYPE_BOOLEAN)
- printf( zFullOptFmt, pOpts->pzPROGNAME, pOD->pz_NAME,
- (pOD->optArg.argBool == 0) ? "false" : "true" );
-
- /*
- * IF the option has an empty value,
- * THEN we set the argument to the occurrence count.
- */
- else if ( (pOD->optArg.argString == NULL)
- || (pOD->optArg.argString[0] == NUL) )
-
- printf( zOptNumFmt, pOpts->pzPROGNAME, pOD->pz_NAME,
- pOD->optOccCt );
-
- /*
- * This option has a text value
- */
- else {
- printf( zOptValFmt, pOpts->pzPROGNAME, pOD->pz_NAME );
- putQuotedStr( pOD->optArg.argString );
- printf( zOptEnd, pOpts->pzPROGNAME, pOD->pz_NAME );
- }
- } while (++optIx < pOpts->presetOptCt );
-
- if ( ((pOpts->fOptSet & OPTPROC_REORDER) != 0)
- && (pOpts->curOptIdx < pOpts->origArgCt)) {
- fputs( "set --", stdout );
- for (optIx = pOpts->curOptIdx; optIx < pOpts->origArgCt; optIx++) {
- char* pzArg = pOpts->origArgVect[ optIx ];
- if (strchr( pzArg, '\'' ) == NULL)
- printf( " '%s'", pzArg );
- else {
- fputs( " '", stdout );
- for (;;) {
- char ch = *(pzArg++);
- switch (ch) {
- case '\'': fputs( "'\\''", stdout ); break;
- case NUL: goto arg_done;
- default: fputc( ch, stdout ); break;
- }
- } arg_done:;
- fputc( '\'', stdout );
- }
- }
- fputs( "\nOPTION_CT=0\n", stdout );
- }
-}
-
-/*
- * Local Variables:
- * mode: C
- * c-file-style: "stroustrup"
- * indent-tabs-mode: nil
- * End:
- * end of autoopts/putshell.c */
+++ /dev/null
-
-/*
- * $Id: 808e536555f06924b450ab6b5a72c03b67c5b99a $
- * Time-stamp: "2009-11-01 11:45:57 bkorb"
- *
- * This file is part of AutoOpts, a companion to AutoGen.
- * AutoOpts is free software.
- * AutoOpts is copyright (c) 1992-2009 by Bruce Korb - all rights reserved
- *
- * AutoOpts is available under any one of two licenses. The license
- * in use must be one of these two and the choice is under the control
- * of the user of the license.
- *
- * The GNU Lesser General Public License, version 3 or later
- * See the files "COPYING.lgplv3" and "COPYING.gplv3"
- *
- * The Modified Berkeley Software Distribution License
- * See the file "COPYING.mbsd"
- *
- * These files have the following md5sums:
- *
- * 43b91e8ca915626ed3818ffb1b71248b pkg/libopts/COPYING.gplv3
- * 06a1a2e4760c90ea5e1dad8dfaac4d39 pkg/libopts/COPYING.lgplv3
- * 66a5cedaf62c4b2637025f049f9b826f pkg/libopts/COPYING.mbsd
- */
-
-static void
-optionReset( tOptions* pOpts, tOptDesc* pOD )
-{
- pOD->fOptState &= OPTST_PERSISTENT_MASK;
- pOD->fOptState |= OPTST_RESET;
- if (pOD->pOptProc != NULL)
- pOD->pOptProc(pOpts, pOD);
- pOD->optArg.argString =
- pOpts->originalOptArgArray[ pOD->optIndex ].argString;
- pOD->optCookie = pOpts->originalOptArgCookie[ pOD->optIndex ];
- pOD->fOptState &= OPTST_PERSISTENT_MASK;
-}
-
-
-static void
-optionResetEverything(tOptions * pOpts)
-{
- tOptDesc * pOD = pOpts->pOptDesc;
- int ct = pOpts->presetOptCt;
-
- for (;;) {
- optionReset(pOpts, pOD);
-
- if (--ct <= 0)
- break;
- pOD++;
- }
-}
-
-
-/*=export_func optionResetOpt
- * private:
- *
- * what: Reset the value of an option
- * arg: + tOptions* + pOpts + program options descriptor +
- * arg: + tOptDesc* + pOptDesc + the descriptor for this arg +
- *
- * doc:
- * This code will cause another option to be reset to its initial state.
- * For example, --reset=foo will cause the --foo option to be reset.
-=*/
-void
-optionResetOpt( tOptions* pOpts, tOptDesc* pOD )
-{
- static ag_bool reset_active = AG_FALSE;
-
- tOptState opt_state = OPTSTATE_INITIALIZER(DEFINED);
- char const * pzArg = pOD->optArg.argString;
- tSuccess succ;
-
- if (reset_active)
- return;
-
- if ( (! HAS_originalOptArgArray(pOpts))
- || (pOpts->originalOptArgCookie == NULL)) {
- fputs(zResetNotConfig, stderr);
- _exit(EX_SOFTWARE);
- }
-
- if ((pzArg == NULL) || (*pzArg == NUL)) {
- fputs(zNoResetArg, stderr);
- pOpts->pUsageProc(pOpts, EXIT_FAILURE);
- /* NOTREACHED */
- assert(0 == 1);
- }
-
- reset_active = AG_TRUE;
-
- if (pzArg[1] == NUL) {
- if (*pzArg == '*') {
- optionResetEverything(pOpts);
- reset_active = AG_FALSE;
- return;
- }
-
- succ = shortOptionFind(pOpts, (tAoUC)*pzArg, &opt_state);
- if (! SUCCESSFUL(succ)) {
- fprintf(stderr, zIllOptChr, pOpts->pzProgPath, *pzArg);
- pOpts->pUsageProc(pOpts, EXIT_FAILURE);
- /* NOTREACHED */
- assert(0 == 1);
- }
- } else {
- succ = longOptionFind(pOpts, (char *)pzArg, &opt_state);
- if (! SUCCESSFUL(succ)) {
- fprintf(stderr, zIllOptStr, pOpts->pzProgPath, pzArg);
- pOpts->pUsageProc(pOpts, EXIT_FAILURE);
- /* NOTREACHED */
- assert(0 == 1);
- }
- }
-
- /*
- * We've found the indicated option. Turn off all non-persistent
- * flags because we're forcing the option back to its initialized state.
- * Call any callout procedure to handle whatever it needs to.
- * Finally, clear the reset flag, too.
- */
- optionReset(pOpts, opt_state.pOD);
- reset_active = AG_FALSE;
-}
-/*
- * Local Variables:
- * mode: C
- * c-file-style: "stroustrup"
- * indent-tabs-mode: nil
- * End:
- * end of autoopts/reset.c */
+++ /dev/null
-
-/*
- * restore.c $Id: 6f5237ba2586755d8ca354f325fc00e7fa1395ec $
- * Time-stamp: "2007-07-04 11:34:40 bkorb"
- *
- * This module's routines will save the current option state to memory
- * and restore it. If saved prior to the initial optionProcess call,
- * then the initial state will be restored.
- *
- * This file is part of AutoOpts, a companion to AutoGen.
- * AutoOpts is free software.
- * AutoOpts is copyright (c) 1992-2009 by Bruce Korb - all rights reserved
- *
- * AutoOpts is available under any one of two licenses. The license
- * in use must be one of these two and the choice is under the control
- * of the user of the license.
- *
- * The GNU Lesser General Public License, version 3 or later
- * See the files "COPYING.lgplv3" and "COPYING.gplv3"
- *
- * The Modified Berkeley Software Distribution License
- * See the file "COPYING.mbsd"
- *
- * These files have the following md5sums:
- *
- * 43b91e8ca915626ed3818ffb1b71248b pkg/libopts/COPYING.gplv3
- * 06a1a2e4760c90ea5e1dad8dfaac4d39 pkg/libopts/COPYING.lgplv3
- * 66a5cedaf62c4b2637025f049f9b826f pkg/libopts/COPYING.mbsd
- */
-
-/*
- * optionFixupSavedOpts Really, it just wipes out option state for
- * options that are troublesome to copy. viz., stacked strings and
- * hierarcicaly valued option args. We do duplicate string args that
- * have been marked as allocated though.
- */
-static void
-fixupSavedOptionArgs(tOptions* pOpts)
-{
- tOptions* p = pOpts->pSavedState;
- tOptDesc* pOD = pOpts->pOptDesc;
- int ct = pOpts->optCt;
-
- /*
- * Make sure that allocated stuff is only referenced in the
- * archived copy of the data.
- */
- for (; ct-- > 0; pOD++) {
- switch (OPTST_GET_ARGTYPE(pOD->fOptState)) {
- case OPARG_TYPE_STRING:
- if (pOD->fOptState & OPTST_STACKED) {
- tOptDesc* q = p->pOptDesc + (pOD - pOpts->pOptDesc);
- q->optCookie = NULL;
- }
- if (pOD->fOptState & OPTST_ALLOC_ARG) {
- tOptDesc* q = p->pOptDesc + (pOD - pOpts->pOptDesc);
- AGDUPSTR(q->optArg.argString, pOD->optArg.argString, "arg");
- }
- break;
-
- case OPARG_TYPE_HIERARCHY:
- {
- tOptDesc* q = p->pOptDesc + (pOD - pOpts->pOptDesc);
- q->optCookie = NULL;
- }
- }
- }
-}
-
-/*=export_func optionSaveState
- *
- * what: saves the option state to memory
- * arg: tOptions*, pOpts, program options descriptor
- *
- * doc:
- *
- * This routine will allocate enough memory to save the current option
- * processing state. If this routine has been called before, that memory
- * will be reused. You may only save one copy of the option state. This
- * routine may be called before optionProcess(3AO). If you do call it
- * before the first call to optionProcess, then you may also change the
- * contents of argc/argv after you call optionRestore(3AO)
- *
- * In fact, more strongly put: it is safest to only use this function
- * before having processed any options. In particular, the saving and
- * restoring of stacked string arguments and hierarchical values is
- * disabled. The values are not saved.
- *
- * err: If it fails to allocate the memory,
- * it will print a message to stderr and exit.
- * Otherwise, it will always succeed.
-=*/
-void
-optionSaveState(tOptions* pOpts)
-{
- tOptions* p = (tOptions*)pOpts->pSavedState;
-
- if (p == NULL) {
- size_t sz = sizeof( *pOpts ) + (pOpts->optCt * sizeof( tOptDesc ));
- p = AGALOC( sz, "saved option state" );
- if (p == NULL) {
- tCC* pzName = pOpts->pzProgName;
- if (pzName == NULL) {
- pzName = pOpts->pzPROGNAME;
- if (pzName == NULL)
- pzName = zNil;
- }
- fprintf( stderr, zCantSave, pzName, sz );
- exit( EXIT_FAILURE );
- }
-
- pOpts->pSavedState = p;
- }
-
- memcpy( p, pOpts, sizeof( *p ));
- memcpy( p + 1, pOpts->pOptDesc, p->optCt * sizeof( tOptDesc ));
-
- fixupSavedOptionArgs(pOpts);
-}
-
-
-/*=export_func optionRestore
- *
- * what: restore option state from memory copy
- * arg: tOptions*, pOpts, program options descriptor
- *
- * doc: Copy back the option state from saved memory.
- * The allocated memory is left intact, so this routine can be
- * called repeatedly without having to call optionSaveState again.
- * If you are restoring a state that was saved before the first call
- * to optionProcess(3AO), then you may change the contents of the
- * argc/argv parameters to optionProcess.
- *
- * err: If you have not called @code{optionSaveState} before, a diagnostic is
- * printed to @code{stderr} and exit is called.
-=*/
-void
-optionRestore( tOptions* pOpts )
-{
- tOptions* p = (tOptions*)pOpts->pSavedState;
-
- if (p == NULL) {
- tCC* pzName = pOpts->pzProgName;
- if (pzName == NULL) {
- pzName = pOpts->pzPROGNAME;
- if (pzName == NULL)
- pzName = zNil;
- }
- fprintf( stderr, zNoState, pzName );
- exit( EXIT_FAILURE );
- }
-
- pOpts->pSavedState = NULL;
- optionFree(pOpts);
-
- memcpy( pOpts, p, sizeof( *p ));
- memcpy( pOpts->pOptDesc, p+1, p->optCt * sizeof( tOptDesc ));
- pOpts->pSavedState = p;
-
- fixupSavedOptionArgs(pOpts);
-}
-
-/* = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = */
-
-/*=export_func optionFree
- *
- * what: free allocated option processing memory
- * arg: tOptions*, pOpts, program options descriptor
- *
- * doc: AutoOpts sometimes allocates memory and puts pointers to it in the
- * option state structures. This routine deallocates all such memory.
- *
- * err: As long as memory has not been corrupted,
- * this routine is always successful.
-=*/
-void
-optionFree( tOptions* pOpts )
-{
- free_saved_state:
- {
- tOptDesc* p = pOpts->pOptDesc;
- int ct = pOpts->optCt;
- do {
- if (p->fOptState & OPTST_ALLOC_ARG) {
- AGFREE(p->optArg.argString);
- p->optArg.argString = NULL;
- p->fOptState &= ~OPTST_ALLOC_ARG;
- }
-
- switch (OPTST_GET_ARGTYPE(p->fOptState)) {
- case OPARG_TYPE_STRING:
-#ifdef WITH_LIBREGEX
- if ( (p->fOptState & OPTST_STACKED)
- && (p->optCookie != NULL)) {
- p->optArg.argString = ".*";
- optionUnstackArg(pOpts, p);
- }
-#else
- /* leak memory */;
-#endif
- break;
-
- case OPARG_TYPE_HIERARCHY:
- if (p->optCookie != NULL)
- unloadNestedArglist(p->optCookie);
- break;
- }
-
- p->optCookie = NULL;
- } while (p++, --ct > 0);
- }
- if (pOpts->pSavedState != NULL) {
- tOptions * p = (tOptions*)pOpts->pSavedState;
- memcpy( pOpts, p, sizeof( *p ));
- memcpy( pOpts->pOptDesc, p+1, p->optCt * sizeof( tOptDesc ));
- AGFREE( pOpts->pSavedState );
- pOpts->pSavedState = NULL;
- goto free_saved_state;
- }
-}
-/*
- * Local Variables:
- * mode: C
- * c-file-style: "stroustrup"
- * indent-tabs-mode: nil
- * End:
- * end of autoopts/restore.c */
+++ /dev/null
-
-/*
- * save.c $Id: 5a69234fab4c2d8d7eaf4aed4dbb3052ce6be5b6 $
- * Time-stamp: "2009-07-20 20:40:28 bkorb"
- *
- * This module's routines will take the currently set options and
- * store them into an ".rc" file for re-interpretation the next
- * time the invoking program is run.
- *
- * This file is part of AutoOpts, a companion to AutoGen.
- * AutoOpts is free software.
- * AutoOpts is copyright (c) 1992-2009 by Bruce Korb - all rights reserved
- *
- * AutoOpts is available under any one of two licenses. The license
- * in use must be one of these two and the choice is under the control
- * of the user of the license.
- *
- * The GNU Lesser General Public License, version 3 or later
- * See the files "COPYING.lgplv3" and "COPYING.gplv3"
- *
- * The Modified Berkeley Software Distribution License
- * See the file "COPYING.mbsd"
- *
- * These files have the following md5sums:
- *
- * 43b91e8ca915626ed3818ffb1b71248b pkg/libopts/COPYING.gplv3
- * 06a1a2e4760c90ea5e1dad8dfaac4d39 pkg/libopts/COPYING.lgplv3
- * 66a5cedaf62c4b2637025f049f9b826f pkg/libopts/COPYING.mbsd
- */
-
-static char const zWarn[] = "%s WARNING: cannot save options - ";
-static char const close_xml[] = "</%s>\n";
-
-/* = = = START-STATIC-FORWARD = = = */
-/* static forward declarations maintained by mk-fwd */
-static tCC*
-findDirName( tOptions* pOpts, int* p_free );
-
-static tCC*
-findFileName( tOptions* pOpts, int* p_free_name );
-
-static void
-printEntry(
- FILE * fp,
- tOptDesc * p,
- tCC* pzLA );
-
-static void
-print_a_value(FILE * fp, int depth, tOptDesc * pOD, tOptionValue const * ovp);
-
-static void
-print_a_string(FILE * fp, char const * name, char const * pz);
-
-static void
-printValueList(FILE * fp, char const * name, tArgList * al);
-
-static void
-printHierarchy(FILE * fp, tOptDesc * p);
-
-static FILE *
-openSaveFile( tOptions* pOpts );
-
-static void
-printNoArgOpt(FILE * fp, tOptDesc * p, tOptDesc * pOD);
-
-static void
-printStringArg(FILE * fp, tOptDesc * pOD);
-
-static void
-printEnumArg(FILE * fp, tOptDesc * pOD);
-
-static void
-printSetMemberArg(FILE * fp, tOptDesc * pOD);
-
-static void
-printFileArg(FILE * fp, tOptDesc * pOD, tOptions* pOpts);
-/* = = = END-STATIC-FORWARD = = = */
-
-static tCC*
-findDirName( tOptions* pOpts, int* p_free )
-{
- tCC* pzDir;
-
- if ( (pOpts->specOptIdx.save_opts == NO_EQUIVALENT)
- || (pOpts->specOptIdx.save_opts == 0))
- return NULL;
-
- pzDir = pOpts->pOptDesc[ pOpts->specOptIdx.save_opts ].optArg.argString;
- if ((pzDir != NULL) && (*pzDir != NUL))
- return pzDir;
-
- /*
- * This function only works if there is a directory where
- * we can stash the RC (INI) file.
- */
- {
- tCC* const* papz = pOpts->papzHomeList;
- if (papz == NULL)
- return NULL;
-
- while (papz[1] != NULL) papz++;
- pzDir = *papz;
- }
-
- /*
- * IF it does not require deciphering an env value, then just copy it
- */
- if (*pzDir != '$')
- return pzDir;
-
- {
- tCC* pzEndDir = strchr( ++pzDir, DIRCH );
- char* pzFileName;
- char* pzEnv;
-
- if (pzEndDir != NULL) {
- char z[ AO_NAME_SIZE ];
- if ((pzEndDir - pzDir) > AO_NAME_LIMIT )
- return NULL;
- strncpy( z, pzDir, (size_t)(pzEndDir - pzDir) );
- z[ (pzEndDir - pzDir) ] = NUL;
- pzEnv = getenv( z );
- } else {
-
- /*
- * Make sure we can get the env value (after stripping off
- * any trailing directory or file names)
- */
- pzEnv = getenv( pzDir );
- }
-
- if (pzEnv == NULL) {
- fprintf( stderr, zWarn, pOpts->pzProgName );
- fprintf( stderr, zNotDef, pzDir );
- return NULL;
- }
-
- if (pzEndDir == NULL)
- return pzEnv;
-
- {
- size_t sz = strlen( pzEnv ) + strlen( pzEndDir ) + 2;
- pzFileName = (char*)AGALOC( sz, "dir name" );
- }
-
- if (pzFileName == NULL)
- return NULL;
-
- *p_free = 1;
- /*
- * Glue together the full name into the allocated memory.
- * FIXME: We lose track of this memory.
- */
- sprintf( pzFileName, "%s/%s", pzEnv, pzEndDir );
- return pzFileName;
- }
-}
-
-
-static tCC*
-findFileName( tOptions* pOpts, int* p_free_name )
-{
- tCC* pzDir;
- struct stat stBuf;
- int free_dir_name = 0;
-
- pzDir = findDirName( pOpts, &free_dir_name );
- if (pzDir == NULL)
- return NULL;
-
- /*
- * See if we can find the specified directory. We use a once-only loop
- * structure so we can bail out early.
- */
- if (stat( pzDir, &stBuf ) != 0) do {
-
- /*
- * IF we could not, check to see if we got a full
- * path to a file name that has not been created yet.
- */
- if (errno == ENOENT) {
- char z[AG_PATH_MAX];
-
- /*
- * Strip off the last component, stat the remaining string and
- * that string must name a directory
- */
- char* pzDirCh = strrchr( pzDir, DIRCH );
- if (pzDirCh == NULL) {
- stBuf.st_mode = S_IFREG;
- continue; /* bail out of error condition */
- }
-
- strncpy( z, pzDir, (size_t)(pzDirCh - pzDir));
- z[ pzDirCh - pzDir ] = NUL;
-
- if ( (stat( z, &stBuf ) == 0)
- && S_ISDIR( stBuf.st_mode )) {
-
- /*
- * We found the directory. Restore the file name and
- * mark the full name as a regular file
- */
- stBuf.st_mode = S_IFREG;
- continue; /* bail out of error condition */
- }
- }
-
- /*
- * We got a bogus name.
- */
- fprintf( stderr, zWarn, pOpts->pzProgName );
- fprintf( stderr, zNoStat, errno, strerror( errno ), pzDir );
- if (free_dir_name)
- AGFREE( (void*)pzDir );
- return NULL;
- } while (0);
-
- /*
- * IF what we found was a directory,
- * THEN tack on the config file name
- */
- if (S_ISDIR( stBuf.st_mode )) {
- size_t sz = strlen( pzDir ) + strlen( pOpts->pzRcName ) + 2;
-
- {
- char* pzPath = (char*)AGALOC( sz, "file name" );
-#ifdef HAVE_SNPRINTF
- snprintf( pzPath, sz, "%s/%s", pzDir, pOpts->pzRcName );
-#else
- sprintf( pzPath, "%s/%s", pzDir, pOpts->pzRcName );
-#endif
- if (free_dir_name)
- AGFREE( (void*)pzDir );
- pzDir = pzPath;
- free_dir_name = 1;
- }
-
- /*
- * IF we cannot stat the object for any reason other than
- * it does not exist, then we bail out
- */
- if (stat( pzDir, &stBuf ) != 0) {
- if (errno != ENOENT) {
- fprintf( stderr, zWarn, pOpts->pzProgName );
- fprintf( stderr, zNoStat, errno, strerror( errno ),
- pzDir );
- AGFREE( (void*)pzDir );
- return NULL;
- }
-
- /*
- * It does not exist yet, but it will be a regular file
- */
- stBuf.st_mode = S_IFREG;
- }
- }
-
- /*
- * Make sure that whatever we ultimately found, that it either is
- * or will soon be a file.
- */
- if (! S_ISREG( stBuf.st_mode )) {
- fprintf( stderr, zWarn, pOpts->pzProgName );
- fprintf( stderr, zNotFile, pzDir );
- if (free_dir_name)
- AGFREE( (void*)pzDir );
- return NULL;
- }
-
- /*
- * Get rid of the old file
- */
- unlink( pzDir );
- *p_free_name = free_dir_name;
- return pzDir;
-}
-
-
-static void
-printEntry(
- FILE * fp,
- tOptDesc * p,
- tCC* pzLA )
-{
- /*
- * There is an argument. Pad the name so values line up.
- * Not disabled *OR* this got equivalenced to another opt,
- * then use current option name.
- * Otherwise, there must be a disablement name.
- */
- {
- char const * pz;
- if (! DISABLED_OPT(p) || (p->optEquivIndex != NO_EQUIVALENT))
- pz = p->pz_Name;
- else
- pz = p->pz_DisableName;
-
- fprintf(fp, "%-18s", pz);
- }
- /*
- * IF the option is numeric only,
- * THEN the char pointer is really the number
- */
- if (OPTST_GET_ARGTYPE(p->fOptState) == OPARG_TYPE_NUMERIC)
- fprintf( fp, " %d\n", (int)(t_word)pzLA );
-
- /*
- * OTHERWISE, FOR each line of the value text, ...
- */
- else if (pzLA == NULL)
- fputc( '\n', fp );
-
- else {
- fputc( ' ', fp ); fputc( ' ', fp );
- for (;;) {
- tCC* pzNl = strchr( pzLA, '\n' );
-
- /*
- * IF this is the last line
- * THEN bail and print it
- */
- if (pzNl == NULL)
- break;
-
- /*
- * Print the continuation and the text from the current line
- */
- (void)fwrite( pzLA, (size_t)(pzNl - pzLA), (size_t)1, fp );
- pzLA = pzNl+1; /* advance the Last Arg pointer */
- fputs( "\\\n", fp );
- }
-
- /*
- * Terminate the entry
- */
- fputs( pzLA, fp );
- fputc( '\n', fp );
- }
-}
-
-
-static void
-print_a_value(FILE * fp, int depth, tOptDesc * pOD, tOptionValue const * ovp)
-{
- static char const bool_atr[] = "<%1$s type=boolean>%2$s</%1$s>\n";
- static char const numb_atr[] = "<%1$s type=integer>0x%2$lX</%1$s>\n";
- static char const type_atr[] = "<%s type=%s>";
- static char const null_atr[] = "<%s/>\n";
-
- while (--depth >= 0)
- putc(' ', fp), putc(' ', fp);
-
- switch (ovp->valType) {
- default:
- case OPARG_TYPE_NONE:
- fprintf(fp, null_atr, ovp->pzName);
- break;
-
- case OPARG_TYPE_STRING:
- print_a_string(fp, ovp->pzName, ovp->v.strVal);
- break;
-
- case OPARG_TYPE_ENUMERATION:
- case OPARG_TYPE_MEMBERSHIP:
- if (pOD != NULL) {
- tAoUI opt_state = pOD->fOptState;
- uintptr_t val = pOD->optArg.argEnum;
- char const * typ = (ovp->valType == OPARG_TYPE_ENUMERATION)
- ? "keyword" : "set-membership";
-
- fprintf(fp, type_atr, ovp->pzName, typ);
-
- /*
- * This is a magic incantation that will convert the
- * bit flag values back into a string suitable for printing.
- */
- (*(pOD->pOptProc))(OPTPROC_RETURN_VALNAME, pOD );
- if (pOD->optArg.argString != NULL) {
- fputs(pOD->optArg.argString, fp);
-
- if (ovp->valType != OPARG_TYPE_ENUMERATION) {
- /*
- * set membership strings get allocated
- */
- AGFREE( (void*)pOD->optArg.argString );
- }
- }
-
- pOD->optArg.argEnum = val;
- pOD->fOptState = opt_state;
- fprintf(fp, close_xml, ovp->pzName);
- break;
- }
- /* FALLTHROUGH */
-
- case OPARG_TYPE_NUMERIC:
- fprintf(fp, numb_atr, ovp->pzName, ovp->v.longVal);
- break;
-
- case OPARG_TYPE_BOOLEAN:
- fprintf(fp, bool_atr, ovp->pzName,
- ovp->v.boolVal ? "true" : "false");
- break;
-
- case OPARG_TYPE_HIERARCHY:
- printValueList(fp, ovp->pzName, ovp->v.nestVal);
- break;
- }
-}
-
-
-static void
-print_a_string(FILE * fp, char const * name, char const * pz)
-{
- static char const open_atr[] = "<%s>";
-
- fprintf(fp, open_atr, name);
- for (;;) {
- int ch = ((int)*(pz++)) & 0xFF;
-
- switch (ch) {
- case NUL: goto string_done;
-
- case '&':
- case '<':
- case '>':
-#if __GNUC__ >= 4
- case 1 ... (' ' - 1):
- case ('~' + 1) ... 0xFF:
-#endif
- emit_special_char(fp, ch);
- break;
-
- default:
-#if __GNUC__ < 4
- if ( ((ch >= 1) && (ch <= (' ' - 1)))
- || ((ch >= ('~' + 1)) && (ch <= 0xFF)) ) {
- emit_special_char(fp, ch);
- break;
- }
-#endif
- putc(ch, fp);
- }
- } string_done:;
- fprintf(fp, close_xml, name);
-}
-
-
-static void
-printValueList(FILE * fp, char const * name, tArgList * al)
-{
- static int depth = 1;
-
- int sp_ct;
- int opt_ct;
- void ** opt_list;
-
- if (al == NULL)
- return;
- opt_ct = al->useCt;
- opt_list = (void **)al->apzArgs;
-
- if (opt_ct <= 0) {
- fprintf(fp, "<%s/>\n", name);
- return;
- }
-
- fprintf(fp, "<%s type=nested>\n", name);
-
- depth++;
- while (--opt_ct >= 0) {
- tOptionValue const * ovp = *(opt_list++);
-
- print_a_value(fp, depth, NULL, ovp);
- }
- depth--;
-
- for (sp_ct = depth; --sp_ct >= 0;)
- putc(' ', fp), putc(' ', fp);
- fprintf(fp, "</%s>\n", name);
-}
-
-
-static void
-printHierarchy(FILE * fp, tOptDesc * p)
-{
- int opt_ct;
- tArgList * al = p->optCookie;
- void ** opt_list;
-
- if (al == NULL)
- return;
-
- opt_ct = al->useCt;
- opt_list = (void **)al->apzArgs;
-
- if (opt_ct <= 0)
- return;
-
- do {
- tOptionValue const * base = *(opt_list++);
- tOptionValue const * ovp = optionGetValue(base, NULL);
-
- if (ovp == NULL)
- continue;
-
- fprintf(fp, "<%s type=nested>\n", p->pz_Name);
-
- do {
- print_a_value(fp, 1, p, ovp);
-
- } while (ovp = optionNextValue(base, ovp),
- ovp != NULL);
-
- fprintf(fp, "</%s>\n", p->pz_Name);
- } while (--opt_ct > 0);
-}
-
-
-static FILE *
-openSaveFile( tOptions* pOpts )
-{
- FILE* fp;
-
- {
- int free_name = 0;
- tCC* pzFName = findFileName( pOpts, &free_name );
- if (pzFName == NULL)
- return NULL;
-
- fp = fopen( pzFName, "w" FOPEN_BINARY_FLAG );
- if (fp == NULL) {
- fprintf( stderr, zWarn, pOpts->pzProgName );
- fprintf( stderr, zNoCreat, errno, strerror( errno ), pzFName );
- if (free_name)
- AGFREE((void*) pzFName );
- return fp;
- }
-
- if (free_name)
- AGFREE( (void*)pzFName );
- }
-
- {
- char const* pz = pOpts->pzUsageTitle;
- fputs( "# ", fp );
- do { fputc( *pz, fp ); } while (*(pz++) != '\n');
- }
-
- {
- time_t timeVal = time( NULL );
- char* pzTime = ctime( &timeVal );
-
- fprintf( fp, zPresetFile, pzTime );
-#ifdef HAVE_ALLOCATED_CTIME
- /*
- * The return values for ctime(), localtime(), and gmtime()
- * normally point to static data that is overwritten by each call.
- * The test to detect allocated ctime, so we leak the memory.
- */
- AGFREE( (void*)pzTime );
-#endif
- }
-
- return fp;
-}
-
-static void
-printNoArgOpt(FILE * fp, tOptDesc * p, tOptDesc * pOD)
-{
- /*
- * The aliased to argument indicates whether or not the option
- * is "disabled". However, the original option has the name
- * string, so we get that there, not with "p".
- */
- char const * pznm =
- (DISABLED_OPT( p )) ? pOD->pz_DisableName : pOD->pz_Name;
- /*
- * If the option was disabled and the disablement name is NULL,
- * then the disablement was caused by aliasing.
- * Use the name as the string to emit.
- */
- if (pznm == NULL)
- pznm = pOD->pz_Name;
-
- fprintf(fp, "%s\n", pznm);
-}
-
-static void
-printStringArg(FILE * fp, tOptDesc * pOD)
-{
- if (pOD->fOptState & OPTST_STACKED) {
- tArgList* pAL = (tArgList*)pOD->optCookie;
- int uct = pAL->useCt;
- tCC** ppz = pAL->apzArgs;
-
- /*
- * un-disable multiple copies of disabled options.
- */
- if (uct > 1)
- pOD->fOptState &= ~OPTST_DISABLED;
-
- while (uct-- > 0)
- printEntry( fp, pOD, *(ppz++) );
- } else {
- printEntry( fp, pOD, pOD->optArg.argString );
- }
-}
-
-static void
-printEnumArg(FILE * fp, tOptDesc * pOD)
-{
- uintptr_t val = pOD->optArg.argEnum;
-
- /*
- * This is a magic incantation that will convert the
- * bit flag values back into a string suitable for printing.
- */
- (*(pOD->pOptProc))(OPTPROC_RETURN_VALNAME, pOD);
- printEntry( fp, pOD, (void*)(pOD->optArg.argString));
-
- pOD->optArg.argEnum = val;
-}
-
-static void
-printSetMemberArg(FILE * fp, tOptDesc * pOD)
-{
- uintptr_t val = pOD->optArg.argEnum;
-
- /*
- * This is a magic incantation that will convert the
- * bit flag values back into a string suitable for printing.
- */
- (*(pOD->pOptProc))(OPTPROC_RETURN_VALNAME, pOD);
- printEntry( fp, pOD, (void*)(pOD->optArg.argString));
-
- if (pOD->optArg.argString != NULL) {
- /*
- * set membership strings get allocated
- */
- AGFREE( (void*)pOD->optArg.argString );
- pOD->fOptState &= ~OPTST_ALLOC_ARG;
- }
-
- pOD->optArg.argEnum = val;
-}
-
-static void
-printFileArg(FILE * fp, tOptDesc * pOD, tOptions* pOpts)
-{
- /*
- * If the cookie is not NULL, then it has the file name, period.
- * Otherwise, if we have a non-NULL string argument, then....
- */
- if (pOD->optCookie != NULL)
- printEntry(fp, pOD, pOD->optCookie);
-
- else if (HAS_originalOptArgArray(pOpts)) {
- char const * orig =
- pOpts->originalOptArgArray[pOD->optIndex].argString;
-
- if (pOD->optArg.argString == orig)
- return;
-
- printEntry(fp, pOD, pOD->optArg.argString);
- }
-}
-
-
-/*=export_func optionSaveFile
- *
- * what: saves the option state to a file
- *
- * arg: tOptions*, pOpts, program options descriptor
- *
- * doc:
- *
- * This routine will save the state of option processing to a file. The name
- * of that file can be specified with the argument to the @code{--save-opts}
- * option, or by appending the @code{rcfile} attribute to the last
- * @code{homerc} attribute. If no @code{rcfile} attribute was specified, it
- * will default to @code{.@i{programname}rc}. If you wish to specify another
- * file, you should invoke the @code{SET_OPT_SAVE_OPTS( @i{filename} )} macro.
- *
- * The recommend usage is as follows:
- * @example
- * optionProcess(&progOptions, argc, argv);
- * if (i_want_a_non_standard_place_for_this)
- * SET_OPT_SAVE_OPTS("myfilename");
- * optionSaveFile(&progOptions);
- * @end example
- *
- * err:
- *
- * If no @code{homerc} file was specified, this routine will silently return
- * and do nothing. If the output file cannot be created or updated, a message
- * will be printed to @code{stderr} and the routine will return.
-=*/
-void
-optionSaveFile( tOptions* pOpts )
-{
- tOptDesc* pOD;
- int ct;
- FILE* fp = openSaveFile(pOpts);
-
- if (fp == NULL)
- return;
-
- /*
- * FOR each of the defined options, ...
- */
- ct = pOpts->presetOptCt;
- pOD = pOpts->pOptDesc;
- do {
- tOptDesc* p;
-
- /*
- * IF the option has not been defined
- * OR it does not take an initialization value
- * OR it is equivalenced to another option
- * THEN continue (ignore it)
- *
- * Equivalenced options get picked up when the equivalenced-to
- * option is processed.
- */
- if (UNUSED_OPT( pOD ))
- continue;
-
- if ((pOD->fOptState & OPTST_DO_NOT_SAVE_MASK) != 0)
- continue;
-
- if ( (pOD->optEquivIndex != NO_EQUIVALENT)
- && (pOD->optEquivIndex != pOD->optIndex))
- continue;
-
- /*
- * The option argument data are found at the equivalenced-to option,
- * but the actual option argument type comes from the original
- * option descriptor. Be careful!
- */
- p = ((pOD->fOptState & OPTST_EQUIVALENCE) != 0)
- ? (pOpts->pOptDesc + pOD->optActualIndex) : pOD;
-
- switch (OPTST_GET_ARGTYPE(pOD->fOptState)) {
- case OPARG_TYPE_NONE:
- printNoArgOpt(fp, p, pOD);
- break;
-
- case OPARG_TYPE_NUMERIC:
- printEntry( fp, p, (void*)(p->optArg.argInt));
- break;
-
- case OPARG_TYPE_STRING:
- printStringArg(fp, p);
- break;
-
- case OPARG_TYPE_ENUMERATION:
- printEnumArg(fp, p);
- break;
-
- case OPARG_TYPE_MEMBERSHIP:
- printSetMemberArg(fp, p);
- break;
-
- case OPARG_TYPE_BOOLEAN:
- printEntry( fp, p, p->optArg.argBool ? "true" : "false" );
- break;
-
- case OPARG_TYPE_HIERARCHY:
- printHierarchy(fp, p);
- break;
-
- case OPARG_TYPE_FILE:
- printFileArg(fp, p, pOpts);
- break;
-
- default:
- break; /* cannot handle - skip it */
- }
- } while ( (pOD++), (--ct > 0));
-
- fclose( fp );
-}
-/*
- * Local Variables:
- * mode: C
- * c-file-style: "stroustrup"
- * indent-tabs-mode: nil
- * End:
- * end of autoopts/save.c */
+++ /dev/null
-
-/*
- * sort.c $Id: aac1bf81481f4bb149a72129fbd11fe54db7fa35 $
- * Time-stamp: "2007-07-04 11:34:52 bkorb"
- *
- * This module implements argument sorting.
- *
- * This file is part of AutoOpts, a companion to AutoGen.
- * AutoOpts is free software.
- * AutoOpts is copyright (c) 1992-2009 by Bruce Korb - all rights reserved
- *
- * AutoOpts is available under any one of two licenses. The license
- * in use must be one of these two and the choice is under the control
- * of the user of the license.
- *
- * The GNU Lesser General Public License, version 3 or later
- * See the files "COPYING.lgplv3" and "COPYING.gplv3"
- *
- * The Modified Berkeley Software Distribution License
- * See the file "COPYING.mbsd"
- *
- * These files have the following md5sums:
- *
- * 43b91e8ca915626ed3818ffb1b71248b pkg/libopts/COPYING.gplv3
- * 06a1a2e4760c90ea5e1dad8dfaac4d39 pkg/libopts/COPYING.lgplv3
- * 66a5cedaf62c4b2637025f049f9b826f pkg/libopts/COPYING.mbsd
- */
-
-/* = = = START-STATIC-FORWARD = = = */
-/* static forward declarations maintained by mk-fwd */
-static tSuccess
-mustHandleArg( tOptions* pOpts, char* pzArg, tOptState* pOS,
- char** ppzOpts, int* pOptsIdx );
-
-static tSuccess
-mayHandleArg( tOptions* pOpts, char* pzArg, tOptState* pOS,
- char** ppzOpts, int* pOptsIdx );
-
-static tSuccess
-checkShortOpts( tOptions* pOpts, char* pzArg, tOptState* pOS,
- char** ppzOpts, int* pOptsIdx );
-/* = = = END-STATIC-FORWARD = = = */
-
-/*
- * "mustHandleArg" and "mayHandleArg" are really similar. The biggest
- * difference is that "may" will consume the next argument only if it
- * does not start with a hyphen and "must" will consume it, hyphen or not.
- */
-static tSuccess
-mustHandleArg( tOptions* pOpts, char* pzArg, tOptState* pOS,
- char** ppzOpts, int* pOptsIdx )
-{
- /*
- * An option argument is required. Long options can either have
- * a separate command line argument, or an argument attached by
- * the '=' character. Figure out which.
- */
- switch (pOS->optType) {
- case TOPT_SHORT:
- /*
- * See if an arg string follows the flag character. If not,
- * the next arg must be the option argument.
- */
- if (*pzArg != NUL)
- return SUCCESS;
- break;
-
- case TOPT_LONG:
- /*
- * See if an arg string has already been assigned (glued on
- * with an `=' character). If not, the next is the opt arg.
- */
- if (pOS->pzOptArg != NULL)
- return SUCCESS;
- break;
-
- default:
- return FAILURE;
- }
- if (pOpts->curOptIdx >= pOpts->origArgCt)
- return FAILURE;
-
- ppzOpts[ (*pOptsIdx)++ ] = pOpts->origArgVect[ (pOpts->curOptIdx)++ ];
- return SUCCESS;
-}
-
-static tSuccess
-mayHandleArg( tOptions* pOpts, char* pzArg, tOptState* pOS,
- char** ppzOpts, int* pOptsIdx )
-{
- /*
- * An option argument is optional.
- */
- switch (pOS->optType) {
- case TOPT_SHORT:
- /*
- * IF nothing is glued on after the current flag character,
- * THEN see if there is another argument. If so and if it
- * does *NOT* start with a hyphen, then it is the option arg.
- */
- if (*pzArg != NUL)
- return SUCCESS;
- break;
-
- case TOPT_LONG:
- /*
- * Look for an argument if we don't already have one (glued on
- * with a `=' character)
- */
- if (pOS->pzOptArg != NULL)
- return SUCCESS;
- break;
-
- default:
- return FAILURE;
- }
- if (pOpts->curOptIdx >= pOpts->origArgCt)
- return PROBLEM;
-
- pzArg = pOpts->origArgVect[ pOpts->curOptIdx ];
- if (*pzArg != '-')
- ppzOpts[ (*pOptsIdx)++ ] = pOpts->origArgVect[ (pOpts->curOptIdx)++ ];
- return SUCCESS;
-}
-
-/*
- * Process a string of short options glued together. If the last one
- * does or may take an argument, the do the argument processing and leave.
- */
-static tSuccess
-checkShortOpts( tOptions* pOpts, char* pzArg, tOptState* pOS,
- char** ppzOpts, int* pOptsIdx )
-{
- while (*pzArg != NUL) {
- if (FAILED( shortOptionFind( pOpts, (tAoUC)*pzArg, pOS )))
- return FAILURE;
-
- /*
- * See if we can have an arg.
- */
- if (OPTST_GET_ARGTYPE(pOS->pOD->fOptState) == OPARG_TYPE_NONE) {
- pzArg++;
-
- } else if (pOS->pOD->fOptState & OPTST_ARG_OPTIONAL) {
- /*
- * Take an argument if it is not attached and it does not
- * start with a hyphen.
- */
- if (pzArg[1] != NUL)
- return SUCCESS;
-
- pzArg = pOpts->origArgVect[ pOpts->curOptIdx ];
- if (*pzArg != '-')
- ppzOpts[ (*pOptsIdx)++ ] =
- pOpts->origArgVect[ (pOpts->curOptIdx)++ ];
- return SUCCESS;
-
- } else {
- /*
- * IF we need another argument, be sure it is there and
- * take it.
- */
- if (pzArg[1] == NUL) {
- if (pOpts->curOptIdx >= pOpts->origArgCt)
- return FAILURE;
- ppzOpts[ (*pOptsIdx)++ ] =
- pOpts->origArgVect[ (pOpts->curOptIdx)++ ];
- }
- return SUCCESS;
- }
- }
- return SUCCESS;
-}
-
-/*
- * If the program wants sorted options (separated operands and options),
- * then this routine will to the trick.
- */
-LOCAL void
-optionSort( tOptions* pOpts )
-{
- char** ppzOpts;
- char** ppzOpds;
- int optsIdx = 0;
- int opdsIdx = 0;
-
- tOptState os = OPTSTATE_INITIALIZER(DEFINED);
-
- /*
- * Disable for POSIX conformance, or if there are no operands.
- */
- if ( (getenv( "POSIXLY_CORRECT" ) != NULL)
- || NAMED_OPTS(pOpts))
- return;
-
- /*
- * Make sure we can allocate two full-sized arg vectors.
- */
- ppzOpts = malloc( pOpts->origArgCt * sizeof( char* ));
- if (ppzOpts == NULL)
- goto exit_no_mem;
-
- ppzOpds = malloc( pOpts->origArgCt * sizeof( char* ));
- if (ppzOpds == NULL) {
- free( ppzOpts );
- goto exit_no_mem;
- }
-
- pOpts->curOptIdx = 1;
- pOpts->pzCurOpt = NULL;
-
- /*
- * Now, process all the options from our current position onward.
- * (This allows interspersed options and arguments for the few
- * non-standard programs that require it.)
- */
- for (;;) {
- char* pzArg;
- tSuccess res;
-
- /*
- * If we're out of arguments, we're done. Join the option and
- * operand lists into the original argument vector.
- */
- if (pOpts->curOptIdx >= pOpts->origArgCt) {
- errno = 0;
- goto joinLists;
- }
-
- pzArg = pOpts->origArgVect[ pOpts->curOptIdx ];
- if (*pzArg != '-') {
- ppzOpds[ opdsIdx++ ] = pOpts->origArgVect[ (pOpts->curOptIdx)++ ];
- continue;
- }
-
- switch (pzArg[1]) {
- case NUL:
- /*
- * A single hyphen is an operand.
- */
- ppzOpds[ opdsIdx++ ] = pOpts->origArgVect[ (pOpts->curOptIdx)++ ];
- continue;
-
- case '-':
- /*
- * Two consecutive hypens. Put them on the options list and then
- * _always_ force the remainder of the arguments to be operands.
- */
- if (pzArg[2] == NUL) {
- ppzOpts[ optsIdx++ ] =
- pOpts->origArgVect[ (pOpts->curOptIdx)++ ];
- goto restOperands;
- }
- res = longOptionFind( pOpts, pzArg+2, &os );
- break;
-
- default:
- /*
- * If short options are not allowed, then do long
- * option processing. Otherwise the character must be a
- * short (i.e. single character) option.
- */
- if ((pOpts->fOptSet & OPTPROC_SHORTOPT) == 0) {
- res = longOptionFind( pOpts, pzArg+1, &os );
- } else {
- res = shortOptionFind( pOpts, (tAoUC)pzArg[1], &os );
- }
- break;
- }
- if (FAILED( res )) {
- errno = EINVAL;
- goto freeTemps;
- }
-
- /*
- * We've found an option. Add the argument to the option list.
- * Next, we have to see if we need to pull another argument to be
- * used as the option argument.
- */
- ppzOpts[ optsIdx++ ] = pOpts->origArgVect[ (pOpts->curOptIdx)++ ];
-
- if (OPTST_GET_ARGTYPE(os.pOD->fOptState) == OPARG_TYPE_NONE) {
- /*
- * No option argument. If we have a short option here,
- * then scan for short options until we get to the end
- * of the argument string.
- */
- if ( (os.optType == TOPT_SHORT)
- && FAILED( checkShortOpts( pOpts, pzArg+2, &os,
- ppzOpts, &optsIdx )) ) {
- errno = EINVAL;
- goto freeTemps;
- }
-
- } else if (os.pOD->fOptState & OPTST_ARG_OPTIONAL) {
- switch (mayHandleArg( pOpts, pzArg+2, &os, ppzOpts, &optsIdx )) {
- case FAILURE: errno = EIO; goto freeTemps;
- case PROBLEM: errno = 0; goto joinLists;
- }
-
- } else {
- switch (mustHandleArg( pOpts, pzArg+2, &os, ppzOpts, &optsIdx )) {
- case PROBLEM:
- case FAILURE: errno = EIO; goto freeTemps;
- }
- }
- } /* for (;;) */
-
- restOperands:
- while (pOpts->curOptIdx < pOpts->origArgCt)
- ppzOpds[ opdsIdx++ ] = pOpts->origArgVect[ (pOpts->curOptIdx)++ ];
-
- joinLists:
- if (optsIdx > 0)
- memcpy( pOpts->origArgVect + 1, ppzOpts, optsIdx * sizeof( char* ));
- if (opdsIdx > 0)
- memcpy( pOpts->origArgVect + 1 + optsIdx,
- ppzOpds, opdsIdx * sizeof( char* ));
-
- freeTemps:
- free( ppzOpts );
- free( ppzOpds );
- return;
-
- exit_no_mem:
- errno = ENOMEM;
- return;
-}
-
-/*
- * Local Variables:
- * mode: C
- * c-file-style: "stroustrup"
- * indent-tabs-mode: nil
- * End:
- * end of autoopts/sort.c */
+++ /dev/null
-
-/*
- * stack.c
- * $Id: 9d4a7c1c6ae364a6134dc5ff01f58f08b52f1a16 $
- * Time-stamp: "2008-07-30 16:56:32 bkorb"
- *
- * This is a special option processing routine that will save the
- * argument to an option in a FIFO queue.
- *
- * This file is part of AutoOpts, a companion to AutoGen.
- * AutoOpts is free software.
- * AutoOpts is copyright (c) 1992-2009 by Bruce Korb - all rights reserved
- *
- * AutoOpts is available under any one of two licenses. The license
- * in use must be one of these two and the choice is under the control
- * of the user of the license.
- *
- * The GNU Lesser General Public License, version 3 or later
- * See the files "COPYING.lgplv3" and "COPYING.gplv3"
- *
- * The Modified Berkeley Software Distribution License
- * See the file "COPYING.mbsd"
- *
- * These files have the following md5sums:
- *
- * 43b91e8ca915626ed3818ffb1b71248b pkg/libopts/COPYING.gplv3
- * 06a1a2e4760c90ea5e1dad8dfaac4d39 pkg/libopts/COPYING.lgplv3
- * 66a5cedaf62c4b2637025f049f9b826f pkg/libopts/COPYING.mbsd
- */
-
-#ifdef WITH_LIBREGEX
-# include REGEX_HEADER
-#endif
-
-/*=export_func optionUnstackArg
- * private:
- *
- * what: Remove option args from a stack
- * arg: + tOptions* + pOpts + program options descriptor +
- * arg: + tOptDesc* + pOptDesc + the descriptor for this arg +
- *
- * doc:
- * Invoked for options that are equivalenced to stacked options.
-=*/
-void
-optionUnstackArg(
- tOptions* pOpts,
- tOptDesc* pOptDesc )
-{
- int res;
-
- tArgList* pAL;
-
- if ((pOptDesc->fOptState & OPTST_RESET) != 0)
- return;
- pAL = (tArgList*)pOptDesc->optCookie;
-
- /*
- * IF we don't have any stacked options,
- * THEN indicate that we don't have any of these options
- */
- if (pAL == NULL) {
- pOptDesc->fOptState &= OPTST_PERSISTENT_MASK;
- if ( (pOptDesc->fOptState & OPTST_INITENABLED) == 0)
- pOptDesc->fOptState |= OPTST_DISABLED;
- return;
- }
-
-#ifdef WITH_LIBREGEX
- {
- regex_t re;
- int i, ct, dIdx;
-
- if (regcomp( &re, pOptDesc->optArg.argString, REG_NOSUB ) != 0)
- return;
-
- /*
- * search the list for the entry(s) to remove. Entries that
- * are removed are *not* copied into the result. The source
- * index is incremented every time. The destination only when
- * we are keeping a define.
- */
- for (i = 0, dIdx = 0, ct = pAL->useCt; --ct >= 0; i++) {
- tCC* pzSrc = pAL->apzArgs[ i ];
- char* pzEq = strchr( pzSrc, '=' );
-
- if (pzEq != NULL)
- *pzEq = NUL;
-
- res = regexec( &re, pzSrc, (size_t)0, NULL, 0 );
- switch (res) {
- case 0:
- /*
- * Remove this entry by reducing the in-use count
- * and *not* putting the string pointer back into
- * the list.
- */
- AGFREE(pzSrc);
- pAL->useCt--;
- break;
-
- default:
- case REG_NOMATCH:
- if (pzEq != NULL)
- *pzEq = '=';
-
- /*
- * IF we have dropped an entry
- * THEN we have to move the current one.
- */
- if (dIdx != i)
- pAL->apzArgs[ dIdx ] = pzSrc;
- dIdx++;
- }
- }
-
- regfree( &re );
- }
-#else /* not WITH_LIBREGEX */
- {
- int i, ct, dIdx;
-
- /*
- * search the list for the entry(s) to remove. Entries that
- * are removed are *not* copied into the result. The source
- * index is incremented every time. The destination only when
- * we are keeping a define.
- */
- for (i = 0, dIdx = 0, ct = pAL->useCt; --ct >= 0; i++) {
- tCC* pzSrc = pAL->apzArgs[ i ];
- char* pzEq = strchr( pzSrc, '=' );
-
- if (pzEq != NULL)
- *pzEq = NUL;
-
- if (strcmp( pzSrc, pOptDesc->optArg.argString ) == 0) {
- /*
- * Remove this entry by reducing the in-use count
- * and *not* putting the string pointer back into
- * the list.
- */
- AGFREE(pzSrc);
- pAL->useCt--;
- } else {
- if (pzEq != NULL)
- *pzEq = '=';
-
- /*
- * IF we have dropped an entry
- * THEN we have to move the current one.
- */
- if (dIdx != i)
- pAL->apzArgs[ dIdx ] = pzSrc;
- dIdx++;
- }
- }
- }
-#endif /* WITH_LIBREGEX */
- /*
- * IF we have unstacked everything,
- * THEN indicate that we don't have any of these options
- */
- if (pAL->useCt == 0) {
- pOptDesc->fOptState &= OPTST_PERSISTENT_MASK;
- if ( (pOptDesc->fOptState & OPTST_INITENABLED) == 0)
- pOptDesc->fOptState |= OPTST_DISABLED;
- AGFREE( (void*)pAL );
- pOptDesc->optCookie = NULL;
- }
-}
-
-
-/*
- * Put an entry into an argument list. The first argument points to
- * a pointer to the argument list structure. It gets passed around
- * as an opaque address.
- */
-LOCAL void
-addArgListEntry( void** ppAL, void* entry )
-{
- tArgList* pAL = *(void**)ppAL;
-
- /*
- * IF we have never allocated one of these,
- * THEN allocate one now
- */
- if (pAL == NULL) {
- pAL = (tArgList*)AGALOC( sizeof( *pAL ), "new option arg stack" );
- if (pAL == NULL)
- return;
- pAL->useCt = 0;
- pAL->allocCt = MIN_ARG_ALLOC_CT;
- *ppAL = (void*)pAL;
- }
-
- /*
- * ELSE if we are out of room
- * THEN make it bigger
- */
- else if (pAL->useCt >= pAL->allocCt) {
- size_t sz = sizeof( *pAL );
- pAL->allocCt += INCR_ARG_ALLOC_CT;
-
- /*
- * The base structure contains space for MIN_ARG_ALLOC_CT
- * pointers. We subtract it off to find our augment size.
- */
- sz += sizeof(char*) * (pAL->allocCt - MIN_ARG_ALLOC_CT);
- pAL = (tArgList*)AGREALOC( (void*)pAL, sz, "expanded opt arg stack" );
- if (pAL == NULL)
- return;
- *ppAL = (void*)pAL;
- }
-
- /*
- * Insert the new argument into the list
- */
- pAL->apzArgs[ (pAL->useCt)++ ] = entry;
-}
-
-
-/*=export_func optionStackArg
- * private:
- *
- * what: put option args on a stack
- * arg: + tOptions* + pOpts + program options descriptor +
- * arg: + tOptDesc* + pOptDesc + the descriptor for this arg +
- *
- * doc:
- * Keep an entry-ordered list of option arguments.
-=*/
-void
-optionStackArg(
- tOptions* pOpts,
- tOptDesc* pOD )
-{
- char * pz;
-
- if ((pOD->fOptState & OPTST_RESET) != 0) {
- tArgList* pAL = (void*)pOD->optCookie;
- int ix;
- if (pAL == NULL)
- return;
-
- ix = pAL->useCt;
- while (--ix >= 0)
- AGFREE(pAL->apzArgs[ix]);
- AGFREE(pAL);
-
- } else {
- if (pOD->optArg.argString == NULL)
- return;
-
- AGDUPSTR(pz, pOD->optArg.argString, "stack arg");
- addArgListEntry( &(pOD->optCookie), (void*)pz );
- }
-}
-/*
- * Local Variables:
- * mode: C
- * c-file-style: "stroustrup"
- * indent-tabs-mode: nil
- * End:
- * end of autoopts/stack.c */
+++ /dev/null
-
-/*
- * $Id: cb437d22b0c48960c9e1c23501fba6e3291fecd8 $
- * Time-stamp: "2008-12-26 10:15:46 bkorb"
- *
- * String Equivalence Comparison
- *
- * These routines allow any character to be mapped to any other
- * character before comparison. In processing long option names,
- * the characters "-", "_" and "^" all need to be equivalent
- * (because they are treated so by different development environments).
- *
- * This file is part of AutoOpts, a companion to AutoGen.
- * AutoOpts is free software.
- * AutoOpts is copyright (c) 1992-2009 by Bruce Korb - all rights reserved
- *
- * AutoOpts is available under any one of two licenses. The license
- * in use must be one of these two and the choice is under the control
- * of the user of the license.
- *
- * The GNU Lesser General Public License, version 3 or later
- * See the files "COPYING.lgplv3" and "COPYING.gplv3"
- *
- * The Modified Berkeley Software Distribution License
- * See the file "COPYING.mbsd"
- *
- * These files have the following md5sums:
- *
- * 43b91e8ca915626ed3818ffb1b71248b pkg/libopts/COPYING.gplv3
- * 06a1a2e4760c90ea5e1dad8dfaac4d39 pkg/libopts/COPYING.lgplv3
- * 66a5cedaf62c4b2637025f049f9b826f pkg/libopts/COPYING.mbsd
- *
- * This array is designed for mapping upper and lower case letter
- * together for a case independent comparison. The mappings are
- * based upon ascii character sequences.
- */
-static unsigned char charmap[] = {
- 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, '\a',
- '\b', '\t', '\n', '\v', '\f', '\r', 0x0E, 0x0F,
- 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
- 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F,
-
- ' ', '!', '"', '#', '$', '%', '&', '\'',
- '(', ')', '*', '+', ',', '-', '.', '/',
- '0', '1', '2', '3', '4', '5', '6', '7',
- '8', '9', ':', ';', '<', '=', '>', '?',
-
- '@', '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', '[', '\\', ']', '^', '_',
- '`', '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', '{', '|', '}', '~', 0x7f,
-
- 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
- 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F,
- 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
- 0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F,
- 0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7,
- 0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF,
- 0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7,
- 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF,
-
- 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7,
- 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF,
- 0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7,
- 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF,
- 0xE0, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7,
- 0xE8, 0xE9, 0xEA, 0xEB, 0xEC, 0xED, 0xEE, 0xEF,
- 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7,
- 0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF,
-};
-
-
-/*=export_func strneqvcmp
- *
- * what: compare two strings with an equivalence mapping
- *
- * arg: + char const* + str1 + first string +
- * arg: + char const* + str2 + second string +
- * arg: + int + ct + compare length +
- *
- * ret_type: int
- * ret_desc: the difference between two differing characters
- *
- * doc:
- *
- * Using a character mapping, two strings are compared for "equivalence".
- * Each input character is mapped to a comparison character and the
- * mapped-to characters are compared for the two NUL terminated input strings.
- * The comparison is limited to @code{ct} bytes.
- * This function name is mapped to option_strneqvcmp so as to not conflict
- * with the POSIX name space.
- *
- * err: none checked. Caller responsible for seg faults.
-=*/
-int
-strneqvcmp( tCC* s1, tCC* s2, int ct )
-{
- for (; ct > 0; --ct) {
- unsigned char u1 = (unsigned char) *s1++;
- unsigned char u2 = (unsigned char) *s2++;
- int dif = charmap[ u1 ] - charmap[ u2 ];
-
- if (dif != 0)
- return dif;
-
- if (u1 == NUL)
- return 0;
- }
-
- return 0;
-}
-
-
-/*=export_func streqvcmp
- *
- * what: compare two strings with an equivalence mapping
- *
- * arg: + char const* + str1 + first string +
- * arg: + char const* + str2 + second string +
- *
- * ret_type: int
- * ret_desc: the difference between two differing characters
- *
- * doc:
- *
- * Using a character mapping, two strings are compared for "equivalence".
- * Each input character is mapped to a comparison character and the
- * mapped-to characters are compared for the two NUL terminated input strings.
- * This function name is mapped to option_streqvcmp so as to not conflict
- * with the POSIX name space.
- *
- * err: none checked. Caller responsible for seg faults.
-=*/
-int
-streqvcmp( tCC* s1, tCC* s2 )
-{
- for (;;) {
- unsigned char u1 = (unsigned char) *s1++;
- unsigned char u2 = (unsigned char) *s2++;
- int dif = charmap[ u1 ] - charmap[ u2 ];
-
- if (dif != 0)
- return dif;
-
- if (u1 == NUL)
- return 0;
- }
-}
-
-
-/*=export_func streqvmap
- *
- * what: Set the character mappings for the streqv functions
- *
- * arg: + char + From + Input character +
- * arg: + char + To + Mapped-to character +
- * arg: + int + ct + compare length +
- *
- * doc:
- *
- * Set the character mapping. If the count (@code{ct}) is set to zero, then
- * the map is cleared by setting all entries in the map to their index
- * value. Otherwise, the "@code{From}" character is mapped to the "@code{To}"
- * character. If @code{ct} is greater than 1, then @code{From} and @code{To}
- * are incremented and the process repeated until @code{ct} entries have been
- * set. For example,
- * @example
- * streqvmap( 'a', 'A', 26 );
- * @end example
- * @noindent
- * will alter the mapping so that all English lower case letters
- * will map to upper case.
- *
- * This function name is mapped to option_streqvmap so as to not conflict
- * with the POSIX name space.
- *
- * err: none.
-=*/
-void
-streqvmap( char From, char To, int ct )
-{
- if (ct == 0) {
- ct = sizeof( charmap ) - 1;
- do {
- charmap[ ct ] = ct;
- } while (--ct >= 0);
- }
-
- else {
- int chTo = (int)To & 0xFF;
- int chFrom = (int)From & 0xFF;
-
- do {
- charmap[ chFrom ] = (unsigned)chTo;
- chFrom++;
- chTo++;
- if ((chFrom >= sizeof( charmap )) || (chTo >= sizeof( charmap )))
- break;
- } while (--ct > 0);
- }
-}
-
-
-/*=export_func strequate
- *
- * what: map a list of characters to the same value
- *
- * arg: + char const* + ch_list + characters to equivalence +
- *
- * doc:
- *
- * Each character in the input string get mapped to the first character
- * in the string.
- * This function name is mapped to option_strequate so as to not conflict
- * with the POSIX name space.
- *
- * err: none.
-=*/
-void
-strequate( char const* s )
-{
- if ((s != NULL) && (*s != NUL)) {
- unsigned char equiv = (unsigned)*s;
- while (*s != NUL)
- charmap[ (unsigned)*(s++) ] = equiv;
- }
-}
-
-
-/*=export_func strtransform
- *
- * what: convert a string into its mapped-to value
- *
- * arg: + char* + dest + output string +
- * arg: + char const* + src + input string +
- *
- * doc:
- *
- * Each character in the input string is mapped and the mapped-to
- * character is put into the output.
- * This function name is mapped to option_strtransform so as to not conflict
- * with the POSIX name space.
- *
- * The source and destination may be the same.
- *
- * err: none.
-=*/
-void
-strtransform( char* d, char const* s )
-{
- do {
- *(d++) = (char)charmap[ (unsigned)*s ];
- } while (*(s++) != NUL);
-}
-
-/*
- * Local Variables:
- * mode: C
- * c-file-style: "stroustrup"
- * indent-tabs-mode: nil
- * End:
- * end of autoopts/streqvcmp.c */
+++ /dev/null
-/*
- * $Id: 14e1f51d1a5a31d8395fdf1e93a07bace1c59e87 $
- *
- * Time-stamp: "2007-07-04 11:35:49 bkorb"
- *
- * This file is part of AutoOpts, a companion to AutoGen.
- * AutoOpts is free software.
- * AutoOpts is copyright (c) 1992-2009 by Bruce Korb - all rights reserved
- *
- * AutoOpts is available under any one of two licenses. The license
- * in use must be one of these two and the choice is under the control
- * of the user of the license.
- *
- * The GNU Lesser General Public License, version 3 or later
- * See the files "COPYING.lgplv3" and "COPYING.gplv3"
- *
- * The Modified Berkeley Software Distribution License
- * See the file "COPYING.mbsd"
- *
- * These files have the following md5sums:
- *
- * 43b91e8ca915626ed3818ffb1b71248b pkg/libopts/COPYING.gplv3
- * 06a1a2e4760c90ea5e1dad8dfaac4d39 pkg/libopts/COPYING.lgplv3
- * 66a5cedaf62c4b2637025f049f9b826f pkg/libopts/COPYING.mbsd
- */
-
-#ifndef MAP_ANONYMOUS
-# ifdef MAP_ANON
-# define MAP_ANONYMOUS MAP_ANON
-# endif
-#endif
-
-/*
- * Some weird systems require that a specifically invalid FD number
- * get passed in as an argument value. Which value is that? Well,
- * as everybody knows, if open(2) fails, it returns -1, so that must
- * be the value. :)
- */
-#define AO_INVALID_FD -1
-
-#define FILE_WRITABLE(_prt,_flg) \
- ( (_prt & PROT_WRITE) \
- && ((_flg & (MAP_SHARED|MAP_PRIVATE)) == MAP_SHARED))
-#define MAP_FAILED_PTR ((void*)MAP_FAILED)
-
-/*=export_func text_mmap
- * private:
- *
- * what: map a text file with terminating NUL
- *
- * arg: char const*, pzFile, name of the file to map
- * arg: int, prot, mmap protections (see mmap(2))
- * arg: int, flags, mmap flags (see mmap(2))
- * arg: tmap_info_t*, mapinfo, returned info about the mapping
- *
- * ret-type: void*
- * ret-desc: The mmaped data address
- *
- * doc:
- *
- * This routine will mmap a file into memory ensuring that there is at least
- * one @file{NUL} character following the file data. It will return the
- * address where the file contents have been mapped into memory. If there is a
- * problem, then it will return @code{MAP_FAILED} and set @file{errno}
- * appropriately.
- *
- * The named file does not exist, @code{stat(2)} will set @file{errno} as it
- * will. If the file is not a regular file, @file{errno} will be
- * @code{EINVAL}. At that point, @code{open(2)} is attempted with the access
- * bits set appropriately for the requested @code{mmap(2)} protections and flag
- * bits. On failure, @file{errno} will be set according to the documentation
- * for @code{open(2)}. If @code{mmap(2)} fails, @file{errno} will be set as
- * that routine sets it. If @code{text_mmap} works to this point, a valid
- * address will be returned, but there may still be ``issues''.
- *
- * If the file size is not an even multiple of the system page size, then
- * @code{text_map} will return at this point and @file{errno} will be zero.
- * Otherwise, an anonymous map is attempted. If not available, then an attempt
- * is made to @code{mmap(2)} @file{/dev/zero}. If any of these fail, the
- * address of the file's data is returned, bug @code{no} @file{NUL} characters
- * are mapped after the end of the data.
- *
- * see: mmap(2), open(2), stat(2)
- *
- * err: Any error code issued by mmap(2), open(2), stat(2) is possible.
- * Additionally, if the specified file is not a regular file, then
- * errno will be set to @code{EINVAL}.
- *
- * example:
- * #include <mylib.h>
- * tmap_info_t mi;
- * int no_nul;
- * void* data = text_mmap( "file", PROT_WRITE, MAP_PRIVATE, &mi );
- * if (data == MAP_FAILED) return;
- * no_nul = (mi.txt_size == mi.txt_full_size);
- * << use the data >>
- * text_munmap( &mi );
-=*/
-void*
-text_mmap( char const* pzFile, int prot, int flags, tmap_info_t* pMI )
-{
- memset( pMI, 0, sizeof(*pMI) );
-#ifdef HAVE_MMAP
- pMI->txt_zero_fd = -1;
-#endif
- pMI->txt_fd = -1;
-
- /*
- * Make sure we can stat the regular file. Save the file size.
- */
- {
- struct stat sb;
- if (stat( pzFile, &sb ) != 0) {
- pMI->txt_errno = errno;
- return MAP_FAILED_PTR;
- }
-
- if (! S_ISREG( sb.st_mode )) {
- pMI->txt_errno = errno = EINVAL;
- return MAP_FAILED_PTR;
- }
-
- pMI->txt_size = sb.st_size;
- }
-
- /*
- * Map mmap flags and protections into open flags and do the open.
- */
- {
- int o_flag;
- /*
- * See if we will be updating the file. If we can alter the memory
- * and if we share the data and we are *not* copy-on-writing the data,
- * then our updates will show in the file, so we must open with
- * write access.
- */
- if (FILE_WRITABLE(prot,flags))
- o_flag = O_RDWR;
- else
- o_flag = O_RDONLY;
-
- /*
- * If you're not sharing the file and you are writing to it,
- * then don't let anyone else have access to the file.
- */
- if (((flags & MAP_SHARED) == 0) && (prot & PROT_WRITE))
- o_flag |= O_EXCL;
-
- pMI->txt_fd = open( pzFile, o_flag );
- }
-
- if (pMI->txt_fd == AO_INVALID_FD) {
- pMI->txt_errno = errno;
- return MAP_FAILED_PTR;
- }
-
-#ifdef HAVE_MMAP /* * * * * WITH MMAP * * * * * */
- /*
- * do the mmap. If we fail, then preserve errno, close the file and
- * return the failure.
- */
- pMI->txt_data =
- mmap(NULL, pMI->txt_size+1, prot, flags, pMI->txt_fd, (size_t)0);
- if (pMI->txt_data == MAP_FAILED_PTR) {
- pMI->txt_errno = errno;
- goto fail_return;
- }
-
- /*
- * Most likely, everything will turn out fine now. The only difficult
- * part at this point is coping with files with sizes that are a multiple
- * of the page size. Handling that is what this whole thing is about.
- */
- pMI->txt_zero_fd = -1;
- pMI->txt_errno = 0;
-
- {
- void* pNuls;
-#ifdef _SC_PAGESIZE
- size_t pgsz = sysconf(_SC_PAGESIZE);
-#else
- size_t pgsz = getpagesize();
-#endif
- /*
- * Compute the pagesize rounded mapped memory size.
- * IF this is not the same as the file size, then there are NUL's
- * at the end of the file mapping and all is okay.
- */
- pMI->txt_full_size = (pMI->txt_size + (pgsz - 1)) & ~(pgsz - 1);
- if (pMI->txt_size != pMI->txt_full_size)
- return pMI->txt_data;
-
- /*
- * Still here? We have to remap the trailing inaccessible page
- * either anonymously or to /dev/zero.
- */
- pMI->txt_full_size += pgsz;
-#if defined(MAP_ANONYMOUS)
- pNuls = mmap(
- (void*)(((char*)pMI->txt_data) + pMI->txt_size),
- pgsz, PROT_READ|PROT_WRITE,
- MAP_ANONYMOUS|MAP_FIXED|MAP_PRIVATE, AO_INVALID_FD, (size_t)0);
-
- if (pNuls != MAP_FAILED_PTR)
- return pMI->txt_data;
-
- pMI->txt_errno = errno;
-
-#elif defined(HAVE_DEV_ZERO)
- pMI->txt_zero_fd = open( "/dev/zero", O_RDONLY );
-
- if (pMI->txt_zero_fd == AO_INVALID_FD) {
- pMI->txt_errno = errno;
-
- } else {
- pNuls = mmap(
- (void*)(((char*)pMI->txt_data) + pMI->txt_size), pgsz,
- PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED,
- pMI->txt_zero_fd, 0 );
-
- if (pNuls != MAP_FAILED_PTR)
- return pMI->txt_data;
-
- pMI->txt_errno = errno;
- close( pMI->txt_zero_fd );
- pMI->txt_zero_fd = -1;
- }
-#endif
-
- pMI->txt_full_size = pMI->txt_size;
- }
-
- {
- void* p = AGALOC( pMI->txt_size+1, "file text" );
- memcpy( p, pMI->txt_data, pMI->txt_size );
- ((char*)p)[pMI->txt_size] = NUL;
- munmap(pMI->txt_data, pMI->txt_size );
- pMI->txt_data = p;
- }
- pMI->txt_alloc = 1;
- return pMI->txt_data;
-
-#else /* * * * * * no HAVE_MMAP * * * * * */
-
- pMI->txt_data = AGALOC( pMI->txt_size+1, "file text" );
- if (pMI->txt_data == NULL) {
- pMI->txt_errno = ENOMEM;
- goto fail_return;
- }
-
- {
- size_t sz = pMI->txt_size;
- char* pz = pMI->txt_data;
-
- while (sz > 0) {
- ssize_t rdct = read( pMI->txt_fd, pz, sz );
- if (rdct <= 0) {
- pMI->txt_errno = errno;
- fprintf( stderr, zFSErrReadFile,
- errno, strerror( errno ), pzFile );
- free( pMI->txt_data );
- goto fail_return;
- }
-
- pz += rdct;
- sz -= rdct;
- }
-
- *pz = NUL;
- }
-
- /*
- * We never need a dummy page mapped in
- */
- pMI->txt_zero_fd = -1;
- pMI->txt_errno = 0;
-
- return pMI->txt_data;
-
-#endif /* * * * * * no HAVE_MMAP * * * * * */
-
- fail_return:
- if (pMI->txt_fd >= 0) {
- close( pMI->txt_fd );
- pMI->txt_fd = -1;
- }
- errno = pMI->txt_errno;
- pMI->txt_data = MAP_FAILED_PTR;
- return pMI->txt_data;
-}
-
-
-/*=export_func text_munmap
- * private:
- *
- * what: unmap the data mapped in by text_mmap
- *
- * arg: tmap_info_t*, mapinfo, info about the mapping
- *
- * ret-type: int
- * ret-desc: -1 or 0. @file{errno} will have the error code.
- *
- * doc:
- *
- * This routine will unmap the data mapped in with @code{text_mmap} and close
- * the associated file descriptors opened by that function.
- *
- * see: munmap(2), close(2)
- *
- * err: Any error code issued by munmap(2) or close(2) is possible.
-=*/
-int
-text_munmap( tmap_info_t* pMI )
-{
-#ifdef HAVE_MMAP
- int res = 0;
- if (pMI->txt_alloc) {
- /*
- * IF the user has write permission and the text is not mapped private,
- * then write back any changes. Hopefully, nobody else has modified
- * the file in the mean time.
- */
- if ( ((pMI->txt_prot & PROT_WRITE) != 0)
- && ((pMI->txt_flags & MAP_PRIVATE) == 0)) {
-
- if (lseek(pMI->txt_fd, (size_t)0, SEEK_SET) != 0)
- goto error_return;
-
- res = (write( pMI->txt_fd, pMI->txt_data, pMI->txt_size ) < 0)
- ? errno : 0;
- }
-
- AGFREE( pMI->txt_data );
- errno = res;
- } else {
- res = munmap( pMI->txt_data, pMI->txt_full_size );
- }
- if (res != 0)
- goto error_return;
-
- res = close( pMI->txt_fd );
- if (res != 0)
- goto error_return;
-
- pMI->txt_fd = -1;
- errno = 0;
- if (pMI->txt_zero_fd != -1) {
- res = close( pMI->txt_zero_fd );
- pMI->txt_zero_fd = -1;
- }
-
- error_return:
- pMI->txt_errno = errno;
- return res;
-#else /* HAVE_MMAP */
-
- errno = 0;
- /*
- * IF the memory is writable *AND* it is not private (copy-on-write)
- * *AND* the memory is "sharable" (seen by other processes)
- * THEN rewrite the data.
- */
- if ( FILE_WRITABLE(pMI->txt_prot, pMI->txt_flags)
- && (lseek( pMI->txt_fd, 0, SEEK_SET ) >= 0) ) {
- write( pMI->txt_fd, pMI->txt_data, pMI->txt_size );
- }
-
- close( pMI->txt_fd );
- pMI->txt_fd = -1;
- pMI->txt_errno = errno;
- free( pMI->txt_data );
-
- return pMI->txt_errno;
-#endif /* HAVE_MMAP */
-}
-
-/*
- * Local Variables:
- * mode: C
- * c-file-style: "stroustrup"
- * indent-tabs-mode: nil
- * End:
- * end of autoopts/text_mmap.c */
+++ /dev/null
-
-/*
- * $Id: 63d3312044fd7854ad0995faea41c96f5185cb93 $
- * Time-stamp: "2008-11-16 14:51:48 bkorb"
- *
- * This file is part of AutoOpts, a companion to AutoGen.
- * AutoOpts is free software.
- * AutoOpts is copyright (c) 1992-2009 by Bruce Korb - all rights reserved
- *
- * AutoOpts is available under any one of two licenses. The license
- * in use must be one of these two and the choice is under the control
- * of the user of the license.
- *
- * The GNU Lesser General Public License, version 3 or later
- * See the files "COPYING.lgplv3" and "COPYING.gplv3"
- *
- * The Modified Berkeley Software Distribution License
- * See the file "COPYING.mbsd"
- *
- * These files have the following md5sums:
- *
- * 43b91e8ca915626ed3818ffb1b71248b pkg/libopts/COPYING.gplv3
- * 06a1a2e4760c90ea5e1dad8dfaac4d39 pkg/libopts/COPYING.lgplv3
- * 66a5cedaf62c4b2637025f049f9b826f pkg/libopts/COPYING.mbsd
- */
-
-#ifndef HAVE_PARSE_DURATION
-#include <time.h>
-
-static inline char *
-ao_xstrdup(char const * pz)
-{
- char * str;
- AGDUPSTR(str, pz, "time val str");
- return str;
-}
-
-#define xstrdup(_s) ao_xstrdup(_s)
-
-#include "parse-duration.c"
-
-#undef xstrdup
-#endif
-
-/*=export_func optionTimeVal
- * private:
- *
- * what: process an option with a time value.
- * arg: + tOptions* + pOpts + program options descriptor +
- * arg: + tOptDesc* + pOptDesc + the descriptor for this arg +
- *
- * doc:
- * Decipher a time duration value.
-=*/
-void
-optionTimeVal(tOptions* pOpts, tOptDesc* pOD )
-{
- long val;
-
- if ((pOD->fOptState & OPTST_RESET) != 0)
- return;
-
- val = parse_duration(pOD->optArg.argString);
- if (errno != 0)
- goto bad_time;
-
- if (pOD->fOptState & OPTST_ALLOC_ARG) {
- AGFREE(pOD->optArg.argString);
- pOD->fOptState &= ~OPTST_ALLOC_ARG;
- }
-
- pOD->optArg.argInt = val;
- return;
-
-bad_time:
- fprintf( stderr, zNotNumber, pOpts->pzProgName, pOD->optArg.argString );
- if ((pOpts->fOptSet & OPTPROC_ERRSTOP) != 0)
- (*(pOpts->pUsageProc))(pOpts, EXIT_FAILURE);
-
- pOD->optArg.argInt = ~0;
-}
-/*
- * Local Variables:
- * mode: C
- * c-file-style: "stroustrup"
- * indent-tabs-mode: nil
- * End:
- * end of autoopts/numeric.c */
+++ /dev/null
-/*
- * This file defines the string_tokenize interface
- * Time-stamp: "2007-11-12 20:40:36 bkorb"
- *
- * This file is part of AutoOpts, a companion to AutoGen.
- * AutoOpts is free software.
- * AutoOpts is copyright (c) 1992-2009 by Bruce Korb - all rights reserved
- *
- * AutoOpts is available under any one of two licenses. The license
- * in use must be one of these two and the choice is under the control
- * of the user of the license.
- *
- * The GNU Lesser General Public License, version 3 or later
- * See the files "COPYING.lgplv3" and "COPYING.gplv3"
- *
- * The Modified Berkeley Software Distribution License
- * See the file "COPYING.mbsd"
- *
- * These files have the following md5sums:
- *
- * 43b91e8ca915626ed3818ffb1b71248b pkg/libopts/COPYING.gplv3
- * 06a1a2e4760c90ea5e1dad8dfaac4d39 pkg/libopts/COPYING.lgplv3
- * 66a5cedaf62c4b2637025f049f9b826f pkg/libopts/COPYING.mbsd
- */
-
-#include <errno.h>
-#include <stdlib.h>
-
-#define cc_t const unsigned char
-#define ch_t unsigned char
-
-/* = = = START-STATIC-FORWARD = = = */
-/* static forward declarations maintained by mk-fwd */
-static void
-copy_cooked( ch_t** ppDest, char const ** ppSrc );
-
-static void
-copy_raw( ch_t** ppDest, char const ** ppSrc );
-/* = = = END-STATIC-FORWARD = = = */
-
-static void
-copy_cooked( ch_t** ppDest, char const ** ppSrc )
-{
- ch_t* pDest = (ch_t*)*ppDest;
- const ch_t* pSrc = (const ch_t*)(*ppSrc + 1);
-
- for (;;) {
- ch_t ch = *(pSrc++);
- switch (ch) {
- case NUL: *ppSrc = NULL; return;
- case '"': goto done;
- case '\\':
- pSrc += ao_string_cook_escape_char( (char*)pSrc, (char*)&ch, 0x7F );
- if (ch == 0x7F)
- break;
- /* FALLTHROUGH */
-
- default:
- *(pDest++) = ch;
- }
- }
-
- done:
- *ppDest = (ch_t*)pDest; /* next spot for storing character */
- *ppSrc = (char const *)pSrc; /* char following closing quote */
-}
-
-
-static void
-copy_raw( ch_t** ppDest, char const ** ppSrc )
-{
- ch_t* pDest = *ppDest;
- cc_t* pSrc = (cc_t*) (*ppSrc + 1);
-
- for (;;) {
- ch_t ch = *(pSrc++);
- switch (ch) {
- case NUL: *ppSrc = NULL; return;
- case '\'': goto done;
- case '\\':
- /*
- * *Four* escapes are handled: newline removal, escape char
- * quoting and apostrophe quoting
- */
- switch (*pSrc) {
- case NUL: *ppSrc = NULL; return;
- case '\r':
- if (*(++pSrc) == '\n')
- ++pSrc;
- continue;
-
- case '\n':
- ++pSrc;
- continue;
-
- case '\'':
- ch = '\'';
- /* FALLTHROUGH */
-
- case '\\':
- ++pSrc;
- break;
- }
- /* FALLTHROUGH */
-
- default:
- *(pDest++) = ch;
- }
- }
-
- done:
- *ppDest = pDest; /* next spot for storing character */
- *ppSrc = (char const *) pSrc; /* char following closing quote */
-}
-
-
-/*=export_func ao_string_tokenize
- *
- * what: tokenize an input string
- *
- * arg: + char const* + string + string to be tokenized +
- *
- * ret_type: token_list_t*
- * ret_desc: pointer to a structure that lists each token
- *
- * doc:
- *
- * This function will convert one input string into a list of strings.
- * The list of strings is derived by separating the input based on
- * white space separation. However, if the input contains either single
- * or double quote characters, then the text after that character up to
- * a matching quote will become the string in the list.
- *
- * The returned pointer should be deallocated with @code{free(3C)} when
- * are done using the data. The data are placed in a single block of
- * allocated memory. Do not deallocate individual token/strings.
- *
- * The structure pointed to will contain at least these two fields:
- * @table @samp
- * @item tkn_ct
- * The number of tokens found in the input string.
- * @item tok_list
- * An array of @code{tkn_ct + 1} pointers to substring tokens, with
- * the last pointer set to NULL.
- * @end table
- *
- * There are two types of quoted strings: single quoted (@code{'}) and
- * double quoted (@code{"}). Singly quoted strings are fairly raw in that
- * escape characters (@code{\\}) are simply another character, except when
- * preceding the following characters:
- * @example
- * @code{\\} double backslashes reduce to one
- * @code{'} incorporates the single quote into the string
- * @code{\n} suppresses both the backslash and newline character
- * @end example
- *
- * Double quote strings are formed according to the rules of string
- * constants in ANSI-C programs.
- *
- * example:
- * @example
- * #include <stdlib.h>
- * int ix;
- * token_list_t* ptl = ao_string_tokenize( some_string )
- * for (ix = 0; ix < ptl->tkn_ct; ix++)
- * do_something_with_tkn( ptl->tkn_list[ix] );
- * free( ptl );
- * @end example
- * Note that everything is freed with the one call to @code{free(3C)}.
- *
- * err:
- * NULL is returned and @code{errno} will be set to indicate the problem:
- * @itemize @bullet
- * @item
- * @code{EINVAL} - There was an unterminated quoted string.
- * @item
- * @code{ENOENT} - The input string was empty.
- * @item
- * @code{ENOMEM} - There is not enough memory.
- * @end itemize
-=*/
-token_list_t*
-ao_string_tokenize( char const* str )
-{
- int max_token_ct = 1; /* allow for trailing NUL on string */
- token_list_t* res;
-
- if (str == NULL) goto bogus_str;
-
- /*
- * Trim leading white space. Use "ENOENT" and a NULL return to indicate
- * an empty string was passed.
- */
- while (IS_WHITESPACE_CHAR(*str)) str++;
- if (*str == NUL) {
- bogus_str:
- errno = ENOENT;
- return NULL;
- }
-
- /*
- * Take an approximate count of tokens. If no quoted strings are used,
- * it will be accurate. If quoted strings are used, it will be a little
- * high and we'll squander the space for a few extra pointers.
- */
- {
- cc_t* pz = (cc_t*)str;
-
- do {
- max_token_ct++;
- while (! IS_WHITESPACE_CHAR(*++pz))
- if (*pz == NUL) goto found_nul;
- while (IS_WHITESPACE_CHAR(*pz)) pz++;
- } while (*pz != NUL);
-
- found_nul:
- ;
- }
-
- res = malloc( sizeof(*res) + strlen(str) + (max_token_ct * sizeof(ch_t*)) );
- if (res == NULL) {
- errno = ENOMEM;
- return res;
- }
-
- /*
- * Now copy each token into the output buffer.
- */
- {
- ch_t* pzDest = (ch_t*)(res->tkn_list + (max_token_ct + 1));
- res->tkn_ct = 0;
-
- do {
- res->tkn_list[ res->tkn_ct++ ] = pzDest;
- for (;;) {
- int ch = (ch_t)*str;
- if (IS_WHITESPACE_CHAR(ch)) {
- found_white_space:
- while (IS_WHITESPACE_CHAR(*++str)) ;
- break;
- }
-
- switch (ch) {
- case '"':
- copy_cooked( &pzDest, &str );
- if (str == NULL) {
- free(res);
- errno = EINVAL;
- return NULL;
- }
- if (IS_WHITESPACE_CHAR(*str))
- goto found_white_space;
- break;
-
- case '\'':
- copy_raw( &pzDest, &str );
- if (str == NULL) {
- free(res);
- errno = EINVAL;
- return NULL;
- }
- if (IS_WHITESPACE_CHAR(*str))
- goto found_white_space;
- break;
-
- case NUL:
- goto copy_done;
-
- default:
- str++;
- *(pzDest++) = ch;
- }
- } copy_done:;
-
- /*
- * NUL terminate the last token and see if we have any more tokens.
- */
- *(pzDest++) = NUL;
- } while (*str != NUL);
-
- res->tkn_list[ res->tkn_ct ] = NULL;
- }
-
- return res;
-}
-
-#ifdef TEST
-#include <stdio.h>
-#include <string.h>
-
-int
-main( int argc, char** argv )
-{
- if (argc == 1) {
- printf("USAGE: %s arg [ ... ]\n", *argv);
- return 1;
- }
- while (--argc > 0) {
- char* arg = *(++argv);
- token_list_t* p = ao_string_tokenize( arg );
- if (p == NULL) {
- printf( "Parsing string ``%s'' failed:\n\terrno %d (%s)\n",
- arg, errno, strerror( errno ));
- } else {
- int ix = 0;
- printf( "Parsed string ``%s''\ninto %d tokens:\n", arg, p->tkn_ct );
- do {
- printf( " %3d: ``%s''\n", ix+1, p->tkn_list[ix] );
- } while (++ix < p->tkn_ct);
- free(p);
- }
- }
- return 0;
-}
-#endif
-
-/*
- * Local Variables:
- * mode: C
- * c-file-style: "stroustrup"
- * indent-tabs-mode: nil
- * End:
- * end of autoopts/tokenize.c */
+++ /dev/null
-
-/*
- * usage.c $Id: f611ee45aa9aa8dc102b8acf6b4bc568c60fa99f $
- * Time-stamp: "2009-10-02 23:18:50 bkorb"
- *
- * This module implements the default usage procedure for
- * Automated Options. It may be overridden, of course.
- *
- * Sort options:
- --start=END-[S]TATIC-FORWARD --patt='^/\*($|[^:])' \
- --out=xx.c key='^[a-zA-Z0-9_]+\(' --trail='^/\*:' \
- --spac=2 --input=usage.c
- */
-
-/*
- * This file is part of AutoOpts, a companion to AutoGen.
- * AutoOpts is free software.
- * AutoOpts is copyright (c) 1992-2009 by Bruce Korb - all rights reserved
- *
- * AutoOpts is available under any one of two licenses. The license
- * in use must be one of these two and the choice is under the control
- * of the user of the license.
- *
- * The GNU Lesser General Public License, version 3 or later
- * See the files "COPYING.lgplv3" and "COPYING.gplv3"
- *
- * The Modified Berkeley Software Distribution License
- * See the file "COPYING.mbsd"
- *
- * These files have the following md5sums:
- *
- * 43b91e8ca915626ed3818ffb1b71248b pkg/libopts/COPYING.gplv3
- * 06a1a2e4760c90ea5e1dad8dfaac4d39 pkg/libopts/COPYING.lgplv3
- * 66a5cedaf62c4b2637025f049f9b826f pkg/libopts/COPYING.mbsd
- */
-
-#define OPTPROC_L_N_S (OPTPROC_LONGOPT | OPTPROC_SHORTOPT)
-
-static arg_types_t argTypes;
-
-FILE* option_usage_fp = NULL;
-static char zOptFmtLine[ 16 ];
-static ag_bool displayEnum;
-
-/* = = = START-STATIC-FORWARD = = = */
-/* static forward declarations maintained by mk-fwd */
-static ag_bool
-checkGNUUsage( tOptions* pOpts );
-
-static void
-printExtendedUsage(
- tOptions* pOptions,
- tOptDesc* pOD,
- arg_types_t* pAT );
-
-static void
-printInitList(
- tCC* const* papz,
- ag_bool* pInitIntro,
- tCC* pzRc,
- tCC* pzPN );
-
-static void
-printOptPreamble(
- tOptions* pOptions,
- tOptDesc* pOD,
- arg_types_t* pAT );
-
-static void
-printOneUsage(
- tOptions* pOptions,
- tOptDesc* pOD,
- arg_types_t* pAT );
-
-static void
-printOptionUsage(
- tOptions * pOpts,
- int ex_code,
- tCC * pOptTitle );
-
-static void
-printProgramDetails( tOptions* pOptions );
-
-static int
-setGnuOptFmts( tOptions* pOpts, tCC** ppT );
-
-static int
-setStdOptFmts( tOptions* pOpts, tCC** ppT );
-/* = = = END-STATIC-FORWARD = = = */
-
-
-/*
- * Figure out if we should try to format usage text sort-of like
- * the way many GNU programs do.
- */
-static ag_bool
-checkGNUUsage( tOptions* pOpts )
-{
- char* pz = getenv( "AUTOOPTS_USAGE" );
- if (pz == NULL)
- ;
-
- else if (streqvcmp( pz, "gnu" ) == 0)
- pOpts->fOptSet |= OPTPROC_GNUUSAGE;
-
- else if (streqvcmp( pz, "autoopts" ) == 0)
- pOpts->fOptSet &= ~OPTPROC_GNUUSAGE;
-
- return (pOpts->fOptSet & OPTPROC_GNUUSAGE) ? AG_TRUE : AG_FALSE;
-}
-
-
-/*=export_func optionOnlyUsage
- *
- * what: Print usage text for just the options
- * arg: + tOptions* + pOpts + program options descriptor +
- * arg: + int + ex_code + exit code for calling exit(3) +
- *
- * doc:
- * This routine will print only the usage for each option.
- * This function may be used when the emitted usage must incorporate
- * information not available to AutoOpts.
-=*/
-void
-optionOnlyUsage(
- tOptions* pOpts,
- int ex_code )
-{
- tCC* pOptTitle = NULL;
-
- /*
- * Determine which header and which option formatting strings to use
- */
- if (checkGNUUsage(pOpts)) {
- (void)setGnuOptFmts( pOpts, &pOptTitle );
- }
- else {
- (void)setStdOptFmts( pOpts, &pOptTitle );
- }
-
- printOptionUsage( pOpts, ex_code, pOptTitle );
-}
-
-
-/*=export_func optionUsage
- * private:
- *
- * what: Print usage text
- * arg: + tOptions* + pOptions + program options descriptor +
- * arg: + int + exitCode + exit code for calling exit(3) +
- *
- * doc:
- * This routine will print usage in both GNU-standard and AutoOpts-expanded
- * formats. The descriptor specifies the default, but AUTOOPTS_USAGE will
- * over-ride this, providing the value of it is set to either "gnu" or
- * "autoopts". This routine will @strong{not} return.
- *
- * If "exitCode" is "EX_USAGE" (normally 64), then output will to to stdout
- * and the actual exit code will be "EXIT_SUCCESS".
-=*/
-void
-optionUsage(
- tOptions* pOptions,
- int usage_exit_code )
-{
- int actual_exit_code =
- (usage_exit_code == EX_USAGE) ? EXIT_SUCCESS : usage_exit_code;
-
- displayEnum = AG_FALSE;
-
- /*
- * Paged usage will preset option_usage_fp to an output file.
- * If it hasn't already been set, then set it to standard output
- * on successful exit (help was requested), otherwise error out.
- *
- * Test the version before obtaining pzFullUsage or pzShortUsage.
- * These fields do not exist before revision 30.
- */
- {
- char const * pz;
-
- if (actual_exit_code == EXIT_SUCCESS) {
- pz = (pOptions->structVersion >= 30 * 4096)
- ? pOptions->pzFullUsage : NULL;
-
- if (option_usage_fp == NULL)
- option_usage_fp = stdout;
- } else {
- pz = (pOptions->structVersion >= 30 * 4096)
- ? pOptions->pzShortUsage : NULL;
-
- if (option_usage_fp == NULL)
- option_usage_fp = stderr;
- }
-
- if (pz != NULL) {
- fputs(pz, option_usage_fp);
- exit(actual_exit_code);
- }
- }
-
- fprintf( option_usage_fp, pOptions->pzUsageTitle, pOptions->pzProgName );
-
- {
- tCC* pOptTitle = NULL;
-
- /*
- * Determine which header and which option formatting strings to use
- */
- if (checkGNUUsage(pOptions)) {
- int flen = setGnuOptFmts( pOptions, &pOptTitle );
- sprintf( zOptFmtLine, zFmtFmt, flen );
- fputc( '\n', option_usage_fp );
- }
- else {
- int flen = setStdOptFmts( pOptions, &pOptTitle );
- sprintf( zOptFmtLine, zFmtFmt, flen );
-
- /*
- * When we exit with EXIT_SUCCESS and the first option is a doc
- * option, we do *NOT* want to emit the column headers.
- * Otherwise, we do.
- */
- if ( (usage_exit_code != EXIT_SUCCESS)
- || ((pOptions->pOptDesc->fOptState & OPTST_DOCUMENT) == 0) )
-
- fputs( pOptTitle, option_usage_fp );
- }
-
- printOptionUsage( pOptions, usage_exit_code, pOptTitle );
- }
-
- /*
- * Describe the mechanics of denoting the options
- */
- switch (pOptions->fOptSet & OPTPROC_L_N_S) {
- case OPTPROC_L_N_S: fputs( zFlagOkay, option_usage_fp ); break;
- case OPTPROC_SHORTOPT: break;
- case OPTPROC_LONGOPT: fputs( zNoFlags, option_usage_fp ); break;
- case 0: fputs( zOptsOnly, option_usage_fp ); break;
- }
-
- if ((pOptions->fOptSet & OPTPROC_NUM_OPT) != 0) {
- fputs( zNumberOpt, option_usage_fp );
- }
-
- if ((pOptions->fOptSet & OPTPROC_REORDER) != 0) {
- fputs( zReorder, option_usage_fp );
- }
-
- if (pOptions->pzExplain != NULL)
- fputs( pOptions->pzExplain, option_usage_fp );
-
- /*
- * IF the user is asking for help (thus exiting with SUCCESS),
- * THEN see what additional information we can provide.
- */
- if (usage_exit_code == EXIT_SUCCESS)
- printProgramDetails( pOptions );
-
- if (pOptions->pzBugAddr != NULL)
- fprintf( option_usage_fp, zPlsSendBugs, pOptions->pzBugAddr );
- fflush( option_usage_fp );
-
- exit( actual_exit_code );
-}
-
-
-/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
- *
- * PER OPTION TYPE USAGE INFORMATION
- */
-static void
-printExtendedUsage(
- tOptions* pOptions,
- tOptDesc* pOD,
- arg_types_t* pAT )
-{
- /*
- * IF there are option conflicts or dependencies,
- * THEN print them here.
- */
- if ( (pOD->pOptMust != NULL)
- || (pOD->pOptCant != NULL) ) {
-
- fputs( zTabHyp, option_usage_fp );
-
- /*
- * DEPENDENCIES:
- */
- if (pOD->pOptMust != NULL) {
- const int* pOptNo = pOD->pOptMust;
-
- fputs( zReqThese, option_usage_fp );
- for (;;) {
- fprintf( option_usage_fp, zTabout, pOptions->pOptDesc[
- *pOptNo ].pz_Name );
- if (*++pOptNo == NO_EQUIVALENT)
- break;
- }
-
- if (pOD->pOptCant != NULL)
- fputs( zTabHypAnd, option_usage_fp );
- }
-
- /*
- * CONFLICTS:
- */
- if (pOD->pOptCant != NULL) {
- const int* pOptNo = pOD->pOptCant;
-
- fputs( zProhib, option_usage_fp );
- for (;;) {
- fprintf( option_usage_fp, zTabout, pOptions->pOptDesc[
- *pOptNo ].pz_Name );
- if (*++pOptNo == NO_EQUIVALENT)
- break;
- }
- }
- }
-
- /*
- * IF there is a disablement string
- * THEN print the disablement info
- */
- if (pOD->pz_DisableName != NULL )
- fprintf( option_usage_fp, zDis, pOD->pz_DisableName );
-
- /*
- * Check for argument types that have callbacks with magical properties
- */
- switch (OPTST_GET_ARGTYPE(pOD->fOptState)) {
- case OPARG_TYPE_NUMERIC:
- /*
- * IF the numeric option has a special callback,
- * THEN call it, requesting the range or other special info
- */
- if ( (pOD->pOptProc != NULL)
- && (pOD->pOptProc != optionNumericVal) ) {
- (*(pOD->pOptProc))(OPTPROC_EMIT_USAGE, pOD);
- }
- break;
-
- case OPARG_TYPE_FILE:
- (*(pOD->pOptProc))(OPTPROC_EMIT_USAGE, pOD);
- break;
- }
-
- /*
- * IF the option defaults to being enabled,
- * THEN print that out
- */
- if (pOD->fOptState & OPTST_INITENABLED)
- fputs( zEnab, option_usage_fp );
-
- /*
- * IF the option is in an equivalence class
- * AND not the designated lead
- * THEN print equivalence and leave it at that.
- */
- if ( (pOD->optEquivIndex != NO_EQUIVALENT)
- && (pOD->optEquivIndex != pOD->optActualIndex ) ) {
- fprintf( option_usage_fp, zAlt,
- pOptions->pOptDesc[ pOD->optEquivIndex ].pz_Name );
- return;
- }
-
- /*
- * IF this particular option can NOT be preset
- * AND some form of presetting IS allowed,
- * AND it is not an auto-managed option (e.g. --help, et al.)
- * THEN advise that this option may not be preset.
- */
- if ( ((pOD->fOptState & OPTST_NO_INIT) != 0)
- && ( (pOptions->papzHomeList != NULL)
- || (pOptions->pzPROGNAME != NULL)
- )
- && (pOD->optIndex < pOptions->presetOptCt)
- )
-
- fputs( zNoPreset, option_usage_fp );
-
- /*
- * Print the appearance requirements.
- */
- if (OPTST_GET_ARGTYPE(pOD->fOptState) == OPARG_TYPE_MEMBERSHIP)
- fputs( zMembers, option_usage_fp );
-
- else switch (pOD->optMinCt) {
- case 1:
- case 0:
- switch (pOD->optMaxCt) {
- case 0: fputs( zPreset, option_usage_fp ); break;
- case NOLIMIT: fputs( zNoLim, option_usage_fp ); break;
- case 1: break;
- /*
- * IF the max is more than one but limited, print "UP TO" message
- */
- default: fprintf( option_usage_fp, zUpTo, pOD->optMaxCt ); break;
- }
- break;
-
- default:
- /*
- * More than one is required. Print the range.
- */
- fprintf( option_usage_fp, zMust, pOD->optMinCt, pOD->optMaxCt );
- }
-
- if ( NAMED_OPTS( pOptions )
- && (pOptions->specOptIdx.default_opt == pOD->optIndex))
- fputs( zDefaultOpt, option_usage_fp );
-}
-
-
-/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
- *
- * Figure out where all the initialization files might live.
- * This requires translating some environment variables and
- * testing to see if a name is a directory or a file. It's
- * squishy, but important to tell users how to find these files.
- */
-static void
-printInitList(
- tCC* const* papz,
- ag_bool* pInitIntro,
- tCC* pzRc,
- tCC* pzPN )
-{
- char zPath[ AG_PATH_MAX+1 ];
-
- if (papz == NULL)
- return;
-
- fputs( zPresetIntro, option_usage_fp );
- *pInitIntro = AG_FALSE;
-
- for (;;) {
- char const* pzPath = *(papz++);
-
- if (pzPath == NULL)
- break;
-
- if (optionMakePath(zPath, (int)sizeof( zPath ), pzPath, pzPN))
- pzPath = zPath;
-
- /*
- * Print the name of the "homerc" file. If the "rcfile" name is
- * not empty, we may or may not print that, too...
- */
- fprintf( option_usage_fp, zPathFmt, pzPath );
- if (*pzRc != NUL) {
- struct stat sb;
-
- /*
- * IF the "homerc" file is a directory,
- * then append the "rcfile" name.
- */
- if ( (stat( pzPath, &sb ) == 0)
- && S_ISDIR( sb.st_mode ) ) {
- fputc( DIRCH, option_usage_fp );
- fputs( pzRc, option_usage_fp );
- }
- }
-
- fputc( '\n', option_usage_fp );
- }
-}
-
-
-static void
-printOptPreamble(
- tOptions* pOptions,
- tOptDesc* pOD,
- arg_types_t* pAT )
-{
- /*
- * Flag prefix: IF no flags at all, then omit it. If not printable
- * (not allowed for this option), then blank, else print it.
- * Follow it with a comma if we are doing GNU usage and long
- * opts are to be printed too.
- */
- if ((pOptions->fOptSet & OPTPROC_SHORTOPT) == 0)
- fputs( pAT->pzSpc, option_usage_fp );
-
- else if (! IS_GRAPHIC_CHAR(pOD->optValue)) {
- if ( (pOptions->fOptSet & (OPTPROC_GNUUSAGE|OPTPROC_LONGOPT))
- == (OPTPROC_GNUUSAGE|OPTPROC_LONGOPT))
- fputc( ' ', option_usage_fp );
- fputs( pAT->pzNoF, option_usage_fp );
-
- } else {
- fprintf( option_usage_fp, " -%c", pOD->optValue );
- if ( (pOptions->fOptSet & (OPTPROC_GNUUSAGE|OPTPROC_LONGOPT))
- == (OPTPROC_GNUUSAGE|OPTPROC_LONGOPT))
- fputs( ", ", option_usage_fp );
- }
-}
-
-/*
- * Print the usage information for a single option.
- */
-static void
-printOneUsage(
- tOptions* pOptions,
- tOptDesc* pOD,
- arg_types_t* pAT )
-{
- printOptPreamble(pOptions, pOD, pAT);
-
- {
- char z[ 80 ];
- tCC* pzArgType;
- /*
- * Determine the argument type string first on its usage, then,
- * when the option argument is required, base the type string on the
- * argument type.
- */
- if (pOD->fOptState & OPTST_ARG_OPTIONAL) {
- pzArgType = pAT->pzOpt;
-
- } else switch (OPTST_GET_ARGTYPE(pOD->fOptState)) {
- case OPARG_TYPE_NONE: pzArgType = pAT->pzNo; break;
- case OPARG_TYPE_ENUMERATION: pzArgType = pAT->pzKey; break;
- case OPARG_TYPE_FILE : pzArgType = pAT->pzFile; break;
- case OPARG_TYPE_MEMBERSHIP: pzArgType = pAT->pzKeyL; break;
- case OPARG_TYPE_BOOLEAN: pzArgType = pAT->pzBool; break;
- case OPARG_TYPE_NUMERIC: pzArgType = pAT->pzNum; break;
- case OPARG_TYPE_HIERARCHY: pzArgType = pAT->pzNest; break;
- case OPARG_TYPE_STRING: pzArgType = pAT->pzStr; break;
- case OPARG_TYPE_TIME: pzArgType = pAT->pzTime; break;
- default: goto bogus_desc;
- }
-
- snprintf( z, sizeof(z), pAT->pzOptFmt, pzArgType, pOD->pz_Name,
- (pOD->optMinCt != 0) ? pAT->pzReq : pAT->pzOpt );
-
- fprintf( option_usage_fp, zOptFmtLine, z, pOD->pzText );
-
- switch (OPTST_GET_ARGTYPE(pOD->fOptState)) {
- case OPARG_TYPE_ENUMERATION:
- case OPARG_TYPE_MEMBERSHIP:
- displayEnum = (pOD->pOptProc != NULL) ? AG_TRUE : displayEnum;
- }
- }
- return;
-
- bogus_desc:
- fprintf( stderr, zInvalOptDesc, pOD->pz_Name );
- exit( EX_SOFTWARE );
-}
-
-
-/*
- * Print out the usage information for just the options.
- */
-static void
-printOptionUsage(
- tOptions * pOpts,
- int ex_code,
- tCC * pOptTitle )
-{
- int ct = pOpts->optCt;
- int optNo = 0;
- tOptDesc * pOD = pOpts->pOptDesc;
- int docCt = 0;
-
- do {
- if ((pOD->fOptState & OPTST_NO_USAGE_MASK) != 0) {
-
- /*
- * IF this is a compiled-out option
- * *AND* usage was requested with "omitted-usage"
- * *AND* this is NOT abbreviated usage
- * THEN display this option.
- */
- if ( (pOD->fOptState == (OPTST_OMITTED | OPTST_NO_INIT))
- && (pOD->pz_Name != NULL)
- && (ex_code == EXIT_SUCCESS)) {
-
- char const * why_pz =
- (pOD->pzText == NULL) ? zDisabledWhy : pOD->pzText;
- printOptPreamble(pOpts, pOD, &argTypes);
- fprintf(option_usage_fp, zDisabledOpt, pOD->pz_Name, why_pz);
- }
-
- continue;
- }
-
- if ((pOD->fOptState & OPTST_DOCUMENT) != 0) {
- if (ex_code == EXIT_SUCCESS) {
- fprintf(option_usage_fp, argTypes.pzBrk, pOD->pzText,
- pOptTitle);
- docCt++;
- }
-
- continue;
- }
-
- /*
- * IF this is the first auto-opt maintained option
- * *AND* we are doing a full help
- * *AND* there are documentation options
- * *AND* the last one was not a doc option,
- * THEN document that the remaining options are not user opts
- */
- if ( (pOpts->presetOptCt == optNo)
- && (ex_code == EXIT_SUCCESS)
- && (docCt > 0)
- && ((pOD[-1].fOptState & OPTST_DOCUMENT) == 0) )
- fprintf( option_usage_fp, argTypes.pzBrk, zAuto, pOptTitle );
-
- printOneUsage(pOpts, pOD, &argTypes);
-
- /*
- * IF we were invoked because of the --help option,
- * THEN print all the extra info
- */
- if (ex_code == EXIT_SUCCESS)
- printExtendedUsage( pOpts, pOD, &argTypes );
-
- } while (pOD++, optNo++, (--ct > 0));
-
- fputc( '\n', option_usage_fp );
-}
-
-
-/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
- *
- * PROGRAM DETAILS
- */
-static void
-printProgramDetails( tOptions* pOptions )
-{
- ag_bool initIntro = AG_TRUE;
-
- /*
- * Display all the places we look for config files
- */
- printInitList( pOptions->papzHomeList, &initIntro,
- pOptions->pzRcName, pOptions->pzProgPath );
-
- /*
- * Let the user know about environment variable settings
- */
- if ((pOptions->fOptSet & OPTPROC_ENVIRON) != 0) {
- if (initIntro)
- fputs( zPresetIntro, option_usage_fp );
-
- fprintf( option_usage_fp, zExamineFmt, pOptions->pzPROGNAME );
- }
-
- /*
- * IF we found an enumeration,
- * THEN hunt for it again. Call the handler proc with a NULL
- * option struct pointer. That tells it to display the keywords.
- */
- if (displayEnum) {
- int ct = pOptions->optCt;
- int optNo = 0;
- tOptDesc* pOD = pOptions->pOptDesc;
-
- fputc( '\n', option_usage_fp );
- fflush( option_usage_fp );
- do {
- switch (OPTST_GET_ARGTYPE(pOD->fOptState)) {
- case OPARG_TYPE_ENUMERATION:
- case OPARG_TYPE_MEMBERSHIP:
- (*(pOD->pOptProc))(OPTPROC_EMIT_USAGE, pOD);
- }
- } while (pOD++, optNo++, (--ct > 0));
- }
-
- /*
- * If there is a detail string, now is the time for that.
- */
- if (pOptions->pzDetail != NULL)
- fputs( pOptions->pzDetail, option_usage_fp );
-}
-
-
-/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
- *
- * OPTION LINE FORMATTING SETUP
- *
- * The "OptFmt" formats receive three arguments:
- * 1. the type of the option's argument
- * 2. the long name of the option
- * 3. "YES" or "no ", depending on whether or not the option must appear
- * on the command line.
- * These formats are used immediately after the option flag (if used) has
- * been printed.
- *
- * Set up the formatting for GNU-style output
- */
-static int
-setGnuOptFmts( tOptions* pOpts, tCC** ppT )
-{
- int flen = 22;
- *ppT = zNoRq_ShrtTtl;
-
- argTypes.pzStr = zGnuStrArg;
- argTypes.pzReq = zOneSpace;
- argTypes.pzNum = zGnuNumArg;
- argTypes.pzKey = zGnuKeyArg;
- argTypes.pzKeyL = zGnuKeyLArg;
- argTypes.pzTime = zGnuTimeArg;
- argTypes.pzFile = zGnuFileArg;
- argTypes.pzBool = zGnuBoolArg;
- argTypes.pzNest = zGnuNestArg;
- argTypes.pzOpt = zGnuOptArg;
- argTypes.pzNo = zOneSpace;
- argTypes.pzBrk = zGnuBreak;
- argTypes.pzNoF = zSixSpaces;
- argTypes.pzSpc = zThreeSpaces;
-
- switch (pOpts->fOptSet & OPTPROC_L_N_S) {
- case OPTPROC_L_N_S: argTypes.pzOptFmt = zGnuOptFmt; break;
- case OPTPROC_LONGOPT: argTypes.pzOptFmt = zGnuOptFmt; break;
- case 0: argTypes.pzOptFmt = zGnuOptFmt + 2; break;
- case OPTPROC_SHORTOPT:
- argTypes.pzOptFmt = zShrtGnuOptFmt;
- zGnuStrArg[0] = zGnuNumArg[0] = zGnuKeyArg[0] = zGnuBoolArg[0] = ' ';
- argTypes.pzOpt = " [arg]";
- flen = 8;
- break;
- }
-
- return flen;
-}
-
-
-/*
- * Standard (AutoOpts normal) option line formatting
- */
-static int
-setStdOptFmts( tOptions* pOpts, tCC** ppT )
-{
- int flen = 0;
-
- argTypes.pzStr = zStdStrArg;
- argTypes.pzReq = zStdReqArg;
- argTypes.pzNum = zStdNumArg;
- argTypes.pzKey = zStdKeyArg;
- argTypes.pzKeyL = zStdKeyLArg;
- argTypes.pzTime = zStdTimeArg;
- argTypes.pzFile = zStdFileArg;
- argTypes.pzBool = zStdBoolArg;
- argTypes.pzNest = zStdNestArg;
- argTypes.pzOpt = zStdOptArg;
- argTypes.pzNo = zStdNoArg;
- argTypes.pzBrk = zStdBreak;
- argTypes.pzNoF = zFiveSpaces;
- argTypes.pzSpc = zTwoSpaces;
-
- switch (pOpts->fOptSet & (OPTPROC_NO_REQ_OPT | OPTPROC_SHORTOPT)) {
- case (OPTPROC_NO_REQ_OPT | OPTPROC_SHORTOPT):
- *ppT = zNoRq_ShrtTtl;
- argTypes.pzOptFmt = zNrmOptFmt;
- flen = 19;
- break;
-
- case OPTPROC_NO_REQ_OPT:
- *ppT = zNoRq_NoShrtTtl;
- argTypes.pzOptFmt = zNrmOptFmt;
- flen = 19;
- break;
-
- case OPTPROC_SHORTOPT:
- *ppT = zReq_ShrtTtl;
- argTypes.pzOptFmt = zReqOptFmt;
- flen = 24;
- break;
-
- case 0:
- *ppT = zReq_NoShrtTtl;
- argTypes.pzOptFmt = zReqOptFmt;
- flen = 24;
- }
-
- return flen;
-}
-
-
-/*:
- * Local Variables:
- * mode: C
- * c-file-style: "stroustrup"
- * indent-tabs-mode: nil
- * End:
- * end of autoopts/usage.c */
+++ /dev/null
-/* ANSI-C code produced by gperf version 3.0.2 */
-
-
-#if 0 /* gperf build options: */
-// %struct-type
-// %language=ANSI-C
-// %includes
-// %global-table
-// %omit-struct-type
-// %readonly-tables
-// %compare-strncmp
-//
-// %define slot-name vtp_name
-// %define hash-function-name value_type_hash
-// %define lookup-function-name find_value_type_name
-// %define word-array-name value_type_table
-// %define initializer-suffix ,VTP_COUNT_KWD
-#endif /* gperf build options: */
-
-#include "value-type.h"
-
-typedef struct {
- char const * vtp_name;
- value_type_enum_t vtp_id;
-} value_type_map_t;
-#include <string.h>
-
-/* maximum key range = 20, duplicates = 0 */
-
-#ifdef __GNUC__
-#else
-#ifdef __cplusplus
-#endif
-#endif
-inline static unsigned int
-value_type_hash (register const char *str, register unsigned int len)
-{
- static const unsigned char asso_values[] =
- {
- 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
- 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
- 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
- 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
- 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
- 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
- 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
- 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
- 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
- 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
- 23, 10, 23, 23, 23, 23, 23, 23, 23, 23,
- 23, 5, 23, 23, 5, 0, 0, 23, 15, 23,
- 23, 10, 23, 23, 23, 23, 23, 23, 23, 23,
- 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
- 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
- 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
- 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
- 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
- 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
- 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
- 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
- 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
- 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
- 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
- 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
- 23, 23, 23, 23, 23, 23
- };
- return len + asso_values[(unsigned char)str[2]];
-}
-
-static const value_type_map_t value_type_table[] =
- {
- {"",VTP_COUNT_KWD}, {"",VTP_COUNT_KWD},
- {"",VTP_COUNT_KWD},
- {"set", VTP_KWD_SET},
- {"",VTP_COUNT_KWD}, {"",VTP_COUNT_KWD},
- {"nested", VTP_KWD_NESTED},
- {"integer", VTP_KWD_INTEGER},
- {"",VTP_COUNT_KWD},
- {"bool", VTP_KWD_BOOL},
- {"",VTP_COUNT_KWD},
- {"string", VTP_KWD_STRING},
- {"boolean", VTP_KWD_BOOLEAN},
- {"",VTP_COUNT_KWD},
- {"set-membership", VTP_KWD_SET_MEMBERSHIP},
- {"",VTP_COUNT_KWD}, {"",VTP_COUNT_KWD},
- {"keyword", VTP_KWD_KEYWORD},
- {"",VTP_COUNT_KWD},
- {"hierarchy", VTP_KWD_HIERARCHY},
- {"",VTP_COUNT_KWD}, {"",VTP_COUNT_KWD},
- {"invalid", VTP_KWD_INVALID}
- };
-
-#ifdef __GNUC__
-#endif
-static inline const value_type_map_t *
-find_value_type_name (register const char *str, register unsigned int len)
-{
- if (len <= 14 && len >= 3)
- {
- register int key = value_type_hash (str, len);
-
- if (key <= 22 && key >= 0)
- {
- register const char *s = value_type_table[key].vtp_name;
-
- if (*str == *s && !strncmp (str + 1, s + 1, len - 1) && s[len] == '\0')
- return &value_type_table[key];
- }
- }
- return 0;
-}
-
-
-value_type_enum_t
-find_value_type_id(char const * str, unsigned int len)
-{
- const value_type_map_t * p =
- find_value_type_name(str, len);
- return (p == 0) ? VTP_KWD_INVALID : p->vtp_id;
-}
+++ /dev/null
-/*
- * Generated header for gperf generated source Sun Nov 8 08:41:19 PST 2009
- * This file enumerates the list of names and declares the
- * procedure for mapping string names to the enum value.
- */
-#ifndef AUTOOPTS_VALUE_TYPE_H_GUARD
-#define AUTOOPTS_VALUE_TYPE_H_GUARD 1
-
-typedef enum {
- VTP_KWD_INVALID,
- VTP_KWD_STRING,
- VTP_KWD_INTEGER,
- VTP_KWD_BOOLEAN,
- VTP_KWD_BOOL,
- VTP_KWD_KEYWORD,
- VTP_KWD_SET,
- VTP_KWD_SET_MEMBERSHIP,
- VTP_KWD_NESTED,
- VTP_KWD_HIERARCHY,
- VTP_COUNT_KWD
-} value_type_enum_t;
-
-extern value_type_enum_t
-find_value_type_id(char const * str, unsigned int len);
-#endif /* AUTOOPTS_VALUE_TYPE_H_GUARD */
+++ /dev/null
-
-/* $Id: e21e2bf9958c54e440efbdc7c1026e46ac589f66 $
- * Time-stamp: "2008-07-27 10:11:30 bkorb"
- *
- * This module implements the default usage procedure for
- * Automated Options. It may be overridden, of course.
- */
-
-/*
- * This file is part of AutoOpts, a companion to AutoGen.
- * AutoOpts is free software.
- * AutoOpts is copyright (c) 1992-2009 by Bruce Korb - all rights reserved
- *
- * AutoOpts is available under any one of two licenses. The license
- * in use must be one of these two and the choice is under the control
- * of the user of the license.
- *
- * The GNU Lesser General Public License, version 3 or later
- * See the files "COPYING.lgplv3" and "COPYING.gplv3"
- *
- * The Modified Berkeley Software Distribution License
- * See the file "COPYING.mbsd"
- *
- * These files have the following md5sums:
- *
- * 43b91e8ca915626ed3818ffb1b71248b pkg/libopts/COPYING.gplv3
- * 06a1a2e4760c90ea5e1dad8dfaac4d39 pkg/libopts/COPYING.lgplv3
- * 66a5cedaf62c4b2637025f049f9b826f pkg/libopts/COPYING.mbsd
- */
-
-/* = = = START-STATIC-FORWARD = = = */
-/* static forward declarations maintained by mk-fwd */
-static void
-printVersion( tOptions* pOpts, tOptDesc* pOD, FILE* fp );
-/* = = = END-STATIC-FORWARD = = = */
-
-/*=export_func optionVersion
- *
- * what: return the compiled AutoOpts version number
- * ret_type: char const*
- * ret_desc: the version string in constant memory
- * doc:
- * Returns the full version string compiled into the library.
- * The returned string cannot be modified.
-=*/
-char const*
-optionVersion( void )
-{
- static char const zVersion[] =
- STR( AO_CURRENT.AO_REVISION );
-
- return zVersion;
-}
-
-
-static void
-printVersion( tOptions* pOpts, tOptDesc* pOD, FILE* fp )
-{
- char swCh;
-
- /*
- * IF the optional argument flag is off, or the argument is not provided,
- * then just print the version.
- */
- if ( ((pOD->fOptState & OPTST_ARG_OPTIONAL) == 0)
- || (pOD->optArg.argString == NULL))
- swCh = 'v';
- else swCh = tolower(pOD->optArg.argString[0]);
-
- if (pOpts->pzFullVersion != NULL) {
- fputs( pOpts->pzFullVersion, fp );
- fputc( '\n', fp );
-
- } else {
- char const *pz = pOpts->pzUsageTitle;
- do { fputc(*pz, fp); } while (*(pz++) != '\n');
- }
-
- switch (swCh) {
- case NUL: /* arg provided, but empty */
- case 'v':
- break;
-
- case 'c':
- if (pOpts->pzCopyright != NULL) {
- fputs( pOpts->pzCopyright, fp );
- fputc( '\n', fp );
- }
- fprintf( fp, zAO_Ver, optionVersion() );
- if (pOpts->pzBugAddr != NULL)
- fprintf( fp, zPlsSendBugs, pOpts->pzBugAddr );
- break;
-
- case 'n':
- if (pOpts->pzCopyright != NULL) {
- fputs( pOpts->pzCopyright, fp );
- fputc( '\n', fp );
- fputc( '\n', fp );
- }
-
- if (pOpts->pzCopyNotice != NULL) {
- fputs( pOpts->pzCopyNotice, fp );
- fputc( '\n', fp );
- }
-
- fprintf( fp, zAO_Ver, optionVersion() );
- if (pOpts->pzBugAddr != NULL)
- fprintf( fp, zPlsSendBugs, pOpts->pzBugAddr );
- break;
-
- default:
- fprintf( stderr, zBadVerArg, swCh );
- exit( EXIT_FAILURE );
- }
-
- exit( EXIT_SUCCESS );
-}
-
-/*=export_func optionPrintVersion
- * private:
- *
- * what: Print the program version
- * arg: + tOptions* + pOpts + program options descriptor +
- * arg: + tOptDesc* + pOptDesc + the descriptor for this arg +
- *
- * doc:
- * This routine will print the version to stdout.
-=*/
-void
-optionPrintVersion( tOptions* pOpts, tOptDesc* pOD )
-{
- printVersion( pOpts, pOD, stdout );
-}
-
-/*=export_func optionVersionStderr
- * private:
- *
- * what: Print the program version to stderr
- * arg: + tOptions* + pOpts + program options descriptor +
- * arg: + tOptDesc* + pOptDesc + the descriptor for this arg +
- *
- * doc:
- * This routine will print the version to stderr.
-=*/
-void
-optionVersionStderr( tOptions* pOpts, tOptDesc* pOD )
-{
- printVersion( pOpts, pOD, stderr );
-}
-
-/*
- * Local Variables:
- * mode: C
- * c-file-style: "stroustrup"
- * indent-tabs-mode: nil
- * End:
- * end of autoopts/version.c */
+++ /dev/null
-/* ANSI-C code produced by gperf version 3.0.2 */
-
-
-#if 0 /* gperf build options: */
-// %struct-type
-// %language=ANSI-C
-// %includes
-// %global-table
-// %omit-struct-type
-// %readonly-tables
-// %compare-strncmp
-//
-// %define slot-name xat_name
-// %define hash-function-name xat_attribute_hash
-// %define lookup-function-name find_xat_attribute_name
-// %define word-array-name xat_attribute_table
-// %define initializer-suffix ,XAT_COUNT_KWD
-#endif /* gperf build options: */
-
-#include "xat-attribute.h"
-
-typedef struct {
- char const * xat_name;
- xat_attribute_enum_t xat_id;
-} xat_attribute_map_t;
-#include <string.h>
-
-/* maximum key range = 9, duplicates = 0 */
-
-#ifdef __GNUC__
-#else
-#ifdef __cplusplus
-#endif
-#endif
-inline static unsigned int
-xat_attribute_hash (register const char *str, register unsigned int len)
-{
- static const unsigned char asso_values[] =
- {
- 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
- 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
- 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
- 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
- 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
- 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
- 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
- 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
- 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
- 13, 13, 13, 13, 13, 13, 13, 13, 13, 0,
- 13, 13, 13, 13, 13, 5, 13, 5, 13, 0,
- 13, 13, 13, 13, 13, 13, 0, 0, 13, 0,
- 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
- 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
- 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
- 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
- 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
- 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
- 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
- 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
- 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
- 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
- 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
- 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
- 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
- 13, 13, 13, 13, 13, 13
- };
- return len + asso_values[(unsigned char)str[0]];
-}
-
-static const xat_attribute_map_t xat_attribute_table[] =
- {
- {"",XAT_COUNT_KWD}, {"",XAT_COUNT_KWD},
- {"",XAT_COUNT_KWD}, {"",XAT_COUNT_KWD},
- {"type", XAT_KWD_TYPE},
- {"words", XAT_KWD_WORDS},
- {"cooked", XAT_KWD_COOKED},
- {"members", XAT_KWD_MEMBERS},
- {"uncooked", XAT_KWD_UNCOOKED},
- {"keep", XAT_KWD_KEEP},
- {"",XAT_COUNT_KWD}, {"",XAT_COUNT_KWD},
- {"invalid", XAT_KWD_INVALID}
- };
-
-#ifdef __GNUC__
-#endif
-static inline const xat_attribute_map_t *
-find_xat_attribute_name (register const char *str, register unsigned int len)
-{
- if (len <= 8 && len >= 4)
- {
- register int key = xat_attribute_hash (str, len);
-
- if (key <= 12 && key >= 0)
- {
- register const char *s = xat_attribute_table[key].xat_name;
-
- if (*str == *s && !strncmp (str + 1, s + 1, len - 1) && s[len] == '\0')
- return &xat_attribute_table[key];
- }
- }
- return 0;
-}
-
-
-xat_attribute_enum_t
-find_xat_attribute_id(char const * str, unsigned int len)
-{
- const xat_attribute_map_t * p =
- find_xat_attribute_name(str, len);
- return (p == 0) ? XAT_KWD_INVALID : p->xat_id;
-}
+++ /dev/null
-/*
- * Generated header for gperf generated source Sun Nov 8 08:41:19 PST 2009
- * This file enumerates the list of names and declares the
- * procedure for mapping string names to the enum value.
- */
-#ifndef AUTOOPTS_XAT_ATTRIBUTE_H_GUARD
-#define AUTOOPTS_XAT_ATTRIBUTE_H_GUARD 1
-
-typedef enum {
- XAT_KWD_INVALID,
- XAT_KWD_TYPE,
- XAT_KWD_WORDS,
- XAT_KWD_MEMBERS,
- XAT_KWD_COOKED,
- XAT_KWD_UNCOOKED,
- XAT_KWD_KEEP,
- XAT_COUNT_KWD
-} xat_attribute_enum_t;
-
-extern xat_attribute_enum_t
-find_xat_attribute_id(char const * str, unsigned int len);
-#endif /* AUTOOPTS_XAT_ATTRIBUTE_H_GUARD */
projects / thirdparty / ntp.git / commitdiff
