sh-utils-1.10/ 40777 74504 1 0 5566761517 12454 5ustar meyeringdaemonsh-utils-1.10/COPYING100666 21570 13 43076 5022247405 12300 0ustar djmuser GNU GENERAL PUBLIC LICENSE Version 2, June 1991 Copyright (C) 1989, 1991 Free Software Foundation, Inc. 675 Mass Ave, Cambridge, MA 02139, USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This General Public License applies to most of the Free Software Foundation's software and to any other program whose authors commit to using it. (Some other Free Software Foundation software is covered by the GNU Library General Public License instead.) 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 this service 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 make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the software, or if you modify it. For example, if you distribute copies of such a program, whether gratis or for a fee, you must give the recipients all the rights that you have. 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. We protect your rights with two steps: (1) copyright the software, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the software. Also, for each author's protection and ours, we want to make certain that everyone understands that there is no warranty for this free software. If the software is modified by someone else and passed on, we want its recipients to know that what they have is not the original, so that any problems introduced by others will not reflect on the original authors' reputations. Finally, any free program is threatened constantly by software patents. We wish to avoid the danger that redistributors of a free program will individually obtain patent licenses, in effect making the program proprietary. To prevent this, we have made it clear that any patent must be licensed for everyone's free use or not licensed at all. The precise terms and conditions for copying, distribution and modification follow. GNU GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. This License applies to any program or other work which contains a notice placed by the copyright holder saying it may be distributed under the terms of this General Public License. The "Program", below, refers to any such program or work, and a "work based on the Program" means either the Program or any derivative work under copyright law: that is to say, a work containing the Program or a portion of it, either verbatim or with modifications and/or translated into another language. (Hereinafter, translation is included without limitation in the term "modification".) Each licensee is addressed as "you". Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running the Program is not restricted, and the output from the Program is covered only if its contents constitute a work based on the Program (independent of having been made by running the Program). Whether that is true depends on what the Program does. 1. You may copy and distribute 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 and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and give any other recipients of the Program a copy of this License along with the Program. You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee. 2. You may modify your copy or copies of the Program or any portion of it, thus forming a work based on the Program, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions: a) You must cause the modified files to carry prominent notices stating that you changed the files and the date of any change. b) You must cause any work that you distribute or publish, that in whole or in part contains or is derived from the Program or any part thereof, to be licensed as a whole at no charge to all third parties under the terms of this License. c) If the modified program normally reads commands interactively when run, you must cause it, when started running for such interactive use in the most ordinary way, to print or display an announcement including an appropriate copyright notice and a notice that there is no warranty (or else, saying that you provide a warranty) and that users may redistribute the program under these conditions, and telling the user how to view a copy of this License. (Exception: if the Program itself is interactive but does not normally print such an announcement, your work based on the Program is not required to print an announcement.) These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Program, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Program, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it. Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Program. In addition, mere aggregation of another work not based on the Program with the Program (or with a work based on the Program) on a volume of a storage or distribution medium does not bring the other work under the scope of this License. 3. You may copy and distribute the Program (or a work based on it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you also do one of the following: a) Accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, b) Accompany it with a written offer, valid for at least three years, to give any third party, for a charge no more than your cost of physically performing source distribution, a complete machine-readable copy of the corresponding source code, to be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, c) Accompany it with the information you received as to the offer to distribute corresponding source code. (This alternative is allowed only for noncommercial distribution and only if you received the program in object code or executable form with such an offer, in accord with Subsection b above.) The source code for a work means the preferred form of the work for making modifications to it. For an executable work, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the executable. However, as a special exception, the source code distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable. If distribution of executable or object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place counts as distribution of the source code, even though third parties are not compelled to copy the source along with the object code. 4. You may not copy, modify, sublicense, or distribute the Program except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense or distribute the Program is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance. 5. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Program or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Program (or any work based on the Program), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Program or works based on it. 6. Each time you redistribute the Program (or any work based on the Program), the recipient automatically receives a license from the original licensor to copy, distribute or modify the Program subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties to this License. 7. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), 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 distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Program at all. For example, if a patent license would not permit royalty-free redistribution of the Program by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Program. If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply and the section as a whole is intended to apply in other circumstances. It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system, which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice. This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License. 8. If the distribution and/or use of the Program is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Program under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License. 9. The Free Software Foundation may publish revised and/or new versions of the 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 a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of this License, you may choose any version ever published by the Free Software Foundation. 10. If you wish to incorporate parts of the Program into other free programs whose distribution conditions are different, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally. NO WARRANTY 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, 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. 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE 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. END OF TERMS AND CONDITIONS Appendix: 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 convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) 19yy 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 2 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, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. Also add information on how to contact you by electronic and paper mail. If the program is interactive, make it output a short notice like this when it starts in an interactive mode: Gnomovision version 69, Copyright (C) 19yy name of author Gnomovision 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, the commands you use may be called something other than `show w' and `show c'; they could even be mouse-clicks or menu items--whatever suits your program. You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the program, if necessary. Here is a sample; alter the names: Yoyodyne, Inc., hereby disclaims all copyright interest in the program `Gnomovision' (which makes passes at compilers) written by James Hacker. , 1 April 1989 Ty Coon, President of Vice This 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 Library General Public License instead of this License. sh-utils-1.10/COPYING.LIB100666 74504 13 61257 5455130113 13755 0ustar meyeringuser GNU LIBRARY GENERAL PUBLIC LICENSE Version 2, June 1991 Copyright (C) 1991 Free Software Foundation, Inc. 675 Mass Ave, Cambridge, MA 02139, USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. [This is the first released version of the library GPL. It is numbered 2 because it goes with version 2 of the ordinary GPL.] Preamble The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public Licenses are intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This license, the Library General Public License, applies to some specially designated Free Software Foundation software, and to any other libraries whose authors decide to use it. You can use it for your libraries, 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 this service 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 make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the library, or if you modify it. For example, if you distribute copies of the library, whether gratis or for a fee, you must give the recipients all the rights that we gave you. You must make sure that they, too, receive or can get the source code. If you link a program with the library, you must provide complete object files to the recipients so that they can relink them with the library, after making changes to the library and recompiling it. And you must show them these terms so they know their rights. Our method of protecting your rights has two steps: (1) copyright the library, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the library. Also, for each distributor's protection, we want to make certain that everyone understands that there is no warranty for this free library. If the library is modified by someone else and passed on, we want its recipients to know that what they have is not the original version, so that any problems introduced by others will not reflect on the original authors' reputations. Finally, any free program is threatened constantly by software patents. We wish to avoid the danger that companies distributing free software will individually obtain patent licenses, thus in effect transforming the program into proprietary software. To prevent this, we have made it clear that any patent must be licensed for everyone's free use or not licensed at all. Most GNU software, including some libraries, is covered by the ordinary GNU General Public License, which was designed for utility programs. This license, the GNU Library General Public License, applies to certain designated libraries. This license is quite different from the ordinary one; be sure to read it in full, and don't assume that anything in it is the same as in the ordinary license. The reason we have a separate public license for some libraries is that they blur the distinction we usually make between modifying or adding to a program and simply using it. Linking a program with a library, without changing the library, is in some sense simply using the library, and is analogous to running a utility program or application program. However, in a textual and legal sense, the linked executable is a combined work, a derivative of the original library, and the ordinary General Public License treats it as such. Because of this blurred distinction, using the ordinary General Public License for libraries did not effectively promote software sharing, because most developers did not use the libraries. We concluded that weaker conditions might promote sharing better. However, unrestricted linking of non-free programs would deprive the users of those programs of all benefit from the free status of the libraries themselves. This Library General Public License is intended to permit developers of non-free programs to use free libraries, while preserving your freedom as a user of such programs to change the free libraries that are incorporated in them. (We have not seen how to achieve this as regards changes in header files, but we have achieved it as regards changes in the actual functions of the Library.) The hope is that this will lead to faster development of free libraries. The precise terms and conditions for copying, distribution and modification follow. Pay close attention to the difference between a "work based on the library" and a "work that uses the library". The former contains code derived from the library, while the latter only works together with the library. Note that it is possible for a library to be covered by the ordinary General Public License rather than by this special one. GNU LIBRARY GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. This License Agreement applies to any software library which contains a notice placed by the copyright holder or other authorized party saying it may be distributed under the terms of this Library General Public License (also called "this License"). Each licensee is addressed as "you". A "library" means a collection of software functions and/or data prepared so as to be conveniently linked with application programs (which use some of those functions and data) to form executables. The "Library", below, refers to any such software library or work which has been distributed under these terms. A "work based on the Library" means either the Library or any derivative work under copyright law: that is to say, a work containing the Library or a portion of it, either verbatim or with modifications and/or translated straightforwardly into another language. (Hereinafter, translation is included without limitation in the term "modification".) "Source code" for a work means the preferred form of the work for making modifications to it. For a library, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the library. Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running a program using the Library is not restricted, and output from such a program is covered only if its contents constitute a work based on the Library (independent of the use of the Library in a tool for writing it). Whether that is true depends on what the Library does and what the program that uses the Library does. 1. You may copy and distribute verbatim copies of the Library's complete source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and distribute a copy of this License along with the Library. You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee. 2. You may modify your copy or copies of the Library or any portion of it, thus forming a work based on the Library, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions: a) The modified work must itself be a software library. b) You must cause the files modified to carry prominent notices stating that you changed the files and the date of any change. c) You must cause the whole of the work to be licensed at no charge to all third parties under the terms of this License. d) If a facility in the modified Library refers to a function or a table of data to be supplied by an application program that uses the facility, other than as an argument passed when the facility is invoked, then you must make a good faith effort to ensure that, in the event an application does not supply such function or table, the facility still operates, and performs whatever part of its purpose remains meaningful. (For example, a function in a library to compute square roots has a purpose that is entirely well-defined independent of the application. Therefore, Subsection 2d requires that any application-supplied function or table used by this function must be optional: if the application does not supply it, the square root function must still compute square roots.) These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Library, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Library, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it. Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Library. In addition, mere aggregation of another work not based on the Library with the Library (or with a work based on the Library) on a volume of a storage or distribution medium does not bring the other work under the scope of this License. 3. You may opt to apply the terms of the ordinary GNU General Public License instead of this License to a given copy of the Library. To do this, you must alter all the notices that refer to this License, so that they refer to the ordinary GNU General Public License, version 2, instead of to this License. (If a newer version than version 2 of the ordinary GNU General Public License has appeared, then you can specify that version instead if you wish.) Do not make any other change in these notices. Once this change is made in a given copy, it is irreversible for that copy, so the ordinary GNU General Public License applies to all subsequent copies and derivative works made from that copy. This option is useful when you wish to copy part of the code of the Library into a program that is not a library. 4. You may copy and distribute the Library (or a portion or derivative of it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange. If distribution of object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place satisfies the requirement to distribute the source code, even though third parties are not compelled to copy the source along with the object code. 5. A program that contains no derivative of any portion of the Library, but is designed to work with the Library by being compiled or linked with it, is called a "work that uses the Library". Such a work, in isolation, is not a derivative work of the Library, and therefore falls outside the scope of this License. However, linking a "work that uses the Library" with the Library creates an executable that is a derivative of the Library (because it contains portions of the Library), rather than a "work that uses the library". The executable is therefore covered by this License. Section 6 states terms for distribution of such executables. When a "work that uses the Library" uses material from a header file that is part of the Library, the object code for the work may be a derivative work of the Library even though the source code is not. Whether this is true is especially significant if the work can be linked without the Library, or if the work is itself a library. The threshold for this to be true is not precisely defined by law. If such an object file uses only numerical parameters, data structure layouts and accessors, and small macros and small inline functions (ten lines or less in length), then the use of the object file is unrestricted, regardless of whether it is legally a derivative work. (Executables containing this object code plus portions of the Library will still fall under Section 6.) Otherwise, if the work is a derivative of the Library, you may distribute the object code for the work under the terms of Section 6. Any executables containing that work also fall under Section 6, whether or not they are linked directly with the Library itself. 6. As an exception to the Sections above, you may also compile or link a "work that uses the Library" with the Library to produce a work containing portions of the Library, and distribute that work under terms of your choice, provided that the terms permit modification of the work for the customer's own use and reverse engineering for debugging such modifications. You must give prominent notice with each copy of the work that the Library is used in it and that the Library and its use are covered by this License. You must supply a copy of this License. If the work during execution displays copyright notices, you must include the copyright notice for the Library among them, as well as a reference directing the user to the copy of this License. Also, you must do one of these things: a) Accompany the work with the complete corresponding machine-readable source code for the Library including whatever changes were used in the work (which must be distributed under Sections 1 and 2 above); and, if the work is an executable linked with the Library, with the complete machine-readable "work that uses the Library", as object code and/or source code, so that the user can modify the Library and then relink to produce a modified executable containing the modified Library. (It is understood that the user who changes the contents of definitions files in the Library will not necessarily be able to recompile the application to use the modified definitions.) b) Accompany the work with a written offer, valid for at least three years, to give the same user the materials specified in Subsection 6a, above, for a charge no more than the cost of performing this distribution. c) If distribution of the work is made by offering access to copy from a designated place, offer equivalent access to copy the above specified materials from the same place. d) Verify that the user has already received a copy of these materials or that you have already sent this user a copy. For an executable, the required form of the "work that uses the Library" must include any data and utility programs needed for reproducing the executable from it. However, as a special exception, the source code distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable. It may happen that this requirement contradicts the license restrictions of other proprietary libraries that do not normally accompany the operating system. Such a contradiction means you cannot use both them and the Library together in an executable that you distribute. 7. 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 not covered by this License, and distribute such a combined library, provided that the separate distribution of the work based on the Library and of the other library facilities is otherwise permitted, and provided that you do these two things: a) Accompany the combined library with a copy of the same work based on the Library, uncombined with any other library facilities. This must be distributed under the terms of the Sections above. b) Give prominent notice with the combined library of the fact that part of it is a work based on the Library, and explaining where to find the accompanying uncombined form of the same work. 8. You may not copy, modify, sublicense, link with, or distribute the Library except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense, link with, or distribute the Library is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance. 9. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Library or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Library (or any work based on the Library), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Library or works based on it. 10. Each time you redistribute the Library (or any work based on the Library), the recipient automatically receives a license from the original licensor to copy, distribute, link with or modify the Library subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties to this License. 11. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), 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 distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Library at all. For example, if a patent license would not permit royalty-free redistribution of the Library by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Library. If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply, and the section as a whole is intended to apply in other circumstances. It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice. This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License. 12. If the distribution and/or use of the Library is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Library under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License. 13. The Free Software Foundation may publish revised and/or new versions of the Library 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 specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Library does not specify a license version number, you may choose any version ever published by the Free Software Foundation. 14. If you wish to incorporate parts of the Library into other free programs whose distribution conditions are incompatible with these, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally. NO WARRANTY 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE LIBRARY "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 LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE LIBRARY 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 LIBRARY (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 LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. END OF TERMS AND CONDITIONS Appendix: How to Apply These Terms to Your New Libraries If you develop a new library, and you want it to be of the greatest possible use to the public, we recommend making it free software that everyone can redistribute and change. You can do so by permitting redistribution under these terms (or, alternatively, under the terms of the ordinary General Public License). To apply these terms, attach the following notices to the library. It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) This library is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This library 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 Library General Public License for more details. You should have received a copy of the GNU Library General Public License along with this library; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. Also add information on how to contact you by electronic and paper mail. You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the library, if necessary. Here is a sample; alter the names: Yoyodyne, Inc., hereby disclaims all copyright interest in the library `Frob' (a library for tweaking knobs) written by James Random Hacker. , 1 April 1990 Ty Coon, President of Vice That's all there is to it! sh-utils-1.10/ChangeLog100644 74504 13 136331 5566761376 14127 0ustar meyeringuserThu May 19 01:10:20 1994 Jim Meyering (meyering@comco.com) * Version 1.10. * lib/Makefile.in (DISTFILES): Add getdate.c and posixtm.c. * src/Makefile.in (users.c): Use cp if hard link fails. From Ian Lance Taylor. * Makefile.in (dist): Change package name from shellutils to sh-utils. That allows a hyphen and 5-character version number without exceeding the 14-character limit on file name length. shellutils-1.10 would have been too long. * version.c: Update package name. * hostname.c: Include before "system.h". From Kaveh Ghazi and Karl Berry. * hostname.c (sethostname) [!HAVE_SETHOSTNAME && HAVE_SYSINFO && HAVE_SYS_SYSTEMINFO_H && HAVE_LIMITS_H]: New function. SVR4 systems prefer sysinfo over sethostname. * configure.in (AC_HAVE_FUNCS): Add sysinfo. (AC_HAVE_HEADERS): Add sys/systeminfo.h. From Kaveh Ghazi. Fri May 13 09:45:23 1994 Jim Meyering (meyering@comco.com) * lib/xgethostname.c (xgethostname): Call xmalloc outside the loop. Correct loop termination condition. * pwd.c: Include before "system.h". From Kaveh Ghazi. * {lib,man,src}/Makefile.in (Makefile): Use ../config.status instead of $(srcdir)/../config.status. The latter didn't work for builddir != srcdir. From Kaveh Ghazi. * Makefile.in (Makefile): Remove dependencies on */Makefile.in. Change the rule so running config.status creates only Makefile. (stamp-config): Have config.status generate only config.h. * {lib,man,src}/Makefile.in (Makefile): Add single dependency on Makefile.in and rule to make config.status create only Makefile. * hostname.c: New program. * hostname.1: New file. * Makefile.in (PROGS): Add hostname. (SOURCES): Add hostname.c * src/Makefile.in: Add rules and dependencies for hostname. * configure.in (AC_HAVE_FUNCS): Add sethostname. * pathchk.c (validate_path) [lint]: Initialize a variable to suppress `used before initialized' warning. * who.c: Correct gethostname prototype to indicate the function returns int, not char. Sun May 01 08:38:18 1994 Jim Meyering (meyering@comco.com) * who.c: Add #ifdefs to build the `users' executable. * src/Makefile.in: Add corresponding rules. * Makefile.in (PROGS): Add users. From Kaveh R. Ghazi . * users.1: Document it. Thu Apr 28 00:45:02 1994 Jim Meyering (meyering@comco.com) * pwd.c: New program. * pwd.1: New file. * Makefile.in (PROGS): Add pwd. * lib/Makefile.in: (DISTFILES): Add pathmax.h. (SOURCES, OBJECTS): Add xgetcwd.c and xgetcwd.o respectively. * src/Makefile.in: Add rules and dependencies for pwd. * yes.c: Don't include version.h. Mon Apr 18 19:54:24 1994 Jim Meyering (meyering@comco.com) * documentation: Change uses of `pathname' and `path' as per GNU standards. * long-options.c (parse-long-options): Take a new argument, command_name, for use in --version output. * basename.c, dirname.c, echo.c, expr.c, printf.c, stty.c, test.c, yes.c (main): Update callers. Wed Mar 30 08:53:21 1994 Jim Meyering (meyering@comco.com) * configure.in: Use AC_SET_MAKE. * Makefile.in: Edit MAKE assignments into @SET_MAKE@. Fri Mar 25 01:13:42 1994 Jim Meyering (meyering@comco.com) * configure.in: Use AC_VERBOSE, AC_CHECKING, and AC_WARN instead of explicit echo commands. When checking for shadow password routines, make sure the function getspnam is available before defining HAVE_SHADOW_H. reported that shadow.h exists on some linux system that did not have the function. Tue Mar 8 10:29:13 1994 Jim Meyering (meyering@comco.com) * configure.in [INSTALL]: When AC_PROG_INSTALL resorts to setting this to `./install.sh', make it `../install.sh' instead since that script will be invoked only from subdirectories. [WINSIZE_IN_PTEM]: Check for this unconditionally, rather than only when TIOCGWINSZ is not defined through termios.h. The old method loses on SCO ODT 3.0 systems. Sat Feb 19 14:23:14 1994 Jim Meyering (meyering@comco.com) * Version 1.9.4. * stty.c (main): Use getopt_long_only with "ag" instead of getopt_long with "". The latter incremented optind so the -a and -g options weren't recognized. * Version 1.9.3. Tue Feb 15 18:28:28 1994 Jim Meyering (meyering@comco.com) * stty.c (main): Use getopt only to recognize long options. Hand code the loop to detect -a, -g, -ag and -ga. Using getopt to detect the short options loses (because we have to ignore unrecognized options and we are allowing GNU getopt to permute) because e.g. `-tabs' is interpreted as a group of options, one of which is `-a'. Before, running `stty -tabs echo' gave this error: stty: when specifying an output style, modes may not be set Reported by Arne H. Juul. Sun Feb 13 13:34:25 1994 Jim Meyering (meyering@comco.com) * basename.1, dirname.1, stty.1: Reflect usage changes. * basename.c, dirname.c, stty.c (usage): Ditto. * long-options.h (parse_long_options): Invoke usage function argument with explicit dereference as per GNU coding standards. * basename.c dirname.c: Use parse_long_options instead of the conventional getopt_long paradigm. Before, the commands `basename file-dist -dist' and `basename -- file.c .c' produced incorrect results. Now, even `basename -file-dist -dist' works and the command `basename -- file.c .c' fails for the right reason: the `--' is not a special (to getopt) token for these commands. It is interpreted as the filename, so there are too many arguments to basename. Rick Sladkey reported the problem with basename. * stty.c (set_window_size): When stty fails to get the window size (as happens on telnet sessions to Solaris systems), initialize all fields of the winsize struct. Before, it was using the uninitialized pixel fields of the struct in the ioctl to set window size parameters. From Rick Sladkey. * stty.c (main): Use parse_long_options to handle --help and --version. (main): In the remaining getopt_long loop, don't jump out of the loop from the `default' branch of the switch statement. Doing that left optind in an inconsistent when there were non-option arguments preceding `reversed' arguments (e.g. stty echo -echoe) and the preceding non-option arguments were ignored. Rick Sladkey reported that stty was ignoring arguments. * stty.c (main): Fail with a diagnostic when both -g and -a are given. (main): Fail with a diagnostic when either -g or -a is used with arguments for setting modes. Fri Feb 11 19:39:37 1994 Jim Meyering (meyering@comco.com) * stty.c (get_win_size): Don't use an ANSI-style function definition. From Kaveh R. Ghazi . Thu Feb 10 01:22:37 1994 Jim Meyering (meyering@comco.com) * stty.c [CSWTCH] (__sparc__ && __svr4__): Define `swtch' to _POSIX_VDISABLE by default. Otherwise, the default settings on SunOS 5.3 (from /usr/include/sys/termios.h) have both `swtch' and `susp' set to ^Z. Those default settings are not unusual. What is unusual is that with such settings on SunOS 5.3, the tty driver doesn't generate a signal for control-Z. Reported by Brent Wiese . * stty.c (main) [CIBAUD]: Don't report an error on SunOS 4.1.x systems if the only difference is in this nybble of c_cflag. See the comments for the gory details. Thanks to Erez "HWank1" Zadok for reporting this and helping me reproduce it. Tue Feb 01 00:59:56 1994 Jim Meyering (meyering@comco.com) * stty.c (main): Call tcsetattr only if we've updated tty modes, not e.g. if we've changed the window size. * Update Copyright dates in src/*. Fri Jan 28 11:02:21 1994 Jim Meyering (meyering@comco.com) * configure.in: Don't set LDFLAGS since linking now uses both LDFLAGS and CFLAGS. Wed Jan 26 10:54:02 1994 Jim Meyering (meyering@comco.com) * stty.c (get_win_size): New function. Try getting size first for the device on stdout. Try stdin only if that fails. Suggested by Andreas Schwab . (set_win_size): Call get_win_size instead of calling ioctl directly. (display_window_size): Ditto. (screen_columns): Ditto. Mon Jan 24 22:57:18 1994 Jim Meyering (meyering@comco.com) * stty.c (set_window_size): Work around SunOS 4.x kernel bug that makes `stty rows 34 cols 80;stty rows 0;stty cols 0' incorrectly set rows to 80 and columns to 0. Sun's stty has this problem, too. The kernel bug is fixed in Solaris 2. Mostly from Alexander Dupuy . * src/Makefile.in: Use both LDFLAGS and CFLAGS when linking. * man/Makefile.in: Use binprefix as the default manprefix. * nohup.sh: Redirect usage message to stderr. From Andreas Schwab . Thu Jan 13 17:27:38 1994 Jim Meyering (meyering@comco.com) * src/Makefile.in: Change all link commands to use both $(CFLAGS) and $(LDFLAGS). Mon Jan 10 01:20:38 1994 Jim Meyering (meyering@comco.com) * man/Makefile.in (manprefix): Use binprefix as the default. Thu Jan 06 18:19:06 1994 Jim Meyering (meyering@comco.com) * who.c (print_entry): Prepend `/dev/' only if ut_line is not already an absolute filename. Just to be safe. Fri Dec 31 00:22:59 1993 Jim Meyering (meyering@comco.com) * date.c (usage): Reorder listing of % formats in `sort -f' order. Tue Dec 28 15:49:32 1993 Jim Meyering (meyering@comco.com) * install.sh: New file. Makefile.in [DISTFILES]: Add it. * who.c (read_utmp): Use stdio functions instead of open/read/close to avoid having to handle POSIX read's -1/errno=EINTR failure case. * tee.c (tee): A POSIX implementation of the read system call may return -1 and set errno to EINTR when it is interrupted. Retry instead of failing with an error. (tee): Don't use xwrite. Use full_write instead and include the losing file name in the message reporting a write failure. Don't treat standard output as a special case, so a failed write to stdout doesn't exit immediately. * date.c (usage): Note that for %w, 0 corresponds to Sunday. Sat Dec 25 23:15:58 1993 Jim Meyering (meyering@comco.com) * who.c (main): Don't chdir ("/dev") for the stat in print_entry. (print_entry): Instead of stat'ing the /dev-relative path, ut_line, stat the absolute path with "/dev/" prefix. From David MacKenzie. Wed Dec 22 00:53:51 1993 Jim Meyering (meyering@comco.com) * expr.c (toarith): Interpret the empty string as just that rather than as the integer zero. Before, `expr "" == 0' output 1. Now it prints 0. * configure.in (AC_HAVE_HEADERS): Check for float.h for strtod.c. * configure.in (check for TIOCGWINSZ): Don't look in sys/ioctl.h or sys/ptem.h if we've already found it in termios.h. This eliminates redefinition warnings from including both termios.h and sys/ioctl.h on sytems running SunOS. From Matthew Seaman (matthew@dyson.ox.ac.uk). * date.1: Document new %s format and old `-' and `_' numeric field modifiers. * memcmp.c: Use the latest version from GNU C library. Mon Dec 20 23:29:30 1993 Jim Meyering (meyering@comco.com) * configure.in [test for 8-bit clean memcmp]: Add a test to detect losing memcmp from SunOS4.1.x. From Robert H. de Vries . Sat Dec 18 01:12:24 1993 Jim Meyering (meyering@comco.com) * configure.in (AC_OUTPUT): Put `touch stamp-config' in second arg so it goes in config.status. This eliminates unnecessary second run of configure. Fri Dec 10 01:06:28 1993 Jim Meyering (meyering@comco.com) * stty.c (screen_columns): Instead of dying just because Solaris' `ioctl (0, TIOCGWINSZ' fails (strangely only for telnet sessions, not rlogin sessions), ignore its errno == EINVAL and try to get the number of columns another way. * stty.c (set_window_size): If ioctl to get window size fails, (as on telnet sessions to Solaris 2.[12] systems) try to set the requested fields anyway, setting to zero any unspecified fields. This is what Sun's /bin/stty appears to do. * (display_window_size): Don't display anything for the number of rows and columns if the ioctl call intended to get them fails. Tue Nov 30 23:58:54 1993 Jim Meyering (meyering@comco.com) * Version 1.9.2. Mon Nov 29 00:28:35 1993 Jim Meyering (meyering@comco.com) * stty.c, configure.in, acconfig.h: Revert change of Nov 26. I am no longer able to reproduce the behavior that prompted that patch -- but I had tested only using an old version of gcc. When building with a more recent version of gcc or with /bin/cc there is no problem. Sat Nov 27 15:11:21 1993 Jim Meyering (meyering@comco.com) * nice.c (main): If an adjustment is specified, but no command is given, give a diagnostic in addition to the usage message. (isinteger): Accept a leading `+'. Fri Nov 26 18:49:42 1993 Jim Meyering (meyering@comco.com) * stty.c [GWINSZ_BROKEN]: Define TIOCGWINSZ to TCGETS for Solaris-2.2. On that system, ioctl (0, TIOCGWINSZ, &win) always fails, but using TCGETS works. Reported by Francois Pinard. * configure.in [GWINSZ_BROKEN]: New test to detect Solaris' inability to get window size from ioctl using TIOCGWINSZ. * acconfig.h [GWINSZ_BROKEN]: Add an #undef. Mon Nov 22 23:40:21 1993 Jim Meyering (meyering@comco.com) * who.c [defined (UTMPX_FILE)]: (undef and) define UTMP_FILE to this value even if UTMP_FILE is already defined. Because some systems define both symbols. From Arne H. Juul. * [MESG_BIT]: Rename to S_IWGRP (from sys/stat.h>) and define only if not already defined. Fri Nov 19 23:08:03 1993 Jim Meyering (meyering@comco.com) * who.c (print_entry): Produce reasonably formatted output even when sizeof (this->ut_name,ut_line) are much larger than 8. For Solaris and other SysVr4. With help from Arne H. Juul. * configure.in (HAVE_UTMPX_H): New test; combined with test for the ut_host field. From Arne H. Juul. * memcmp.c: New file. * lib/Makefile.in [SOURCES]: Add memcmp.c. * configure.in (AC_REPLACE_FUNCS): Add memcmp. Add test for 8-bit clean memcmp. * configure.in (AC_HAVE_FUNCS): Add isascii. * expr.c [!defined (isascii) || defined (STDC_HEADERS)]: This failed on AIX PS/2 1.3 systems because isascii is a function and it is used in definitions (with the necessary side effect of assigning to a global variable) of the is* macros. Also test HAVE_ISASCII and redefine ISASCII(c) instead of isascii. Reported by Minh Tran-Le (tranle@intellicorp.com). * printf.c: Ditto. * configure.in (AC_HAVE_HEADERS): Add sys/timeb.h; getdate.y tests HAVE_SYS_TIMEB_H. * stty.c (main): Detect the case in which POSIX-conformant tcsetattr fails and still returns zero. Wed Nov 17 21:05:10 1993 Jim Meyering (meyering@comco.com) * yes.c (main): Complete my half-finished Nov 2 change. yes with arguments did not print newlines. From Andreas Schwab (ls5.informatik.uni-dortmund.de). * stty.c (wrapf): Fix off-by-one error that could make `stty -a' output lines one character too long. From Andreas Schwab. Sat Nov 13 00:11:19 1993 Jim Meyering (meyering@comco.com) * Version 1.9.1. * configure.in [LIBS]: Add -lbsd if that is necessary to get the syslog function. With help from Kaveh Ghazi. * configure.in [LIBS]: Reorganize/unify the code that adds libraries solely to resolve syslog. Add a library only if it is required to resolve the syslog reference. * configure.in [AC_HAVE_HEADERS]: Check for sys/timeb.h. getdate.y needs to know. [LIBS]: Check for initgroups in -los. This is required by SCO-ODT-3.0 when linking su. [LIBS]: Check -lufc for crypt. Reported by Steven W Orr (steveo@world.std.com). Thu Nov 11 23:55:48 1993 Jim Meyering (meyering@comco.com) * id.c [NGROUPS_MAX]: Undefine before redefining. From Kaveh R. Ghazi (ghazi@noc.rutgers.edu). * who.c (list_entries): Trim any trailing blanks from ut_name and make sure the string is NUL-terminated before printing it. Before, `who -q' displayed 8-character names with a tty (e.g. `q1') suffix. * stty.c [CFLUSHO]: Move this definition so it follows the one for VFLUSHO. Mon Nov 08 23:16:36 1993 Jim Meyering (meyering@comco.com) * Version 1.9. * su.c (correct_password): Report an error and fail if getpass returns NULL. Tue Nov 02 01:14:21 1993 Jim Meyering (meyering@comco.com) * acconfig.h: Add comments. * printenv.c (main): Exit with status == 2 for file error. * yes.c (main): Restore argv/optind handling -- now that parse_long_options doesn't change optind. Mon Oct 25 19:22:58 1993 Jim Meyering (meyering@comco.com) * basename.c, date.c, dirname.c, echo.c, env.c, expr.c, id.c, logname.c, nice.c, pathchk.c, printenv.c, printf.c, sleep.c, stty.c, su.c, tee.c, test.c, tty.c, uname.c, who.c, whoami.c, yes.c: Use the preferred `--longopt=arg' syntax in --help message rather than `--longopt arg'. From Francois Pinard. * stty.c (main, integer_arg): Don't just call error(1,... about improper usage. Call `error (0,...' then usage (1). Sun Oct 24 14:10:23 1993 Jim Meyering (meyering@comco.com) * test.c [member]: Don't try to cast index return value to an int. That can lose on systems with 64-bit pointers. * long-options.c: Save and restore optind, too. * long-options.h: New file. * long-options.c, echo.c, expr.c, printf.c, test.c, yes.c: Include it instead of duplicating dcls. * src/Makefile.in: Add dependencies for it. Tue Oct 19 00:26:27 1993 Jim Meyering (meyering@comco.com) * expr.c [!__STDC__]: Don't define away `const'. configure alone decides whether to do that. From Francois Pinard. Sat Oct 16 22:32:54 1993 Jim Meyering (meyering@comco.com) * whoami.c (main): Cast printf arg UID so it matches the type expected by %u format no matter how uid_t is defined. * stty.c: Accept `status' option and VDISCARD as an alias for VFLUSHO. From Arne H. Juul (arnej@imf.unit.no). * basename.c, date.c, dirname.c, echo.c, env.c, expr.c, false.sh, groups.sh, id.c, logname.c, long-options.c, nice.c, nohup.sh, pathchk.c, printenv.c, printf.c, sleep.c, stty.c, su.c, tee.c, test.c, true.sh, tty.c, uname.c, who.c, whoami.c, yes.c: Using --help gets long well- formatted help. Now --help writes to stdout and exits successfully. From Francois Pinard . Wed Oct 13 13:10:27 1993 Jim Meyering (meyering@comco.com) * long-options.c: Include sys/types before system.h. From Franc,ois Pinard (pinard@iro.umontreal.ca). Tue Oct 12 00:53:26 1993 Jim Meyering (meyering@comco.com) * stime.c [HAVE_CONFIG_H, CONFIG_BROKETS]: Include or "config.h". * src/Makefile.in [clean]: Also delete '['. Sun Oct 10 14:05:23 1993 Jim Meyering meyering@comco.com * false.sh, groups.sh, nohup.sh, true.sh: Add --help and --version. * src/Makefile.in (false, groups, nohup, true): Substitute the string from version.c for @VERSION@ in *.sh. Sat Oct 9 23:12:53 1993 Jim Meyering meyering@comco.com * configure.in: Remove AC_UNISTD_H; add unistd.h to AC_HAVE_HEADERS. Tue Oct 5 22:18:05 1993 Jim Meyering meyering@comco.com * tty.c (main): Detect write error. Use isatty (rather than testing whether ttyname() is NULL) to determine exit status because ttyname may return NULL when stdin is a terminal device. * expr.c (eval7): Rewrite if-else-if-else... sequence to avoid a spurious `function returns without a value' warning. * printenv.c (main), tty.c (main): Detect and report write errors. * echo.c, patchchk.c, printenv.c, printf.c, sleep.c, stty.c, su.c, tee.c, test.c, tty.c, uname.c, yes.c: Accept --help and --version options. * long-options.c: New file. To let echo, expr, printf, test, and yes accept --help and --version as unobtrusively as possible. * src/Makefile.in [SORUCES]: Add it. * configure.in: Add AC_TIME_WITH_SYS_TIME and AC_STAT_MACROS_BROKEN. * nice.c (main) [NICE_PRIORITY]: When given an argument, don't try to get current priority. nice() requires only the delta; we don't need to compute the absolute priority as for setpriority. Mon Oct 04 22:15:07 1993 Jim Meyering (meyering@comco.com) * who.c (print_entry, print_heading, who_am_i): Cast printf field width arguments to int to avoid warnings. (idle_string): Cast idle seconds and minutes to int. Declare functions read_utmp and idle_string to be static. Don't declare ttyname as static. * echo.c (just_echo): Use putchar instead of printf. * expr.c (parse_long_options): New function. (main): Use it to handle --version and --help properly. * tee.c (main): Put entire #ifdef inside if-braces to make structure clearer. (main, tee): Compare close() != 0 rather than close () == -1. * pathchk.c (portable_chars_only, dir_ok): Make a couple variables const. Wed Sep 08 00:07:36 1993 Jim Meyering (meyering@comco.com) * test.c [advance, unary_advance]: Rewrite using do{...}while(0) paradigm instead of comma expressions that make Alpha OSFv1.3 C compiler segfault. * basename.c, date.c, dirname.c, env.c, id.c, logname.c, nice.c: Add --help and --version options. Sat Jul 24 08:52:18 1993 Jim Meyering (meyering@comco.com) * configure.in: Check for -lshadow. Linux needs it when using shadow passwords. Reported by Mattias Olofsson . Thu May 27 20:05:50 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * configure.in (c_line test): Add missing `fi'. Tue May 18 23:49:26 1993 Jim Meyering (meyering@comco.com) * mkinstalldirs: New file. * Makefile.in (installdirs): Use it. Thu May 13 01:03:16 1993 Jim Meyering (meyering@comco.com) * Makefile.in (installdirs): New rules for creating installation directories. (install): depend on it. Mon May 3 22:09:24 1993 Jim Meyering (meyering@comco.com) * configure.in: Add AC_GETGROUPS_T. * id.c, test.c: Don't define GETGROUPS_T. Now configure does it. Sun May 2 00:21:05 1993 Jim Meyering (meyering@comco.com) * expr.c (eval6): Terminate result with a zero byte. The command `expr substr xx 1 2' would fail on systems with tight malloc. From Steve James . * expr.c (null): Recognize the string `0' as zero. (divide, mod): Upon request to divide by zero, give an error message instead of dumping core. From J.T. Conklin . * configure.in: Check for sys/time.h; getdate.y needs it for structs timeval and timezone on some systems. * Check for gettimeofday and for `struct tm'. * Add existence tests for memcpy and bcopy. * configure.in: Find a parser generator. * putenv.c: Include stdlib.h only if __GNU_LIBRARY__ is defined. Many vendor-supplied have a declaration of putenv that conflicts with ours. Tue Apr 20 02:33:24 1993 David J. MacKenzie (djm@kropotkin.gnu.ai.mit.edu) * stty.c: Use GWINSZ_IN_SYS_IOCTL, not _AIX, to determine whether sys/ioctl.h is needed to support `stty size'. Thu Apr 1 18:03:47 1993 Jim Meyering (meyering@comco.com) * printf.c, expr.c [isascii]: Undefine before redefining. Sun Mar 28 00:07:45 1993 Jim Meyering (meyering@comco.com) * stty.c: Accept `flush' option. From Arne H. Juul arnej@lise.unit.no * system.h: Don't define r?index, bcopy... if they're already defined. Thu Mar 25 22:41:01 1993 Jim Meyering (meyering@comco.com) * configure.in: Add AC_IRIX_SUN to get -lsun because Irix-4.0.5's libc.a doesn't have yp/NIS entrypoints. From Kjetil Wiekhorst J|rgensen . Fri Mar 05 00:02:53 1993 Jim Meyering (meyering@comco.com) * date.c: Add long-named options. Sun Dec 6 23:17:09 1992 Jim Meyering (meyering@comco.com) * date.c: Remove unused definition of isdigit. * expr.c (toarith): Change single use of isdigit to ISDIGIT. * printf.c (print_formatted, print_esc): Define ISDIGIT and ISXDIGIT and use them instead of isdigit and isxdigit. Wed Dec 2 12:49:11 1992 Jim Meyering (meyering@comco.com) * env.c, id.c, nice.c, pathchk.c, stty.c, su.c, tee.c, tty.c, uname.c, who.c: Convert static declarations of struct option to use new macros from getopt.h: no_argument, required_argument, and optional_argument. Tue Nov 24 09:46:02 1992 David J. MacKenzie (djm@goldman.gnu.ai.mit.edu) * echo.c: Use V9_DEFAULT instead of USG. Define it always. * system.h: Use HAVE_FCNTL_H and HAVE_STRING_H instead of USG. Wed Nov 11 18:19:10 1992 Jim Meyering (meyering@hal.gnu.ai.mit.edu) * All files in src: Make all functions and extern variables static. Make all longopts arrays const as well as static. Make a couple statically initialized aggregates `const.' * pathchk.c (portable_chars_only): Cast char used as array index. * echo.c (main), su.c (restricted_shell): Add parentheses to assignment statements used in boolean context. * stty.c (set_mode): Parenthesize expressions with bit operations to correctly set/reset modes bits. Wed Oct 28 14:16:48 1992 David J. MacKenzie (djm@goldman.gnu.ai.mit.edu) * Version 1.8. * stty.c: Accept Irix VRPRNT for VREPRINT. From Jim Meyering. * stty.c: Fix some type mismatches. From Bruce Evans, bde@runx.oz.au. * who.c (read_utmp): Close file on error. From Bruce Evans. * su.c, test.c: Add some decls. From Bruce Evans. * sleep.c (main): Arg to sleep is unsigned, not long. From Bruce Evans. Fri Sep 11 00:25:52 1992 David J. MacKenzie (djm@nutrimat.gnu.ai.mit.edu) * echo.c, echo.1: New files. Thu Sep 10 18:42:44 1992 David J. MacKenzie (djm@nutrimat.gnu.ai.mit.edu) * pathchk.c (main): Don't strip trailing slashes from args; they might make a path invalid. (portable_chars_only, dir_ok): New functions. (validate_path): Renamed from validate_new_path. Call them. Don't complain if a leading dir doesn't exist. Don't replace `parent' with a dir that doesn't exist. Don't print a message when falling back from pathconf to constant values. * who.c [!UTMP_FILE]: If _PATH_UTMP is defined, use it instead of /etc/utmp. From Marc Boucher . Tue Aug 25 17:02:25 1992 David J. MacKenzie (djm@nutrimat.gnu.ai.mit.edu) * Version 1.7. * groups.sh, nohup.sh: Add $(bindir) to front of path. Mon Aug 24 16:39:39 1992 David J. MacKenzie (djm@nutrimat.gnu.ai.mit.edu) * stty.c: make sane value for "min" 1, not 0. From haible@ma2s2.mathematik.uni-karlsruhe.de (Bruno Haible). Sun Aug 23 03:02:07 1992 David J. MacKenzie (djm@nutrimat.gnu.ai.mit.edu) * id.c, test.c: Use NGROUPS_MAX if it's defined. 386BSD is like sun. Sat Aug 22 03:16:41 1992 David J. MacKenzie (djm@nutrimat.gnu.ai.mit.edu) * test.c: Rename STANDALONE to TEST_STANDALONE to avoid IBM RT ACIS sys/param.h conflict. * su.c (correct_password) [HAVE_SHADOW_H]: Try to get the encrypted correct password from the shadow password file. Fri Jul 17 15:25:01 1992 David J. MacKenzie (djm@nutrimat.gnu.ai.mit.edu) * su.c, getusershell.c: New files. Fri Jul 3 15:08:43 1992 David J. MacKenzie (djm@nutrimat.gnu.ai.mit.edu) * stty.c, who.c: Change FOO_MISSING to HAVE_FOO. Fri Jun 5 01:49:29 1992 David J. MacKenzie (djm@churchy.gnu.ai.mit.edu) * strcspn.c: New file. * expr.c: Misc. cleanups. * expr.c (eval7): Renamed from eval6. Give syntax error if no more args. Don't coerce all values to numbers. (eval6): New function. (eval5): Accept == as a synonym for =. (eval2): Coerce values to numbers for comparisons. Above all from Dana Jacobsen (jacobsd@prism.cs.orst.edu). Thu Jun 4 19:32:09 1992 David J. MacKenzie (djm@churchy.gnu.ai.mit.edu) * printf.c (print_formatted): Move main loop into new function. (main): Add an outer loop to use the format multiple times. (verify): Don't reject a completely empty string. Check errno (for overflow). * false.sh, true.sh: New programs. Oh, boy. Thu May 14 01:17:22 1992 David J. MacKenzie (djm@churchy.gnu.ai.mit.edu) * stty.c (set_mode): Support crt and dec modes partially if necessary, so they work on, for example, Ultrix . . . . Wed May 13 14:47:45 1992 David J. MacKenzie (djm@churchy.gnu.ai.mit.edu) * stty.c (set_mode): Swap nl and -nl. Have them also affect output as well as input. Tue May 12 00:07:28 1992 David J. MacKenzie (djm@churchy.gnu.ai.mit.edu) * date.c (show_date): Use strftime for the whole conversion. Tue May 5 15:20:24 1992 David J. MacKenzie (djm@hal) * stty.c (wrapf): Print the formatted buffer; don't redo the formatting using vprintf. Thu Apr 30 01:17:08 1992 David J. MacKenzie (djm@churchy.gnu.ai.mit.edu) * printf.c (xstrtol, xstrtoul, xstrtod, verify): New functions. (main, print_direc): Use them. Make error messages more specific. * tee.c (tee): Only malloc and free the table of file descriptors if >0 files are given. Fri Apr 17 11:56:48 1992 David J. MacKenzie (djm@wookumz.gnu.ai.mit.edu) * pathchk.c (validate_new_path): Print the name of the component that failed the length test, not the whole path. From Andreas Schwab (schwab@ls5.informatik.uni-dortmund.de). Mon Apr 6 15:11:36 1992 David J. MacKenzie (djm@wookumz.gnu.ai.mit.edu) * who.c (read_utmp): Check close return for error. (print_heading): Align columns based on sizes of utmp members. (who_am_i): Skip past /dev/ instead of skipping leading path. Mon Mar 16 23:47:03 1992 David J. MacKenzie (djm@apple-gunkies.gnu.ai.mit.edu) * date.c (show_date): Don't call strftime if FORMAT is the empty string. * date.c (main): Reorganize to reduce duplicated code. Add -d option. (usage): Document -d. (set_date): Function removed. Tue Feb 11 16:12:18 1992 David J. MacKenzie (djm at wookumz.gnu.ai.mit.edu) * printf.c (print_esc): When a numeric escape is given, don't call print_esc_char, and return 1 less. From Thorston Ohl. Mon Jan 20 02:17:18 1992 David J. MacKenzie (djm at wookumz.gnu.ai.mit.edu) * Version 1.6. * test.c: HAVE_MULTIPLE_GROUPS -> HAVE_GETGROUPS, for bash 1.11. Fri Jan 17 15:46:18 1992 David J. MacKenzie (djm at wookumz.gnu.ai.mit.edu) * expr.c (docolon): Use re_nsub to find the number of subexpressions . . . From Karl Berry, who knows. Wed Dec 25 23:27:53 1991 David J. MacKenzie (djm at wookumz.gnu.ai.mit.edu) * expr.c (docolon): Use the new way (re_regs.num_regs > 0) to find out if there were any subexpressions, instead of the old way (re_regs.start[1] >= 0), which can cause random memory accesses with regex 0.1. From Brian Matthews. Tue Dec 24 02:12:15 1991 David J. MacKenzie (djm at wookumz.gnu.ai.mit.edu) * system.h, id.c, pathchk.c, tee.c: Change POSIX ifdefs to HAVE_UNISTD_H and _POSIX_VERSION. Wed Dec 11 13:15:09 1991 David J. MacKenzie (djm at wookumz.gnu.ai.mit.edu) * Version 1.5. * expr.c (main): Set obscure_syntax to tell re_match to allocate memory for the group registers. Mon Dec 9 16:03:14 1991 Charles Hannum (mycroft at hal.gnu.ai.mit.edu) * who.c (list_entries): Check type == USER_PROCESS if defined, for SysV. Sat Dec 7 00:32:02 1991 David J. MacKenzie (djm at wookumz.gnu.ai.mit.edu) * Version 1.4. * env, id, nice, pathchk, stty, tee, tty, uname: Change usage messages and documentation to list long-named options starting with `--' rather than `+'. * env.c (main), nice.c (main): Simplify test for which exit status to use if exec fails. Fri Dec 6 23:49:42 1991 David J. MacKenzie (djm at wookumz.gnu.ai.mit.edu) * tee.c (main) [POSIX]: Use sigaction instead of signal, which POSIX doesn't have. Fri Oct 18 00:31:35 1991 David J. MacKenzie (djm at wookumz.gnu.ai.mit.edu) * test.c (two_arguments): Fix from Chet. * expr.c: Include regex.h after sys/types.h, not before, so size_t gets defined. * test.c: New version, adapted from bash 1.10. * id.c: GID_T -> GETGROUPS_T, for clarity. Sat Oct 12 14:38:34 1991 David J. MacKenzie (djm at churchy.gnu.ai.mit.edu) * configure: Define uid_t and gid_t as int if they're not defined in sys/types.h. That's probably right for old Unixes and avoids trying to find the C preprocessor. Sat Sep 28 13:01:23 1991 David J. MacKenzie (djm at churchy.gnu.ai.mit.edu) * stty.c (set_mode): Make `raw' and `cooked' not change parity and character size, which would probably make them useless on 7-bit lines. Make `raw' set the `time' character to 0, not 1. From Bruce Evans. * nohup.sh: If creating nohup.out, give it mode 0600, for POSIX. Fri Sep 13 14:59:51 1991 David J. MacKenzie (djm at churchy.gnu.ai.mit.edu) * id.c [POSIX]: Always use sysconf to get NGROUPS_MAX. Thu Aug 29 14:43:07 1991 David J. MacKenzie (djm at wookumz.gnu.ai.mit.edu) * test.c: Don't include sys/file.h if POSIX. Use gid_t for getgroups. * stty.c (set_mode): Use CEOF and CEOL instead of hardcoding them. (display_speed): Fix a printf string type mismatch. From Bruce Evans. Mon Aug 26 16:52:51 1991 David J. MacKenzie (djm at pogo.gnu.ai.mit.edu) * configure, src/Makefile.in, lib/Makefile.in: Only put $< in Makefiles if VPATH is being used, because older makes don't understand it. Mon Aug 19 01:57:46 1991 David J. MacKenzie (djm at wookumz.gnu.ai.mit.edu) * Version 1.3. Sat Aug 17 22:48:15 1991 David J. MacKenzie (djm at geech.gnu.ai.mit.edu) * src/Makefile.in (install): Install a link to test called '['. Wed Aug 14 12:22:57 1991 David J. MacKenzie (djm at geech.gnu.ai.mit.edu) * test.c (unary_operator): Check first char of string, not its address. Sun Aug 11 18:10:30 1991 David J. MacKenzie (djm at wookumz.gnu.ai.mit.edu) * Version 1.2. * system.h: Define S_IFMT if needed, for test.c. * test.c: New file, from bash. * nice.c: Change +priority to +adjustment (more accurate). Sat Aug 10 13:09:51 1991 David J. MacKenzie (djm at wookumz.gnu.ai.mit.edu) * stty.c [WINSIZE_IN_PTEM]: sys/ptem.h requires sys/stream.h. * nice.c, configure: Use nice if available and setpriority is missing. Thu Aug 8 01:34:05 1991 David J. MacKenzie (djm at wookumz.gnu.ai.mit.edu) * date.c: USG needs TZ=GMT0 for UCT timezone, also. * stty.c: Add pass8 and litout modes. Sun Aug 4 22:45:51 1991 David J. MacKenzie (djm at wheat-chex) * Version 1.1. Fri Aug 2 13:22:31 1991 David J. MacKenzie (djm at apple-gunkies) * configure: Implement +srcdir. Don't check for bison. * stty.c: Don't change ixon in "sane" mode. * configure: Use 1 instead of 255 for checking tzname, because of signedness. Thu Aug 1 13:40:58 1991 David J. MacKenzie (djm at apple-gunkies) * printenv.c (main): Don't print the variable names when given args, as people seem to use printenv in scripts after all . . . . * stty.c: Don't change parity or character size settings in "sane" mode. The right values for those depend on the hardware. Wed Jul 31 01:19:01 1991 David J. MacKenzie (djm at hal) * stty.c [_AIX]: Include sys/ioctl.h -- needed on AIX to get window size. Tue Jul 30 00:06:54 1991 David J. MacKenzie (djm at wookumz.gnu.ai.mit.edu) * getdate.y: New file. * date.c: Add -s option to set date in English. * configure: Check for ftime. * date.c: Remove COMPUTE_TM_ZONE code, which didn't work. * configure: Instead of checking whether tzname is declared, check whether it exists. * logname.c (main): Go back to just printing an error message if getlogin fails, as required by POSIX. * stty.c (screen_columns, wrapf): New functions to implement output wrapping. Globally: use them. * configure: Define uid_t and gid_t if sys/types.h doesn't. * system.h: Define F_OK et al. if nothing else does. Mon Jul 29 21:11:16 1991 David J. MacKenzie (djm at wombat.gnu.ai.mit.edu) * pathchk.c (validate_new_path): Rearrange tests so that pathconf is only called on existing directories. Use access instead of stat to determine directory searchability. From Jim Meyering. * stty.c, configure: Add WINSIZE_IN_PTEM and GWINSZ_BROKEN for SCO. Wed Jul 24 02:13:31 1991 David J. MacKenzie (djm at wookumz.gnu.ai.mit.edu) * stty.c (sane_mode): Always set control chars to sane values. Set min and time if they're different from eof and eol. * whoami.c: Print UID as unsigned. * logname.c: Do "whoami" if getlogin fails. * logname.c (main): fprintf was missing an arg. Tue Jul 23 02:20:15 1991 David J. MacKenzie (djm at wookumz.gnu.ai.mit.edu) * id.c: GID_T is int if ultrix as well as if sun. * stty.c: Implement raw and cooked modes. Mon Jul 22 15:21:21 1991 David J. MacKenzie (djm at wookumz.gnu.ai.mit.edu) * tee.c (main): close stdin and stdout to check for errors. * stty.c: Use tcflag_t for termios bitmasks. Use speed_t for speeds. Use unsigned long for baud rates to accomodate large values, and support 57600 and 115200 if available. * date.c, configure: Instead of SIZE_T_MISSING, define size_t if it's missing. * id.c, whoami.c: Use uid_t and gid_t. * id.c: If POSIX and not sun (bogus!), pass getgroups and getugroups an array of gid_t instead of int. * system.h: New file. * Most programs: include it. Fri Jul 19 12:04:58 1991 David J. MacKenzie (djm at apple-gunkies) * env.c [!STDC_HEADERS]: Declare errno. * printf.c, pathchk.c: Don't include errno.h; not needed. * version.c: New file. * All C programs: Link with it, to get version number in the binary where at least `strings -' and grep can find it. * pathchk.c (strip_trailing_slashes): Function removed; use version in lib. Mon Jul 15 11:34:22 1991 David J. MacKenzie (djm at wookumz.gnu.ai.mit.edu) * Version 1.0. * pathchk.c: Always check whether _POSIX_PATH_MAX and _POSIX_NAME_MAX need to be defined. [POSIX]: If no PATH_MAX or NAME_MAX and pathconf for the path returns -1 (some systems do this if the path does not exist), use pathconf for "/". Sun Jul 14 21:17:22 1991 David J. MacKenzie (djm at geech.gnu.ai.mit.edu) * date.c (date_seconds): Function removed, replaced with posixtm.y in lib. (set_date): Change caller. * configure: Check for bison. * stty.c [!C_LINE_MISSING]: Add support for setting and printing the line discipline. * configure: Check for C_LINE_MISSING. * configure: Check for Minix. Sat Jul 13 01:33:59 1991 David J. MacKenzie (djm at geech.gnu.ai.mit.edu) * Add `man' directory and manual pages. * configure: Set INSTALLDATA and MAN. * id.c: Add #ifdefs for POSIX ways of getting max groups list size. (print_group_list, print_full_info): Allocate list of groups with malloc since its size might not be constant. * nice.c (main): Don't adjust priority if printing it. Default adjustment of 10, not 0. * printf.c: Add \c escape and %b conversion. Implement '*' for field width and precision. Make all errors fatal. (print_esc_string, print_esc): New functions. * configure, date.c: Change SYS_TIME_H to TM_IN_SYS_TIME. * configure: Always check where to find struct tm. * yes.c: Rewrite to accept multiple arguments. * Add groups.sh. Fri Jul 12 10:57:00 1991 David J. MacKenzie (djm at wookumz.gnu.ai.mit.edu) * dirname.c: Move code from dirname function into main, simplifying things quite a bit. From Jim Meyering. * Omit strdup from lib; no longer used. * configure: Don't check for strdup. * printenv.c (main): If args given, print the values in the order given on the command line rather than the order given in the environment. * tee.c, tty.c (struct longopts): Revise to make short-option equivalents clear. Thu Jul 11 12:46:11 1991 David J. MacKenzie (djm at geech.gnu.ai.mit.edu) * nice.c: Add long options. * Add date command and libraries it needs. * configure: Updated. * env.c: Add long options. Use GNU putenv instead of custom setenv function. * id.c: Add long options. * pathchk.c [POSIX]: Use pathconf if necessary to get NAME_MAX and PATH_MAX. * nice.c: Use exit status required for nohup by POSIX.2 (nohup execs nice). * sleep.c: Don't bother with hex and octal. * env.c: Fix exit status for POSIX.2 draft 11.1. * Many files: Remove private copies of xmalloc, error, xstrdup, etc. to use shared versions. Fix #includes for USG, STDC_HEADERS, POSIX. Mon Jul 8 18:56:24 1991 David J. MacKenzie (djm at churchy.gnu.ai.mit.edu) * date.c (main): For -u, set TZ to "" instead of "GMT0", unless on HP-UX or Ultrix. * Rename some feature-test macros. * stime.c: Created from code in date.c. * date.c (compute_tm_zone): New function. (date_seconds, show_date): Use it. (xmalloc, xrealloc): Functions removed; use xmalloc.c instead. Tue Jul 2 02:28:11 1991 David J. MacKenzie (djm at geech.gnu.ai.mit.edu) * tee.c (tee): Report errors in closing files. Mon Mar 18 10:13:59 1991 Jeffrey A. Law (law at geech.ai.mit.edu) * date.c (date_seconds, show_date): #if COMPUTE_TMZONE then compute the proper value to place in tm->tm_zone from information returned by localtime and gettimeofday. Fri Apr 26 11:38:09 1991 David J. MacKenzie (djm at mole.gnu.ai.mit.edu) * stty.c: Define default values for control chars if necessary. Complain about invalid options if no other options follow. Use POSIX functions instead of ioctl, for manipulating termios. * expr.c (main): Exit status was backwards. Thu Dec 20 00:36:01 1990 David J. MacKenzie (djm at apple-gunkies) * id.c: Reorganization and many changes to fix bugs and POSIX compliance problems. Mon Dec 10 03:09:13 1990 David J. MacKenzie (djm at apple-gunkies) * stty.c: Don't declare printf and some other functions that might have variable numbers of args in system header file decls. Tue Nov 14 23:37:22 1990 Roland McGrath (roland at geech.ai.mit.edu) * id.c (print_groups): Put spaces after commas. (print_group): New fn, to print a group id. Uses numeric fmt unless -n, in which case it uses group names. (print_groups): Call it. Find the rgid and egid, and print them as well as the supplementary groups. Make sure we print each group only once. Sun Sep 16 01:49:14 1990 David J. MacKenzie (djm at apple-gunkies) * id.c (main): Add -G option for POSIX.2 draft 10. Allow a username to be given. (print_groups): New function from code in main. (getugroups): New function. Sun Aug 12 00:32:01 1990 David J. MacKenzie (djm at albert.ai.mit.edu) * env.c (main): Instead of setting _POSIX_OPTION_ORDER, tell getopt to not permute, with `+'. Sat Aug 11 01:32:53 1990 David J. MacKenzie (djm at albert.ai.mit.edu) * expr.c: Use regex.c library instead of private regex routines. * nice.c (main): Add -n option for POSIX.2a. (usage): New function. Fri Aug 10 23:58:11 1990 David J. MacKenzie (djm at albert.ai.mit.edu) * who.c: Add -m, -i, -w options for POSIX.2a. Tue Aug 7 00:01:02 1990 David J. MacKenzie (djm at apple-gunkies) * expr.c: Use exit directly instead of longjmp on error. Use argv[0] instead of hardcoded "expr" in messages. Make some functions void. Sat Aug 4 21:19:25 1990 David J. MacKenzie (djm at pogo.ai.mit.edu) * env.c: Change exit statuses for POSIX draft 10. Wed Jul 4 04:32:51 1990 David J. MacKenzie (djm at apple-gunkies) * tee.c: Use error instead of perror_with_name and out_of_memory. Wed Jun 20 02:39:49 1990 David J. MacKenzie (djm at albert.ai.mit.edu) * date.c: Change -DSETTOD to -DSTIME_MISSING, -DSIZE_T to -DSIZE_T_IN_TYPES, and -DSTDC_HDRS to -DSTDC_HEADERS. Declare some more functions. Replace fatal, memory_out, and nonfatal_perror with error. Mon Jun 18 00:16:52 1990 David J. MacKenzie (djm at apple-gunkies) * stty.c: Add some Unix compatibility modes. Sat Jun 16 21:05:59 1990 David J. MacKenzie (djm at apple-gunkies) * stty.c (display_changed, display_all): Print values of min and time. Thu Jun 14 17:49:31 1990 David J. MacKenzie (djm at apple-gunkies) * stty.c: Implement tab, backspace, etc. delay args. Thu May 31 12:25:40 1990 David J. MacKenzie (djm at albert.ai.mit.edu) * nohup.sh: Don't ignore SIGTERM. If ./nohup.out is unwritable, try $HOME/nohup.out. Thu May 3 22:33:32 1990 David J. MacKenzie (djm at albert.ai.mit.edu) * who.c: Use error instead of fatal and fatal_perror. (print_headings): Print headings in all caps, like SYSV does. (list_entries): New function for -q to make it like SYSV -q. (valid_entries): Function removed. Mon Apr 2 01:27:23 1990 David J. MacKenzie (djm at albert.ai.mit.edu) * id.c (main): Don't strip off leading path from program name. Revise a couple of error messages. * whoami.c (main): Use geteuid, not getuid, for Unix compatibility. Tue Mar 20 14:28:25 1990 David J. MacKenzie (djm at pogo.ai.mit.edu) * tee.c (main): Pass list of files and its size as args to tee rather than as global vars. Exit with return value of tee instead of always 0. (tee): Use unbuffered I/O instead of stdio, for POSIX. Return an error status. (xwrite): New function. Tue Mar 13 00:38:13 1990 David J. MacKenzie (djm at albert.ai.mit.edu) * who.c (who_am_i): Print heading before checking to see whether there is an entry for the tty on stdin, for consistency with the who function. (main): Use argv[optind], not argv[1], as alternate file. Fri Mar 9 15:49:04 1990 David J. MacKenzie (djm at albert.ai.mit.edu) * who.c: Rename UTMP to UTMP_FILE for compatibility with SysV utmp.h. Include some additional header files. (main): Recognize some options from SysVr3 who. Call usage. Set new global var `program_name' from argv[0]. (usage): New function. (who): If -q given, only print count of users logged on. (print_entry): New function to format an entry on the output; make format more like that of the Unix who programs. (print_heading): New function to print a line describing each output field. (who, who_am_i): Call print_entry and print_heading. (valid_entries): New function to return count of nonempty entries in utmp. (search_entries): Compare with utmp tty field instead of username field. Don't assume null termination in utmp field. (who_am_i): Print the entry for the tty on stdin rather than the first entry found for the uid. If hostname is not available, use a null one instead of "". Don't hardcode max hostname length. (idle_string): New function to format idle time field. (fatal, fatal_perror): Use program_name instead of hardcoded "who" in error messages. Tue Mar 6 00:59:03 1990 David J. MacKenzie (djm at albert.ai.mit.edu) * printenv.c (main): Allow multiple variables to be specified. (barf): Function removed. Sat Jan 20 18:41:48 1990 Jim Kingdon (kingdon at geech) * expr.c (nextarg): Do not pass *args to strcmp if NULL. Mon Dec 18 09:57:20 1989 David J. MacKenzie (djm at hobbes.ai.mit.edu) * printenv.c (main): Simplify error messages. Sat Dec 16 15:15:50 1989 David J. MacKenzie (djm at hobbes.ai.mit.edu) * expr.c: Indent to regularize spacing. (cmpv, arithf): Change '#define foo (args)' to '#define foo(args)' so they compile. (docolon): Remove unused vars. (multiply): Rename from times to avoid libc conflict. (error): Include program name in message. (xmalloc): Rename from Malloc. (re_compiled): Rename from re_comp to avoid libc conflict. * basename.c: Fix some weird indentation. (main): Print a clearer usage message. Use a simpler method for removing suffix, if given. (fatal): Function no longer used; removed. * sleep.c: (main): Rename `time' to `seconds'. Print usage message if given no args. Exit with status 0 instead of falling off end. (error): Print to stderr, not stdout. * tee.c: (main): Use getopt_long instead of custom parser, and adjust usage message. Use list of filenames in argv rather than making a copy. (tee): New function created from the second half of main. Fix bug where it tried to fclose a loop index instead of a stream. (xmalloc): Ok to return 0 if 0 bytes requested. (xrealloc): Unused function removed. * whoami.c: Canonicalize usage message and fix error message. * who.c: Declare some functions. (fatal_perror): New function for printing errors after system calls. Global: Use it when appropriate. (xmalloc): Return char *, not int. (read_utmp): Ok if utmp file is empty. Include filename in error messages. (scan_entries): Adjust columns to line up better, particularly when there are users with 8 character long usernames logged in. Sat Oct 28 13:20:43 1989 David J. MacKenzie (djm at spiff) * uname.c: Added long options. global: changed the word `part' to the word `element' (more precise). (program_name, long_options): New variables. (main): Support long options. (usage): Add long options summary to message. Local Variables: mode: indented-text left-margin: 8 version-control: never End: sh-utils-1.10/Makefile.in100666 74504 1 7250 5566761436 14622 0ustar meyeringdaemon# Master Makefile for the GNU shell programming utilities. # Copyright (C) 1991, 1992, 1993 Free Software Foundation, Inc. # 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 2, 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, write to the Free Software # Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. # This directory's subdirectories are mostly independent; you can cd # into them and run `make' without going through this Makefile. # To change the values of `make' variables: instead of editing Makefiles, # (1) if the variable is set in `config.status', edit `config.status' # (which will cause the Makefiles to be regenerated when you run `make'); # (2) otherwise, pass the desired values on the `make' command line. srcdir = @srcdir@ VPATH = @srcdir@ @SET_MAKE@ prefix = /usr/local exec_prefix = $(prefix) bindir = $(exec_prefix)/bin libdir = $(exec_prefix)/lib datadir = $(prefix)/lib mandir = $(prefix)/man/man1 SHELL = /bin/sh DISTFILES = COPYING COPYING.LIB ChangeLog Makefile.in README INSTALL \ NEWS configure configure.in config.h.in acconfig.h mkinstalldirs install.sh # Redundant stuff for making only selected programs. PROGS = basename date dirname echo env expr false groups hostname id logname \ pathchk printenv printf pwd sleep tee test true tty users who whoami \ yes @PROGS@ # Subdirectories to run make in for the primary targets. SUBDIRS = lib src man all: for dir in $(SUBDIRS); do \ echo making $@ in $$dir ; \ (cd $$dir; $(MAKE) $@) ; \ done info: install-info: dvi: check: installcheck: $(PROGS) su: cd lib; $(MAKE) all cd src; $(MAKE) $@ config.h: stamp-config ; stamp-config: config.status $(srcdir)/config.h.in CONFIG_FILES= CONFIG_HEADERS=config.h ./config.status touch stamp-config Makefile: config.status Makefile.in CONFIG_FILES=$@ CONFIG_HEADERS= ./config.status config.status: configure $(SHELL) config.status --recheck #configure: configure.in ## Comment-me-out in distribution # cd $(srcdir); autoconf ## Comment-me-out in distribution #config.h.in: configure.in ## Comment-me-out in distribution # cd $(srcdir); autoheader ## Comment-me-out in distribution # Make sure all installation directories, e.g. $(bindir) actually exist by # making them if necessary. installdirs: $(SHELL) $(srcdir)/mkinstalldirs \ $(bindir) $(datadir) $(libdir) $(infodir) $(mandir) install:: installdirs install uninstall TAGS clean mostlyclean distclean realclean:: for dir in $(SUBDIRS); do \ echo making $@ in $$dir ; \ (cd $$dir; $(MAKE) $@) ; \ done distclean realclean:: rm -f Makefile config.status config.h stamp-config dist: $(DISTFILES) echo sh-utils-`sed -e '/version_string/!d' \ -e 's/[^0-9.]*\([0-9.a-z]*\).*/\1/' -e q src/version.c` > .fname rm -rf `cat .fname` mkdir `cat .fname` ln $(DISTFILES) `cat .fname` rm -f `cat .fname`/Makefile.in sed 's/^.*#$(empty)# Comment.*/#&/' Makefile.in \ > `cat .fname`/Makefile.in for dir in $(SUBDIRS); do \ mkdir `cat .fname`/$$dir; \ (cd $$dir; $(MAKE) $@); \ done tar --gzip -chvf `cat .fname`.tar.gz `cat .fname` rm -rf `cat .fname` .fname # Tell versions [3.59,3.63) of GNU make not to export all variables. # Otherwise a system limit (for SysV at least) may be exceeded. .NOEXPORT: sh-utils-1.10/README100666 74504 1 3116 5531472277 13424 0ustar meyeringdaemonThis is a package of small shell programming utilities. They are mostly compliant with POSIX.2, where applicable. The programs that can be built with this package are: basename date dirname echo env expr false groups id logname nice nohup pathchk printenv printf sleep stty tee test true tty uname who whoami yes Some programs (uname, nice, nohup, and stty) are built and installed only on systems that have the features to support them. See the file NEWS for a list of major changes in the current release. See the file INSTALL for compilation and installation instructions. If you are using a version of the Linux libc that predates 4.4.1, you should get a newer version. The old libraries contain getopt functions that are incompatible with certain uses of the date program. For instance, when built with the obsolete getopt functions, `date +%j' will give a usage error instead of the expected result. nice, stty, and uname require facilities not available on all systems; `configure' detects this and does not try to compile them on systems where those facilities are missing. nohup requires nice. su will be installed only if you do `make install' as root. Many thanks to all the people who have taken the time to submit problem reports and fixes. Contributed changes are attributed in the ChangeLog file. These programs all recognize the `--version' option. When reporting bugs, please include in the subject line both the package name/version and the name of the program for which you found a problem. Mail suggestions and bug reports for these programs to bug-gnu-utils@prep.ai.mit.edu. sh-utils-1.10/INSTALL100444 21570 1 13655 5554637713 12551 0ustar djmdaemon This is a generic INSTALL file for utilities distributions. If this package does not come with, e.g., installable documentation or data files, please ignore the references to them below. The `configure' shell script attempts to guess correct values for various system-dependent variables used during compilation, and creates the Makefile(s) (one in each subdirectory of the source directory). In some packages it creates a C header file containing system-dependent definitions. It also creates a file `config.status' that you can run in the future to recreate the current configuration. To compile this package: 1. Configure the package for your system. Normally, you just `cd' to the directory containing the package's source code and type `./configure'. If you're using `csh' on an old version of System V, you might need to type `sh configure' instead to prevent `csh' from trying to execute `configure' itself. Running `configure' takes awhile. While it is running, it prints some messages that tell what it is doing. If you don't want to see any messages, run `configure' with its standard output redirected to `/dev/null'; for example, `./configure >/dev/null'. To compile the package in a different directory from the one containing the source code, you must use a version of `make' that supports the `VPATH' variable, such as GNU `make'. `cd' to the directory where you want the object files and executables to go and run the `configure' script. `configure' automatically checks for the source code in the directory that `configure' is in and in `..'. If for some reason `configure' is not in the source code directory that you are configuring, then it will report that it can't find the source code. In that case, run `configure' with the option `--srcdir=DIR', where DIR is the directory that contains the source code. By default, `make install' will install the package's files in `/usr/local/bin', `/usr/local/man', etc. You can specify an installation prefix other than `/usr/local' by giving `configure' the option `--prefix=PATH'. Alternately, you can do so by consistently giving a value for the `prefix' variable when you run `make', e.g., make prefix=/usr/gnu make prefix=/usr/gnu install You can specify separate installation prefixes for architecture-specific files and architecture-independent files. If you give `configure' the option `--exec-prefix=PATH' or set the `make' variable `exec_prefix' to PATH, the package will use PATH as the prefix for installing programs and libraries. Data files and documentation will still use the regular prefix. Normally, all files are installed using the same prefix. Some packages pay attention to `--with-PACKAGE' options to `configure', where PACKAGE is something like `gnu-as' or `x' (for the X Window System). They may also pay attention to `--enable-FEATURE' options, where FEATURE indicates an optional part of the package. The README should mention any `--with-' and `--enable-' options that the package recognizes. `configure' also recognizes the following options: `--help' Print a summary of the options to `configure', and exit. `--quiet' `--silent' Do not print messages saying which checks are being made. `--verbose' Print the results of the checks. `--version' Print the version of Autoconf used to generate the `configure' script, and exit. `--x-includes=DIR' X include files are in DIR. `--x-libraries=DIR' X library files are in DIR. `configure' also accepts and ignores some other options. On systems that require unusual options for compilation or linking that the package's `configure' script does not know about, you can give `configure' initial values for variables by setting them in the environment. In Bourne-compatible shells, you can do that on the command line like this: CC='gcc -traditional' LIBS=-lposix ./configure On systems that have the `env' program, you can do it like this: env CC='gcc -traditional' LIBS=-lposix ./configure Here are the `make' variables that you might want to override with environment variables when running `configure'. For these variables, any value given in the environment overrides the value that `configure' would choose: - Variable: CC C compiler program. The default is `cc'. - Variable: INSTALL Program to use to install files. The default is `install' if you have it, `cp' otherwise. For these variables, any value given in the environment is added to the value that `configure' chooses: - Variable: DEFS Configuration options, in the form `-Dfoo -Dbar...'. Do not use this variable in packages that create a configuration header file. - Variable: LIBS Libraries to link with, in the form `-lfoo -lbar...'. If you need to do unusual things to compile the package, we encourage you to figure out how `configure' could check whether to do them, and mail diffs or instructions to the address given in the README so we can include them in the next release. 2. Type `make' to compile the package. If you want, you can override the `make' variables CFLAGS and LDFLAGS like this: make CFLAGS=-O2 LDFLAGS=-s 3. If the package comes with self-tests and you want to run them, type `make check'. If you're not sure whether there are any, try it; if `make' responds with something like make: *** No way to make target `check'. Stop. then the package does not come with self-tests. 4. Type `make install' to install programs, data files, and documentation. 5. You can remove the program binaries and object files from the source directory by typing `make clean'. To also remove the Makefile(s), the header file containing system-dependent definitions (if the package uses one), and `config.status' (all the files that `configure' created), type `make distclean'. The file `configure.in' is used to create `configure' by a program called `autoconf'. You only need it if you want to regenerate `configure' using a newer version of `autoconf'. sh-utils-1.10/NEWS100666 74504 1 7035 5566752004 13244 0ustar meyeringdaemonUser visible changes in release 1.10 * change package name from shellutils to sh-utils * add hostname, pwd, and users commands * --version outputs the name of the utility as well as the package name and version number. * Configure properly determines options for stty on SCO ODT 3.0 systems. * `date -d' works better. Before, `date -d '4apr94'' produced `Sun Apr 3 23:00:00 CDT 1994'. User visible changes in release 1.9.4 * Repair stty option handling. User visible changes in release 1.9.3 * `stty -a -g' gets a diagnostic * `stty {-a|-g} any-other-argument' gets a diagnostic * stty no longer ignores some of its arguments * basename and dirname no longer treat `--' specially * `basename -- file.c .c' generates a usage error. Before, it output `file'. * `basename file-dist -dist' outputs `file'. Before it output `file-dist'. * stty defaults `swtch' to undefined for Solaris so `susp' (^Z) will work. Before, with the default settings ^Z did nothing. * stty no longer gives an error message when it finds a spurious difference (due to buggy tcgetattr/tcsetattr) between requested and current tty modes under SunOS 4.1.x. * stty no longer fails if the ioctl to determine the display width fails when displaying settings. * stty works around SunOS 4.x kernel bug that made `stty rows 0 cols 0' fail. * who and tee no longer fail gratuitously when continued after an interrupted read or write system call. * date accepts new format: %s time in seconds since 1970-01-01 00:00:00 UCT * date -d can parse dates like `11-JUL-1991' * expr '' == 0 works (before, it printed 1) * stty no longer fails on telnet sessions to Solaris systems * `cd /etc; who utmp' now works. Before, any filename argument had to be absolute or relative to /dev. User visible changes in release 1.9.2: * who output is better formatted on Solaris and other SysVr4 systems * fix a minor problem in formatting the output from `stty -a' * yes with arguments outputs newlines again * partial stty failures are reported Major changes in release 1.9.1: * stty can be built on Suns again * minor fix for who -q Major changes in release 1.9: * su fails gracefully when getpass is unable to open /dev/tty. * printenv and tty detect and report write errors * fix bug in stty * stty accepts the new options status and flush on systems that provide them * `expr 1 / 0' gives an error message rather than trying to divide by zero * expr's `substr' doesn't overrun malloc'd buffer * expr recognizes the string `0' as zero * better support for Linux, Dec Alpha, and SGI Irix * all programs (even true and false) accept --version and --help options * uname's --version option is no longer equivalent to its -v option * configure uses config.h, so DEFS won't exceed preprocessor limits of some compilers on the number of symbols defined via -D. * work around problem where $(srcdir)/config.h was used instead of ../config.h -- this happened only when building in a subdirectory and when config.h remained in $(srcdir) from a previous ./configure. * make may be run from the subdirectories Major changes in release 1.8: * add echo command * fix some incorrect warnings in pathchk * look at the right utmp file on 386BSD * date doesn't dump core on some systems now Major changes in release 1.7: * add su, who, true, false commands * add more tests to expr * fix printf program handling of \ escapes * printf can re-use format string for multiple groups of arguments * printf catches numeric conversion errors with an ANSI C library * stty nl and -nl were backwards * date can format an arbitrary date without setting it sh-utils-1.10/configure100777 74504 13 210675 5566752330 14262 0ustar meyeringuser#!/bin/sh # Guess values for system-dependent variables and create Makefiles. # Generated automatically using autoconf version 1.11 # Copyright (C) 1991, 1992, 1993, 1994 Free Software Foundation, Inc. # This configure script 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 2, or (at your option) # any later version. # This script 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, write to the Free Software # Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. # Save the original args to write them into config.status later. configure_args="$*" # Only options that might do something get documented. ac_usage="Usage: configure [options] [host] Options: [defaults in brackets after descriptions] --build=BUILD configure for building on BUILD [BUILD=HOST] --disable-FEATURE do not include FEATURE (same as --enable-FEATURE=no) --enable-FEATURE[=ARG] include FEATURE [ARG=yes] --exec-prefix=PREFIX install host dependent files in PREFIX [/usr/local] --help print this message --host=HOST configure for HOST [guessed] --prefix=PREFIX install host independent files in PREFIX [/usr/local] --quiet, --silent do not print \`checking for...' messages --srcdir=DIR find the sources in DIR [configure dir or ..] --target=TARGET configure for TARGET [TARGET=HOST] --verbose print results of checks --version print the version of autoconf that created configure --with-PACKAGE[=ARG] use PACKAGE [ARG=yes] --without-PACKAGE do not use PACKAGE (same as --with-PACKAGE=no) --x-includes=DIR X include files are in DIR --x-libraries=DIR X library files are in DIR" # Initialize some variables set by options. # The variables have the same names as the options, with # dashes changed to underlines. build=NONE exec_prefix= host=NONE no_create= nonopt=NONE norecursion= prefix= program_prefix= program_suffix= program_transform_name= silent= srcdir= target=NONE verbose= x_includes= x_libraries= ac_prev= for ac_option do # If the previous option needs an argument, assign it. if test -n "$ac_prev"; then eval "$ac_prev=\$ac_option" ac_prev= continue fi # Accept (but ignore some of) the important Cygnus configure # options, so we can diagnose typos. case "$ac_option" in -*=*) ac_optarg=`echo "$ac_option" | sed 's/[-_a-zA-Z0-9]*=//'` ;; *) ac_optarg= ;; esac case "$ac_option" in -build | --build | --buil | --bui | --bu | --b) ac_prev=build ;; -build=* | --build=* | --buil=* | --bui=* | --bu=* | --b=*) build="$ac_optarg" ;; -disable-* | --disable-*) ac_feature=`echo $ac_option|sed -e 's/-*disable-//'` # Reject names that aren't valid shell variable names. if test -n "`echo $ac_feature| sed 's/[-a-zA-Z0-9_]//g'`"; then echo "configure: $ac_feature: invalid feature name" >&2; exit 1 fi ac_feature=`echo $ac_feature| sed 's/-/_/g'` eval "enable_${ac_feature}=no" ;; -enable-* | --enable-*) ac_feature=`echo $ac_option|sed -e 's/-*enable-//' -e 's/=.*//'` # Reject names that aren't valid shell variable names. if test -n "`echo $ac_feature| sed 's/[-_a-zA-Z0-9]//g'`"; then echo "configure: $ac_feature: invalid feature name" >&2; exit 1 fi ac_feature=`echo $ac_feature| sed 's/-/_/g'` case "$ac_option" in *=*) ;; *) ac_optarg=yes ;; esac eval "enable_${ac_feature}='$ac_optarg'" ;; # For backward compatibility, recognize -exec-prefix and --exec_prefix. -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \ | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \ | --exec | --exe | --ex) ac_prev=exec_prefix ;; -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \ | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \ | --exec=* | --exe=* | --ex=*) exec_prefix="$ac_optarg" ;; -gas | --gas | --ga | --g) with_gas=yes ;; # Obsolete; use --with-gas. -help | --help | --hel | --he) cat << EOF $ac_usage EOF exit 0 ;; -host | --host | --hos | --ho) ac_prev=host ;; -host=* | --host=* | --hos=* | --ho=*) host="$ac_optarg" ;; -nfp | --nfp | --nf) with_fp=no ;; # Obsolete; use --without-fp. -no-create | --no-create | --no-creat | --no-crea | --no-cre \ | --no-cr | --no-c) no_create=yes ;; -norecursion | --norecursion | --norecursio | --norecursi \ | --norecurs | --norecur | --norecu | --norec | --nore | --nor) norecursion=yes ;; -prefix | --prefix | --prefi | --pref | --pre | --pr | --p) ac_prev=prefix ;; -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*) prefix="$ac_optarg" ;; -program-prefix | --program-prefix | --program-prefi | --program-pref \ | --program-pre | --program-pr | --program-p) ac_prev=program_prefix ;; -program-prefix=* | --program-prefix=* | --program-prefi=* \ | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*) program_prefix="$ac_optarg" ;; -program-suffix | --program-suffix | --program-suffi | --program-suff \ | --program-suf | --program-su | --program-s) ac_prev=program_suffix ;; -program-suffix=* | --program-suffix=* | --program-suffi=* \ | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*) program_suffix="$ac_optarg" ;; -program-transform-name | --program-transform-name \ | --program-transform-nam | --program-transform-na \ | --program-transform-n | --program-transform- \ | --program-transform | --program-transfor \ | --program-transfo | --program-transf \ | --program-trans | --program-tran \ | --progr-tra | --program-tr | --program-t) ac_prev=program_transform_name ;; -program-transform-name=* | --program-transform-name=* \ | --program-transform-nam=* | --program-transform-na=* \ | --program-transform-n=* | --program-transform-=* \ | --program-transform=* | --program-transfor=* \ | --program-transfo=* | --program-transf=* \ | --program-trans=* | --program-tran=* \ | --progr-tra=* | --program-tr=* | --program-t=*) program_transform_name="$ac_optarg" ;; -q | -quiet | --quiet | --quie | --qui | --qu | --q \ | -silent | --silent | --silen | --sile | --sil) silent=yes ;; -srcdir | --srcdir | --srcdi | --srcd | --src | --sr) ac_prev=srcdir ;; -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*) srcdir="$ac_optarg" ;; -target | --target | --targe | --targ | --tar | --ta | --t) ac_prev=target ;; -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*) target="$ac_optarg" ;; -v | -verbose | --verbose | --verbos | --verbo | --verb) verbose=yes ;; -version | --version | --versio | --versi | --vers) echo "configure generated by autoconf version 1.11" exit 0 ;; -with-* | --with-*) ac_package=`echo $ac_option|sed -e 's/-*with-//' -e 's/=.*//'` # Reject names that aren't valid shell variable names. if test -n "`echo $ac_package| sed 's/[-_a-zA-Z0-9]//g'`"; then echo "configure: $ac_package: invalid package name" >&2; exit 1 fi ac_package=`echo $ac_package| sed 's/-/_/g'` case "$ac_option" in *=*) ;; *) ac_optarg=yes ;; esac eval "with_${ac_package}='$ac_optarg'" ;; -without-* | --without-*) ac_package=`echo $ac_option|sed -e 's/-*without-//'` # Reject names that aren't valid shell variable names. if test -n "`echo $ac_package| sed 's/[-a-zA-Z0-9_]//g'`"; then echo "configure: $ac_package: invalid package name" >&2; exit 1 fi ac_package=`echo $ac_package| sed 's/-/_/g'` eval "with_${ac_package}=no" ;; --x) with_x=yes ;; # Obsolete; use --with-x. -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \ | --x-incl | --x-inc | --x-in | --x-i) ac_prev=x_includes ;; -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \ | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*) x_includes="$ac_optarg" ;; -x-libraries | --x-libraries | --x-librarie | --x-librari \ | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l) ac_prev=x_libraries ;; -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \ | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*) x_libraries="$ac_optarg" ;; -*) echo "configure: $ac_option: invalid option; use --help to show usage" >&2; exit 1 ;; *) if test -n "`echo $ac_option| sed 's/[-a-z0-9.]//g'`"; then echo "configure: warning: $ac_option: invalid host type" >&2 fi if test "x$nonopt" != xNONE; then echo "configure: can only configure for one host and one target at a time" >&2; exit 1 fi nonopt="$ac_option" ;; esac done if test -n "$ac_prev"; then echo "configure: missing argument to --`echo $ac_prev | sed 's/_/-/g'`" >&2; exit 1 fi trap 'rm -fr conftest* confdefs* core $ac_clean_files; exit 1' 1 2 15 trap 'rm -fr confdefs* $ac_clean_files' 0 # Save the original args if we used an alternate arg parser. ac_configure_temp="${configure_args-$*}" # Strip out --no-create and --norecursion so they don't pile up. configure_args= for ac_arg in $ac_configure_temp; do case "$ac_arg" in -no-create | --no-create | --no-creat | --no-crea | --no-cre \ | --no-cr | --no-c) ;; -norecursion | --norecursion | --norecursio | --norecursi \ | --norecurs | --norecur | --norecu | --norec | --nore | --nor) ;; *) configure_args="$configure_args $ac_arg" ;; esac done # NLS nuisances. # These must not be set unconditionally because not all systems understand # e.g. LANG=C (notably SCO). if test "${LC_ALL+set}" = 'set'; then LC_ALL=C; export LC_ALL; fi if test "${LANG+set}" = 'set'; then LANG=C; export LANG; fi # confdefs.h avoids OS command line length limits that DEFS can exceed. rm -rf conftest* confdefs.h # AIX cpp loses on an empty file, so make sure it contains at least a newline. echo > confdefs.h # A filename unique to this package, relative to the directory that # configure is in, which we can look for to find out if srcdir is correct. ac_unique_file=src/stty.c # Find the source files, if location was not specified. if test -z "$srcdir"; then ac_srcdir_defaulted=yes # Try the directory containing this script, then `..'. ac_prog=$0 ac_confdir=`echo $ac_prog|sed 's%/[^/][^/]*$%%'` test "x$ac_confdir" = "x$ac_prog" && ac_confdir=. srcdir=$ac_confdir if test ! -r $srcdir/$ac_unique_file; then srcdir=.. fi fi if test ! -r $srcdir/$ac_unique_file; then if test x$ac_srcdir_defaulted = xyes; then echo "configure: can not find sources in ${ac_confdir} or .." >&2; exit 1 else echo "configure: can not find sources in ${srcdir}" >&2; exit 1 fi fi ac_ext=c # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options. ac_cpp='${CPP}' ac_compile='${CC-cc} $CFLAGS $LDFLAGS conftest.${ac_ext} -o conftest $LIBS >/dev/null 2>&1' cat > conftestmake <<'EOF' all: @echo 'ac_maketemp="${MAKE}"' EOF # GNU make sometimes prints "make[1]: Entering...", which would confuse us. eval `${MAKE-make} -f conftestmake 2>/dev/null | grep temp=` if test -n "$ac_maketemp"; then SET_MAKE= else SET_MAKE="MAKE=${MAKE-make}"; fi rm -f conftestmake # We want these before the checks, so the checks can modify their values. test -z "$CFLAGS" && CFLAGS=-g auto_cflags=1 if test -z "$CC"; then # Extract the first word of `gcc', so it can be a program name with args. set ac_dummy gcc; ac_word=$2 test -n "$silent" || echo "checking for $ac_word" IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}:" for ac_dir in $PATH; do test -z "$ac_dir" && ac_dir=. if test -f $ac_dir/$ac_word; then CC="gcc" break fi done IFS="$ac_save_ifs" fi test -z "$CC" && CC="cc" test -n "$CC" && test -n "$verbose" && echo " setting CC to $CC" # Find out if we are using GNU C, under whatever name. cat > conftest.c < conftest.out 2>&1 if egrep yes conftest.out >/dev/null 2>&1; then GCC=1 # For later tests. fi rm -f conftest* # If we're using gcc and the user hasn't specified CFLAGS, add -O to CFLAGS. test -n "$GCC" && test -n "$auto_cflags" && CFLAGS="$CFLAGS -O" test -n "$silent" || echo "checking how to run the C preprocessor" if test -z "$CPP"; then # This must be in double quotes, not single quotes, because CPP may get # substituted into the Makefile and ``${CC-cc}'' will simply confuse # make. It must be expanded now. CPP="${CC-cc} -E" cat > conftest.${ac_ext} < Syntax Error EOF # Some shells (Coherent) do redirections in the wrong order, so need # the parens. ac_err=`eval "($ac_cpp conftest.${ac_ext} >/dev/null) 2>&1"` if test -z "$ac_err"; then : else rm -rf conftest* CPP="${CC-cc} -E -traditional-cpp" cat > conftest.${ac_ext} < Syntax Error EOF # Some shells (Coherent) do redirections in the wrong order, so need # the parens. ac_err=`eval "($ac_cpp conftest.${ac_ext} >/dev/null) 2>&1"` if test -z "$ac_err"; then : else rm -rf conftest* CPP=/lib/cpp fi rm -f conftest* fi rm -f conftest* fi test -n "$verbose" && echo " setting CPP to $CPP" if test -n "$GCC"; then test -n "$silent" || echo "checking whether -traditional is needed" ac_pattern="Autoconf.*'x'" ac_prog='#include Autoconf TIOCGETP' cat > conftest.${ac_ext} < conftest.out 2>&1" if egrep "$ac_pattern" conftest.out >/dev/null 2>&1; then rm -rf conftest* ac_need_trad=1 fi rm -f conftest* if test -z "$ac_need_trad"; then ac_prog='#include Autoconf TCGETA' cat > conftest.${ac_ext} < conftest.out 2>&1" if egrep "$ac_pattern" conftest.out >/dev/null 2>&1; then rm -rf conftest* ac_need_trad=1 fi rm -f conftest* fi test -n "$ac_need_trad" && CC="$CC -traditional" fi # Make sure to not get the incompatible SysV /etc/install and # /usr/sbin/install, which might be in PATH before a BSD-like install, # or the SunOS /usr/etc/install directory, or the AIX /bin/install, # or the AFS install, which mishandles nonexistent args, or # /usr/ucb/install on SVR4, which tries to use the nonexistent group # `staff', or /sbin/install on IRIX which has incompatible command-line # syntax. Sigh. # # On most BSDish systems install is in /usr/bin, not /usr/ucb # anyway. # This turns out not to be true, so the mere pathname isn't an indication # of whether the program works. What we really need is a set of tests for # the install program to see if it actually works in all the required ways. # # Avoid using ./install, which might have been erroneously created # by make from ./install.sh. if test -z "${INSTALL}"; then test -n "$silent" || echo "checking for a BSD compatible install" IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}:" for ac_dir in $PATH; do case "$ac_dir" in ''|.|/etc|/sbin|/usr/sbin|/usr/etc|/usr/afsws/bin|/usr/ucb) ;; *) # OSF1 and SCO ODT 3.0 have their own names for install. for ac_prog in installbsd scoinst install; do if test -f $ac_dir/$ac_prog; then if test $ac_prog = install && grep dspmsg $ac_dir/$ac_prog >/dev/null 2>&1; then # AIX install. It has an incompatible calling convention. # OSF/1 installbsd also uses dspmsg, but is usable. : else INSTALL="$ac_dir/$ac_prog -c" break 2 fi fi done ;; esac done IFS="$ac_save_ifs" fi if test -z "$INSTALL"; then # As a last resort, use the slow shell script. for ac_dir in ${srcdir} ${srcdir}/.. ${srcdir}/../..; do if test -f $ac_dir/install.sh; then INSTALL="$ac_dir/install.sh -c"; break fi done fi if test -z "$INSTALL"; then echo "configure: can not find install.sh in ${srcdir} or ${srcdir}/.. or ${srcdir}/../.." >&2; exit 1 fi test -n "$verbose" && echo " setting INSTALL to $INSTALL" # Use test -z because SunOS4 sh mishandles ${INSTALL_PROGRAM-'${INSTALL}'}. # It thinks the first close brace ends the variable substitution. test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}' test -n "$verbose" && echo " setting INSTALL_PROGRAM to $INSTALL_PROGRAM" test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644' test -n "$verbose" && echo " setting INSTALL_DATA to $INSTALL_DATA" case "$INSTALL" in \./install\.sh*) INSTALL=".$INSTALL" ; test -n "$verbose" && echo " adjusting INSTALL to $INSTALL" ;; *) ;; esac if test -z "$RANLIB"; then # Extract the first word of `ranlib', so it can be a program name with args. set ac_dummy ranlib; ac_word=$2 test -n "$silent" || echo "checking for $ac_word" IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}:" for ac_dir in $PATH; do test -z "$ac_dir" && ac_dir=. if test -f $ac_dir/$ac_word; then RANLIB="ranlib" break fi done IFS="$ac_save_ifs" fi test -z "$RANLIB" && RANLIB=":" test -n "$RANLIB" && test -n "$verbose" && echo " setting RANLIB to $RANLIB" for ac_prog in 'bison -y' byacc do if test -z "$YACC"; then # Extract the first word of `$ac_prog', so it can be a program name with args. set ac_dummy $ac_prog; ac_word=$2 test -n "$silent" || echo "checking for $ac_word" IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}:" for ac_dir in $PATH; do test -z "$ac_dir" && ac_dir=. if test -f $ac_dir/$ac_word; then YACC="$ac_prog" break fi done IFS="$ac_save_ifs" fi test -n "$YACC" && test -n "$verbose" && echo " setting YACC to $YACC" test -n "$YACC" && break done test -n "$YACC" || YACC="yacc" test -n "$silent" || echo "checking for AIX" cat > conftest.${ac_ext} < conftest.out 2>&1" if egrep "yes" conftest.out >/dev/null 2>&1; then rm -rf conftest* { test -n "$verbose" && \ echo " defining _ALL_SOURCE" echo "#define" _ALL_SOURCE "1" >> confdefs.h DEFS="$DEFS -D_ALL_SOURCE=1" ac_sed_defs="${ac_sed_defs}\${ac_dA}_ALL_SOURCE\${ac_dB}_ALL_SOURCE\${ac_dC}1\${ac_dD} \${ac_uA}_ALL_SOURCE\${ac_uB}_ALL_SOURCE\${ac_uC}1\${ac_uD} \${ac_eA}_ALL_SOURCE\${ac_eB}_ALL_SOURCE\${ac_eC}1\${ac_eD} " } fi rm -f conftest* test -n "$silent" || echo "checking for minix/config.h" cat > conftest.${ac_ext} < EOF # Some shells (Coherent) do redirections in the wrong order, so need # the parens. ac_err=`eval "($ac_cpp conftest.${ac_ext} >/dev/null) 2>&1"` if test -z "$ac_err"; then rm -rf conftest* MINIX=1 fi rm -f conftest* # The Minix shell can't assign to the same variable on the same line! if test -n "$MINIX"; then { test -n "$verbose" && \ echo " defining _POSIX_SOURCE" echo "#define" _POSIX_SOURCE "1" >> confdefs.h DEFS="$DEFS -D_POSIX_SOURCE=1" ac_sed_defs="${ac_sed_defs}\${ac_dA}_POSIX_SOURCE\${ac_dB}_POSIX_SOURCE\${ac_dC}1\${ac_dD} \${ac_uA}_POSIX_SOURCE\${ac_uB}_POSIX_SOURCE\${ac_uC}1\${ac_uD} \${ac_eA}_POSIX_SOURCE\${ac_eB}_POSIX_SOURCE\${ac_eC}1\${ac_eD} " } { test -n "$verbose" && \ echo " defining" _POSIX_1_SOURCE to be "2" echo "#define" _POSIX_1_SOURCE "2" >> confdefs.h DEFS="$DEFS -D_POSIX_1_SOURCE=2" ac_sed_defs="${ac_sed_defs}\${ac_dA}_POSIX_1_SOURCE\${ac_dB}_POSIX_1_SOURCE\${ac_dC}2\${ac_dD} \${ac_uA}_POSIX_1_SOURCE\${ac_uB}_POSIX_1_SOURCE\${ac_uC}2\${ac_uD} \${ac_eA}_POSIX_1_SOURCE\${ac_eB}_POSIX_1_SOURCE\${ac_eC}2\${ac_eD} " } { test -n "$verbose" && \ echo " defining _MINIX" echo "#define" _MINIX "1" >> confdefs.h DEFS="$DEFS -D_MINIX=1" ac_sed_defs="${ac_sed_defs}\${ac_dA}_MINIX\${ac_dB}_MINIX\${ac_dC}1\${ac_dD} \${ac_uA}_MINIX\${ac_uB}_MINIX\${ac_uC}1\${ac_uD} \${ac_eA}_MINIX\${ac_eB}_MINIX\${ac_eC}1\${ac_eD} " } fi test -n "$silent" || echo "checking for POSIXized ISC" if test -d /etc/conf/kconfig.d && grep _POSIX_VERSION /usr/include/sys/unistd.h >/dev/null 2>&1 then ISC=1 # If later tests want to check for ISC. { test -n "$verbose" && \ echo " defining _POSIX_SOURCE" echo "#define" _POSIX_SOURCE "1" >> confdefs.h DEFS="$DEFS -D_POSIX_SOURCE=1" ac_sed_defs="${ac_sed_defs}\${ac_dA}_POSIX_SOURCE\${ac_dB}_POSIX_SOURCE\${ac_dC}1\${ac_dD} \${ac_uA}_POSIX_SOURCE\${ac_uB}_POSIX_SOURCE\${ac_uC}1\${ac_uD} \${ac_eA}_POSIX_SOURCE\${ac_eB}_POSIX_SOURCE\${ac_eC}1\${ac_eD} " } if test -n "$GCC"; then CC="$CC -posix" else CC="$CC -Xp" fi fi ac_save_LIBS="${LIBS}" LIBS="${LIBS} -lintl" ac_have_lib="" test -n "$silent" || echo "checking for -lintl" cat > conftest.${ac_ext} < conftest.${ac_ext} < int main() { return 0; } int t() { /* The GNU C library defines this for functions which it implements to always fail with ENOSYS. Some functions are actually named something starting with __ and the normal name is an alias. */ #if defined (__stub_uname) || defined (__stub___uname) choke me #else /* Override any gcc2 internal prototype to avoid an error. */ extern char uname(); uname(); #endif ; return 0; } EOF if eval $ac_compile; then rm -rf conftest* PROGS="$PROGS uname" MAN="$MAN uname.1" have_uname=1 fi rm -f conftest* ac_prog='/* Ultrix mips cc rejects this. */ typedef int charset[2]; const charset x; /* SunOS 4.1.1 cc rejects this. */ char const *const *ccp; char **p; /* AIX XL C 1.02.0.0 rejects this. It does not let you subtract one const X* pointer from another in an arm of an if-expression whose if-part is not a constant expression */ const char *g = "string"; ccp = &g + (g ? g-g : 0); /* HPUX 7.0 cc rejects these. */ ++ccp; p = (char**) ccp; ccp = (char const *const *) p; { /* SCO 3.2v4 cc rejects this. */ char *t; char const *s = 0 ? (char *) 0 : (char const *) 0; *t++ = 0; } { /* Someone thinks the Sun supposedly-ANSI compiler will reject this. */ int x[] = {25,17}; const int *foo = &x[0]; ++foo; } { /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */ typedef const int *iptr; iptr p = 0; ++p; } { /* AIX XL C 1.02.0.0 rejects this saying "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */ struct s { int j; const int *ap[3]; }; struct s *b; b->j = 5; } { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */ const int foo = 10; }' test -n "$silent" || echo "checking for lack of working const" cat > conftest.${ac_ext} <> confdefs.h DEFS="$DEFS -Dconst=" ac_sed_defs="${ac_sed_defs}\${ac_dA}const\${ac_dB}const\${ac_dC}\${ac_dD} \${ac_uA}const\${ac_uB}const\${ac_uC}\${ac_uD} \${ac_eA}const\${ac_eB}const\${ac_eC}\${ac_eD} " } fi rm -f conftest* test -n "$silent" || echo "checking for ANSI C header files" cat > conftest.${ac_ext} < #include #include #include EOF # Some shells (Coherent) do redirections in the wrong order, so need # the parens. ac_err=`eval "($ac_cpp conftest.${ac_ext} >/dev/null) 2>&1"` if test -z "$ac_err"; then rm -rf conftest* # SunOS 4.x string.h does not declare mem*, contrary to ANSI. echo '#include "confdefs.h" #include ' > conftest.${ac_ext} eval "$ac_cpp conftest.${ac_ext} > conftest.out 2>&1" if egrep "memchr" conftest.out >/dev/null 2>&1; then rm -rf conftest* # SGI's /bin/cc from Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi. cat > conftest.${ac_ext} < #define ISLOWER(c) ('a' <= (c) && (c) <= 'z') #define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c)) #define XOR(e,f) (((e) && !(f)) || (!(e) && (f))) int main () { int i; for (i = 0; i < 256; i++) if (XOR (islower (i), ISLOWER (i)) || toupper (i) != TOUPPER (i)) exit(2); exit (0); } EOF eval $ac_compile if test -s conftest && (./conftest; exit) 2>/dev/null; then # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI. echo '#include "confdefs.h" #include ' > conftest.${ac_ext} eval "$ac_cpp conftest.${ac_ext} > conftest.out 2>&1" if egrep "free" conftest.out >/dev/null 2>&1; then rm -rf conftest* { test -n "$verbose" && \ echo " defining STDC_HEADERS" echo "#define" STDC_HEADERS "1" >> confdefs.h DEFS="$DEFS -DSTDC_HEADERS=1" ac_sed_defs="${ac_sed_defs}\${ac_dA}STDC_HEADERS\${ac_dB}STDC_HEADERS\${ac_dC}1\${ac_dD} \${ac_uA}STDC_HEADERS\${ac_uB}STDC_HEADERS\${ac_uC}1\${ac_uD} \${ac_eA}STDC_HEADERS\${ac_eB}STDC_HEADERS\${ac_eC}1\${ac_eD} " } fi rm -f conftest* fi rm -fr conftest* fi rm -f conftest* fi rm -f conftest* for ac_func in strerror ftime memcpy bcopy gettimeofday syslog initgroups \ isascii sethostname sysinfo do ac_tr_func=HAVE_`echo $ac_func | tr '[a-z]' '[A-Z]'` test -n "$silent" || echo "checking for ${ac_func}" cat > conftest.${ac_ext} < int main() { return 0; } int t() { /* The GNU C library defines this for functions which it implements to always fail with ENOSYS. Some functions are actually named something starting with __ and the normal name is an alias. */ #if defined (__stub_${ac_func}) || defined (__stub___${ac_func}) choke me #else /* Override any gcc2 internal prototype to avoid an error. */ extern char ${ac_func}(); ${ac_func}(); #endif ; return 0; } EOF if eval $ac_compile; then rm -rf conftest* { test -n "$verbose" && \ echo " defining ${ac_tr_func}" echo "#define" ${ac_tr_func} "1" >> confdefs.h DEFS="$DEFS -D${ac_tr_func}=1" ac_sed_defs="${ac_sed_defs}\${ac_dA}${ac_tr_func}\${ac_dB}${ac_tr_func}\${ac_dC}1\${ac_dD} \${ac_uA}${ac_tr_func}\${ac_uB}${ac_tr_func}\${ac_uC}1\${ac_uD} \${ac_eA}${ac_tr_func}\${ac_eB}${ac_tr_func}\${ac_eC}1\${ac_eD} " } fi rm -f conftest* done # This check must be performed before HAVE_SYSLOG_H can be defined. case "$DEFS" in *-DHAVE_SYSLOG*) ;; *) # syslog is not in the default libraries. See if it's in some other. saved_LIBS="$LIBS" for lib in bsd socket inet; do test -n "$silent" || echo "checking for syslog in -l$lib" LIBS="$saved_LIBS -l$lib" for ac_func in syslog do ac_tr_func=HAVE_`echo $ac_func | tr '[a-z]' '[A-Z]'` test -n "$silent" || echo "checking for ${ac_func}" cat > conftest.${ac_ext} < int main() { return 0; } int t() { /* The GNU C library defines this for functions which it implements to always fail with ENOSYS. Some functions are actually named something starting with __ and the normal name is an alias. */ #if defined (__stub_${ac_func}) || defined (__stub___${ac_func}) choke me #else /* Override any gcc2 internal prototype to avoid an error. */ extern char ${ac_func}(); ${ac_func}(); #endif ; return 0; } EOF if eval $ac_compile; then rm -rf conftest* { test -n "$verbose" && \ echo " defining ${ac_tr_func}" echo "#define" ${ac_tr_func} "1" >> confdefs.h DEFS="$DEFS -D${ac_tr_func}=1" ac_sed_defs="${ac_sed_defs}\${ac_dA}${ac_tr_func}\${ac_dB}${ac_tr_func}\${ac_dC}1\${ac_dD} \${ac_uA}${ac_tr_func}\${ac_uB}${ac_tr_func}\${ac_uC}1\${ac_uD} \${ac_eA}${ac_tr_func}\${ac_eB}${ac_tr_func}\${ac_eC}1\${ac_eD} " } fi rm -f conftest* done case "$DEFS" in *-DHAVE_SYSLOG*) break ;; *) ;; esac LIBS="$saved_LIBS" done ;; esac # SCO-ODT-3.0 is reported to need -los to link programs using initgroups case "$DEFS" in *-DHAVE_INITGROUPS*) ;; *) # initgroups is not in the default libraries. See if it's in some other. saved_LIBS="$LIBS" for lib in os; do test -n "$silent" || echo "checking for initgroups in -l$lib" LIBS="$saved_LIBS -l$lib" for ac_func in initgroups do ac_tr_func=HAVE_`echo $ac_func | tr '[a-z]' '[A-Z]'` test -n "$silent" || echo "checking for ${ac_func}" cat > conftest.${ac_ext} < int main() { return 0; } int t() { /* The GNU C library defines this for functions which it implements to always fail with ENOSYS. Some functions are actually named something starting with __ and the normal name is an alias. */ #if defined (__stub_${ac_func}) || defined (__stub___${ac_func}) choke me #else /* Override any gcc2 internal prototype to avoid an error. */ extern char ${ac_func}(); ${ac_func}(); #endif ; return 0; } EOF if eval $ac_compile; then rm -rf conftest* { test -n "$verbose" && \ echo " defining ${ac_tr_func}" echo "#define" ${ac_tr_func} "1" >> confdefs.h DEFS="$DEFS -D${ac_tr_func}=1" ac_sed_defs="${ac_sed_defs}\${ac_dA}${ac_tr_func}\${ac_dB}${ac_tr_func}\${ac_dC}1\${ac_dD} \${ac_uA}${ac_tr_func}\${ac_uB}${ac_tr_func}\${ac_uC}1\${ac_uD} \${ac_eA}${ac_tr_func}\${ac_eB}${ac_tr_func}\${ac_eC}1\${ac_eD} " } fi rm -f conftest* done case "$DEFS" in *-DHAVE_INITGROUPS*) break ;; *) ;; esac LIBS="$saved_LIBS" done ;; esac for ac_hdr in string.h fcntl.h limits.h syslog.h sys/time.h unistd.h \ sys/timeb.h float.h sys/systeminfo.h do ac_tr_hdr=HAVE_`echo $ac_hdr | tr '[a-z]./' '[A-Z]__'` test -n "$silent" || echo "checking for ${ac_hdr}" cat > conftest.${ac_ext} < EOF # Some shells (Coherent) do redirections in the wrong order, so need # the parens. ac_err=`eval "($ac_cpp conftest.${ac_ext} >/dev/null) 2>&1"` if test -z "$ac_err"; then rm -rf conftest* { test -n "$verbose" && \ echo " defining ${ac_tr_hdr}" echo "#define" ${ac_tr_hdr} "1" >> confdefs.h DEFS="$DEFS -D${ac_tr_hdr}=1" ac_sed_defs="${ac_sed_defs}\${ac_dA}${ac_tr_hdr}\${ac_dB}${ac_tr_hdr}\${ac_dC}1\${ac_dD} \${ac_uA}${ac_tr_hdr}\${ac_uB}${ac_tr_hdr}\${ac_uC}1\${ac_uD} \${ac_eA}${ac_tr_hdr}\${ac_eB}${ac_tr_hdr}\${ac_eC}1\${ac_eD} " } fi rm -f conftest* done test -n "$silent" || echo "checking for uid_t in sys/types.h" echo '#include "confdefs.h" #include ' > conftest.${ac_ext} eval "$ac_cpp conftest.${ac_ext} > conftest.out 2>&1" if egrep "uid_t" conftest.out >/dev/null 2>&1; then : else rm -rf conftest* { test -n "$verbose" && \ echo " defining" uid_t to be "int" echo "#define" uid_t "int" >> confdefs.h DEFS="$DEFS -Duid_t=int" ac_sed_defs="${ac_sed_defs}\${ac_dA}uid_t\${ac_dB}uid_t\${ac_dC}int\${ac_dD} \${ac_uA}uid_t\${ac_uB}uid_t\${ac_uC}int\${ac_uD} \${ac_eA}uid_t\${ac_eB}uid_t\${ac_eC}int\${ac_eD} " } { test -n "$verbose" && \ echo " defining" gid_t to be "int" echo "#define" gid_t "int" >> confdefs.h DEFS="$DEFS -Dgid_t=int" ac_sed_defs="${ac_sed_defs}\${ac_dA}gid_t\${ac_dB}gid_t\${ac_dC}int\${ac_dD} \${ac_uA}gid_t\${ac_uB}gid_t\${ac_uC}int\${ac_uD} \${ac_eA}gid_t\${ac_eB}gid_t\${ac_eC}int\${ac_eD} " } fi rm -f conftest* test -n "$silent" || echo "checking for type of array argument to getgroups" ac_prog='/* Thanks to Mike Rendell for this test. */ #include #define NGID 256 #undef MAX #define MAX(x,y) ((x) > (y) ? (x) : (y)) main() { gid_t gidset[NGID]; int i, n; union { gid_t gval; long lval; } val; val.lval = -1; for (i = 0; i < NGID; i++) gidset[i] = val.gval; n = getgroups (sizeof (gidset) / MAX (sizeof (int), sizeof (gid_t)) - 1, gidset); /* Exit non-zero if getgroups seems to require an array of ints. This happens when gid_t is short but getgroups modifies an array of ints. */ exit ((n > 0 && gidset[n] != val.gval) ? 1 : 0); }' cat > conftest.${ac_ext} </dev/null; then { test -n "$verbose" && \ echo " defining" GETGROUPS_T to be "gid_t" echo "#define" GETGROUPS_T "gid_t" >> confdefs.h DEFS="$DEFS -DGETGROUPS_T=gid_t" ac_sed_defs="${ac_sed_defs}\${ac_dA}GETGROUPS_T\${ac_dB}GETGROUPS_T\${ac_dC}gid_t\${ac_dD} \${ac_uA}GETGROUPS_T\${ac_uB}GETGROUPS_T\${ac_uC}gid_t\${ac_uD} \${ac_eA}GETGROUPS_T\${ac_eB}GETGROUPS_T\${ac_eC}gid_t\${ac_eD} " } else { test -n "$verbose" && \ echo " defining" GETGROUPS_T to be "int" echo "#define" GETGROUPS_T "int" >> confdefs.h DEFS="$DEFS -DGETGROUPS_T=int" ac_sed_defs="${ac_sed_defs}\${ac_dA}GETGROUPS_T\${ac_dB}GETGROUPS_T\${ac_dC}int\${ac_dD} \${ac_uA}GETGROUPS_T\${ac_uB}GETGROUPS_T\${ac_uC}int\${ac_uD} \${ac_eA}GETGROUPS_T\${ac_eB}GETGROUPS_T\${ac_eC}int\${ac_eD} " } fi rm -fr conftest* test -n "$silent" || echo "checking for size_t in sys/types.h" echo '#include "confdefs.h" #include ' > conftest.${ac_ext} eval "$ac_cpp conftest.${ac_ext} > conftest.out 2>&1" if egrep "size_t" conftest.out >/dev/null 2>&1; then : else rm -rf conftest* { test -n "$verbose" && \ echo " defining" size_t to be "unsigned" echo "#define" size_t "unsigned" >> confdefs.h DEFS="$DEFS -Dsize_t=unsigned" ac_sed_defs="${ac_sed_defs}\${ac_dA}size_t\${ac_dB}size_t\${ac_dC}unsigned\${ac_dD} \${ac_uA}size_t\${ac_uB}size_t\${ac_uC}unsigned\${ac_uD} \${ac_eA}size_t\${ac_eB}size_t\${ac_eC}unsigned\${ac_eD} " } fi rm -f conftest* for ac_func in gethostname getusershell memcmp mktime stime \ strcspn strstr strtol strtoul strtod do test -n "$silent" || echo "checking for ${ac_func}" cat > conftest.${ac_ext} < int main() { return 0; } int t() { /* The GNU C library defines this for functions which it implements to always fail with ENOSYS. Some functions are actually named something starting with __ and the normal name is an alias. */ #if defined (__stub_${ac_func}) || defined (__stub___${ac_func}) choke me #else /* Override any gcc2 internal prototype to avoid an error. */ extern char ${ac_func}(); ${ac_func}(); #endif ; return 0; } EOF if eval $ac_compile; then : else rm -rf conftest* LIBOBJS="$LIBOBJS ${ac_func}.o" test -n "$verbose" && echo " using ${ac_func}.o instead" fi rm -f conftest* done case "$LIBOBJS" in *memcmp*) ;; *) test -n "$silent" || echo "checking whether memcmp is 8-bit clean" cat > conftest.${ac_ext} </dev/null; then test -n "$verbose" && echo " memcmp is 8-bit clean" else echo "configure: warning: memcmp is NOT 8-bit clean -- using replacement" >&2 LIBOBJS="$LIBOBJS memcmp.o" fi rm -fr conftest* ;; esac test -n "$silent" || echo "checking for setpriority" cat > conftest.${ac_ext} < #include int main() { return 0; } int t() { setpriority(0, 0, 0);; return 0; } EOF if eval $ac_compile; then rm -rf conftest* PROGS="$PROGS nice nohup" MAN="$MAN nice.1 nohup.1" fi rm -f conftest* case "$PROGS" in *nice*) ;; *) test -n "$silent" || echo "checking for nice" cat > conftest.${ac_ext} <> confdefs.h DEFS="$DEFS -DNICE_PRIORITY=1" ac_sed_defs="${ac_sed_defs}\${ac_dA}NICE_PRIORITY\${ac_dB}NICE_PRIORITY\${ac_dC}1\${ac_dD} \${ac_uA}NICE_PRIORITY\${ac_uB}NICE_PRIORITY\${ac_uC}1\${ac_uD} \${ac_eA}NICE_PRIORITY\${ac_eB}NICE_PRIORITY\${ac_eC}1\${ac_eD} " } PROGS="$PROGS nice nohup" MAN="$MAN nice.1 nohup.1" fi rm -f conftest* ;; esac case "$LIBOBJS" in *gethostname*) test -n "$have_uname" && { test -n "$verbose" && \ echo " defining HAVE_UNAME" echo "#define" HAVE_UNAME "1" >> confdefs.h DEFS="$DEFS -DHAVE_UNAME=1" ac_sed_defs="${ac_sed_defs}\${ac_dA}HAVE_UNAME\${ac_dB}HAVE_UNAME\${ac_dC}1\${ac_dD} \${ac_uA}HAVE_UNAME\${ac_uB}HAVE_UNAME\${ac_uC}1\${ac_uD} \${ac_eA}HAVE_UNAME\${ac_eB}HAVE_UNAME\${ac_eC}1\${ac_eD} " } ;; esac test -n "$silent" || echo "checking for ut_host in struct utmp" cat > conftest.${ac_ext} < #include int main() { return 0; } int t() { struct utmp ut; ut.ut_host;; return 0; } EOF if eval $ac_compile; then rm -rf conftest* { test -n "$verbose" && \ echo " defining HAVE_UT_HOST" echo "#define" HAVE_UT_HOST "1" >> confdefs.h DEFS="$DEFS -DHAVE_UT_HOST=1" ac_sed_defs="${ac_sed_defs}\${ac_dA}HAVE_UT_HOST\${ac_dB}HAVE_UT_HOST\${ac_dC}1\${ac_dD} \${ac_uA}HAVE_UT_HOST\${ac_uB}HAVE_UT_HOST\${ac_uC}1\${ac_uD} \${ac_eA}HAVE_UT_HOST\${ac_eB}HAVE_UT_HOST\${ac_eC}1\${ac_eD} " } fi rm -f conftest* case "$DEFS" in *HAVE_UT_HOST*) ;; *) test -n "$silent" || echo "checking for ut_host in struct utmpx" cat > conftest.${ac_ext} < #include int main() { return 0; } int t() { struct utmpx ut; ut.ut_host;; return 0; } EOF if eval $ac_compile; then rm -rf conftest* { test -n "$verbose" && \ echo " defining HAVE_UTMPX_H" echo "#define" HAVE_UTMPX_H "1" >> confdefs.h DEFS="$DEFS -DHAVE_UTMPX_H=1" ac_sed_defs="${ac_sed_defs}\${ac_dA}HAVE_UTMPX_H\${ac_dB}HAVE_UTMPX_H\${ac_dC}1\${ac_dD} \${ac_uA}HAVE_UTMPX_H\${ac_uB}HAVE_UTMPX_H\${ac_uC}1\${ac_uD} \${ac_eA}HAVE_UTMPX_H\${ac_eB}HAVE_UTMPX_H\${ac_eC}1\${ac_eD} " } { test -n "$verbose" && \ echo " defining HAVE_UT_HOST" echo "#define" HAVE_UT_HOST "1" >> confdefs.h DEFS="$DEFS -DHAVE_UT_HOST=1" ac_sed_defs="${ac_sed_defs}\${ac_dA}HAVE_UT_HOST\${ac_dB}HAVE_UT_HOST\${ac_dC}1\${ac_dD} \${ac_uA}HAVE_UT_HOST\${ac_uB}HAVE_UT_HOST\${ac_uC}1\${ac_uD} \${ac_eA}HAVE_UT_HOST\${ac_eB}HAVE_UT_HOST\${ac_eC}1\${ac_eD} " } fi rm -f conftest* ;; esac test -n "$silent" || echo "checking for POSIX termios" cat > conftest.${ac_ext} < #include #include int main() { return 0; } int t() { /* SunOS 4.0.3 has termios.h but not the library calls. */ tcgetattr(0, 0);; return 0; } EOF if eval $ac_compile; then rm -rf conftest* have_termios=1 fi rm -f conftest* if test -n "$have_termios"; then PROGS="$PROGS stty" MAN="$MAN stty.1" test -n "$silent" || echo "checking for c_line in struct termios" cat > conftest.${ac_ext} < #include int main() { return 0; } int t() { struct termios t; t.c_line;; return 0; } EOF if eval $ac_compile; then rm -rf conftest* { test -n "$verbose" && \ echo " defining HAVE_C_LINE" echo "#define" HAVE_C_LINE "1" >> confdefs.h DEFS="$DEFS -DHAVE_C_LINE=1" ac_sed_defs="${ac_sed_defs}\${ac_dA}HAVE_C_LINE\${ac_dB}HAVE_C_LINE\${ac_dC}1\${ac_dD} \${ac_uA}HAVE_C_LINE\${ac_uB}HAVE_C_LINE\${ac_uC}1\${ac_uD} \${ac_eA}HAVE_C_LINE\${ac_eB}HAVE_C_LINE\${ac_eC}1\${ac_eD} " } fi rm -f conftest* test -n "$silent" || echo "checking for TIOCGWINSZ in termios.h" cat > conftest.${ac_ext} < #include int main() { return 0; } int t() { int x = TIOCGWINSZ;; return 0; } EOF if eval $ac_compile; then rm -rf conftest* have_tiocgwinsz=1 fi rm -f conftest* fi if test -z "$have_tiocgwinsz"; then test -n "$silent" || echo "checking for TIOCGWINSZ in sys/ioctl.h" cat > conftest.${ac_ext} < #include int main() { return 0; } int t() { int x = TIOCGWINSZ;; return 0; } EOF if eval $ac_compile; then rm -rf conftest* { test -n "$verbose" && \ echo " defining GWINSZ_IN_SYS_IOCTL" echo "#define" GWINSZ_IN_SYS_IOCTL "1" >> confdefs.h DEFS="$DEFS -DGWINSZ_IN_SYS_IOCTL=1" ac_sed_defs="${ac_sed_defs}\${ac_dA}GWINSZ_IN_SYS_IOCTL\${ac_dB}GWINSZ_IN_SYS_IOCTL\${ac_dC}1\${ac_dD} \${ac_uA}GWINSZ_IN_SYS_IOCTL\${ac_uB}GWINSZ_IN_SYS_IOCTL\${ac_uC}1\${ac_uD} \${ac_eA}GWINSZ_IN_SYS_IOCTL\${ac_eB}GWINSZ_IN_SYS_IOCTL\${ac_eC}1\${ac_eD} " } fi rm -f conftest* fi test -n "$silent" || echo "checking for sys/ptem.h" cat > conftest.${ac_ext} < EOF # Some shells (Coherent) do redirections in the wrong order, so need # the parens. ac_err=`eval "($ac_cpp conftest.${ac_ext} >/dev/null) 2>&1"` if test -z "$ac_err"; then rm -rf conftest* { test -n "$verbose" && \ echo " defining WINSIZE_IN_PTEM" echo "#define" WINSIZE_IN_PTEM "1" >> confdefs.h DEFS="$DEFS -DWINSIZE_IN_PTEM=1" ac_sed_defs="${ac_sed_defs}\${ac_dA}WINSIZE_IN_PTEM\${ac_dB}WINSIZE_IN_PTEM\${ac_dC}1\${ac_dD} \${ac_uA}WINSIZE_IN_PTEM\${ac_uB}WINSIZE_IN_PTEM\${ac_uC}1\${ac_uD} \${ac_eA}WINSIZE_IN_PTEM\${ac_eB}WINSIZE_IN_PTEM\${ac_eC}1\${ac_eD} " } fi rm -f conftest* test -n "$silent" || echo "checking for vprintf" cat > conftest.${ac_ext} <> confdefs.h DEFS="$DEFS -DHAVE_VPRINTF=1" ac_sed_defs="${ac_sed_defs}\${ac_dA}HAVE_VPRINTF\${ac_dB}HAVE_VPRINTF\${ac_dC}1\${ac_dD} \${ac_uA}HAVE_VPRINTF\${ac_uB}HAVE_VPRINTF\${ac_uC}1\${ac_uD} \${ac_eA}HAVE_VPRINTF\${ac_eB}HAVE_VPRINTF\${ac_eC}1\${ac_eD} " } else rm -rf conftest* ac_vprintf_missing=1 fi rm -f conftest* if test -n "$ac_vprintf_missing"; then test -n "$silent" || echo "checking for _doprnt" cat > conftest.${ac_ext} <> confdefs.h DEFS="$DEFS -DHAVE_DOPRNT=1" ac_sed_defs="${ac_sed_defs}\${ac_dA}HAVE_DOPRNT\${ac_dB}HAVE_DOPRNT\${ac_dC}1\${ac_dD} \${ac_uA}HAVE_DOPRNT\${ac_uB}HAVE_DOPRNT\${ac_uC}1\${ac_uD} \${ac_eA}HAVE_DOPRNT\${ac_eB}HAVE_DOPRNT\${ac_eC}1\${ac_eD} " } fi rm -f conftest* fi # The Ultrix 4.2 mips builtin alloca declared by alloca.h only works # for constant arguments. Useless! test -n "$silent" || echo "checking for working alloca.h" cat > conftest.${ac_ext} < int main() { return 0; } int t() { char *p = alloca(2 * sizeof(int));; return 0; } EOF if eval $ac_compile; then rm -rf conftest* { test -n "$verbose" && \ echo " defining HAVE_ALLOCA_H" echo "#define" HAVE_ALLOCA_H "1" >> confdefs.h DEFS="$DEFS -DHAVE_ALLOCA_H=1" ac_sed_defs="${ac_sed_defs}\${ac_dA}HAVE_ALLOCA_H\${ac_dB}HAVE_ALLOCA_H\${ac_dC}1\${ac_dD} \${ac_uA}HAVE_ALLOCA_H\${ac_uB}HAVE_ALLOCA_H\${ac_uC}1\${ac_uD} \${ac_eA}HAVE_ALLOCA_H\${ac_eB}HAVE_ALLOCA_H\${ac_eC}1\${ac_eD} " } fi rm -f conftest* ac_decl="#ifdef __GNUC__ #define alloca __builtin_alloca #else #if HAVE_ALLOCA_H #include #else #ifdef _AIX #pragma alloca #else char *alloca (); #endif #endif #endif " test -n "$silent" || echo "checking for alloca" cat > conftest.${ac_ext} <> confdefs.h DEFS="$DEFS -DHAVE_ALLOCA=1" ac_sed_defs="${ac_sed_defs}\${ac_dA}HAVE_ALLOCA\${ac_dB}HAVE_ALLOCA\${ac_dC}1\${ac_dD} \${ac_uA}HAVE_ALLOCA\${ac_uB}HAVE_ALLOCA\${ac_uC}1\${ac_uD} \${ac_eA}HAVE_ALLOCA\${ac_eB}HAVE_ALLOCA\${ac_eC}1\${ac_eD} " } else rm -rf conftest* ac_alloca_missing=1 cat > conftest.${ac_ext} < conftest.out 2>&1" if egrep "winnitude" conftest.out >/dev/null 2>&1; then rm -rf conftest* test -n "$silent" || echo "checking for _getb67" cat > conftest.${ac_ext} < int main() { return 0; } int t() { /* The GNU C library defines this for functions which it implements to always fail with ENOSYS. Some functions are actually named something starting with __ and the normal name is an alias. */ #if defined (__stub__getb67) || defined (__stub____getb67) choke me #else /* Override any gcc2 internal prototype to avoid an error. */ extern char _getb67(); _getb67(); #endif ; return 0; } EOF if eval $ac_compile; then rm -rf conftest* { test -n "$verbose" && \ echo " defining" CRAY_STACKSEG_END to be "_getb67" echo "#define" CRAY_STACKSEG_END "_getb67" >> confdefs.h DEFS="$DEFS -DCRAY_STACKSEG_END=_getb67" ac_sed_defs="${ac_sed_defs}\${ac_dA}CRAY_STACKSEG_END\${ac_dB}CRAY_STACKSEG_END\${ac_dC}_getb67\${ac_dD} \${ac_uA}CRAY_STACKSEG_END\${ac_uB}CRAY_STACKSEG_END\${ac_uC}_getb67\${ac_uD} \${ac_eA}CRAY_STACKSEG_END\${ac_eB}CRAY_STACKSEG_END\${ac_eC}_getb67\${ac_eD} " } else rm -rf conftest* test -n "$silent" || echo "checking for GETB67" cat > conftest.${ac_ext} < int main() { return 0; } int t() { /* The GNU C library defines this for functions which it implements to always fail with ENOSYS. Some functions are actually named something starting with __ and the normal name is an alias. */ #if defined (__stub_GETB67) || defined (__stub___GETB67) choke me #else /* Override any gcc2 internal prototype to avoid an error. */ extern char GETB67(); GETB67(); #endif ; return 0; } EOF if eval $ac_compile; then rm -rf conftest* { test -n "$verbose" && \ echo " defining" CRAY_STACKSEG_END to be "GETB67" echo "#define" CRAY_STACKSEG_END "GETB67" >> confdefs.h DEFS="$DEFS -DCRAY_STACKSEG_END=GETB67" ac_sed_defs="${ac_sed_defs}\${ac_dA}CRAY_STACKSEG_END\${ac_dB}CRAY_STACKSEG_END\${ac_dC}GETB67\${ac_dD} \${ac_uA}CRAY_STACKSEG_END\${ac_uB}CRAY_STACKSEG_END\${ac_uC}GETB67\${ac_uD} \${ac_eA}CRAY_STACKSEG_END\${ac_eB}CRAY_STACKSEG_END\${ac_eC}GETB67\${ac_eD} " } else rm -rf conftest* test -n "$silent" || echo "checking for getb67" cat > conftest.${ac_ext} < int main() { return 0; } int t() { /* The GNU C library defines this for functions which it implements to always fail with ENOSYS. Some functions are actually named something starting with __ and the normal name is an alias. */ #if defined (__stub_getb67) || defined (__stub___getb67) choke me #else /* Override any gcc2 internal prototype to avoid an error. */ extern char getb67(); getb67(); #endif ; return 0; } EOF if eval $ac_compile; then rm -rf conftest* { test -n "$verbose" && \ echo " defining" CRAY_STACKSEG_END to be "getb67" echo "#define" CRAY_STACKSEG_END "getb67" >> confdefs.h DEFS="$DEFS -DCRAY_STACKSEG_END=getb67" ac_sed_defs="${ac_sed_defs}\${ac_dA}CRAY_STACKSEG_END\${ac_dB}CRAY_STACKSEG_END\${ac_dC}getb67\${ac_dD} \${ac_uA}CRAY_STACKSEG_END\${ac_uB}CRAY_STACKSEG_END\${ac_uC}getb67\${ac_uD} \${ac_eA}CRAY_STACKSEG_END\${ac_eB}CRAY_STACKSEG_END\${ac_eC}getb67\${ac_eD} " } fi rm -f conftest* fi rm -f conftest* fi rm -f conftest* fi rm -f conftest* fi rm -f conftest* if test -n "$ac_alloca_missing"; then # The SVR3 libPW and SVR4 libucb both contain incompatible functions # that cause trouble. Some versions do not even contain alloca or # contain a buggy version. If you still want to use their alloca, # use ar to extract alloca.o from them instead of compiling alloca.c. ALLOCA=alloca.o { test -n "$verbose" && \ echo " defining C_ALLOCA" echo "#define" C_ALLOCA "1" >> confdefs.h DEFS="$DEFS -DC_ALLOCA=1" ac_sed_defs="${ac_sed_defs}\${ac_dA}C_ALLOCA\${ac_dB}C_ALLOCA\${ac_dC}1\${ac_dD} \${ac_uA}C_ALLOCA\${ac_uB}C_ALLOCA\${ac_uC}1\${ac_uD} \${ac_eA}C_ALLOCA\${ac_eB}C_ALLOCA\${ac_eC}1\${ac_eD} " } test -n "$silent" || echo "checking stack direction for C alloca" test -n "$silent" || echo "checking whether cross-compiling" # If we cannot run a trivial program, we must be cross compiling. cat > conftest.${ac_ext} </dev/null; then : else cross_compiling=1 fi rm -fr conftest* if test -n "$cross_compiling" then { test -n "$verbose" && \ echo " defining" STACK_DIRECTION to be "0" echo "#define" STACK_DIRECTION "0" >> confdefs.h DEFS="$DEFS -DSTACK_DIRECTION=0" ac_sed_defs="${ac_sed_defs}\${ac_dA}STACK_DIRECTION\${ac_dB}STACK_DIRECTION\${ac_dC}0\${ac_dD} \${ac_uA}STACK_DIRECTION\${ac_uB}STACK_DIRECTION\${ac_uC}0\${ac_uD} \${ac_eA}STACK_DIRECTION\${ac_eB}STACK_DIRECTION\${ac_eC}0\${ac_eD} " } else cat > conftest.${ac_ext} < addr) ? 1 : -1; } main () { exit (find_stack_direction() < 0); } EOF eval $ac_compile if test -s conftest && (./conftest; exit) 2>/dev/null; then { test -n "$verbose" && \ echo " defining" STACK_DIRECTION to be "1" echo "#define" STACK_DIRECTION "1" >> confdefs.h DEFS="$DEFS -DSTACK_DIRECTION=1" ac_sed_defs="${ac_sed_defs}\${ac_dA}STACK_DIRECTION\${ac_dB}STACK_DIRECTION\${ac_dC}1\${ac_dD} \${ac_uA}STACK_DIRECTION\${ac_uB}STACK_DIRECTION\${ac_uC}1\${ac_uD} \${ac_eA}STACK_DIRECTION\${ac_eB}STACK_DIRECTION\${ac_eC}1\${ac_eD} " } else { test -n "$verbose" && \ echo " defining" STACK_DIRECTION to be "-1" echo "#define" STACK_DIRECTION "-1" >> confdefs.h DEFS="$DEFS -DSTACK_DIRECTION=-1" ac_sed_defs="${ac_sed_defs}\${ac_dA}STACK_DIRECTION\${ac_dB}STACK_DIRECTION\${ac_dC}-1\${ac_dD} \${ac_uA}STACK_DIRECTION\${ac_uB}STACK_DIRECTION\${ac_uC}-1\${ac_uD} \${ac_eA}STACK_DIRECTION\${ac_eB}STACK_DIRECTION\${ac_eC}-1\${ac_eD} " } fi fi rm -fr conftest* fi test -n "$silent" || echo "checking for struct tm in time.h" cat > conftest.${ac_ext} < #include int main() { return 0; } int t() { struct tm *tp; tp->tm_sec;; return 0; } EOF if eval $ac_compile; then : else rm -rf conftest* { test -n "$verbose" && \ echo " defining TM_IN_SYS_TIME" echo "#define" TM_IN_SYS_TIME "1" >> confdefs.h DEFS="$DEFS -DTM_IN_SYS_TIME=1" ac_sed_defs="${ac_sed_defs}\${ac_dA}TM_IN_SYS_TIME\${ac_dB}TM_IN_SYS_TIME\${ac_dC}1\${ac_dD} \${ac_uA}TM_IN_SYS_TIME\${ac_uB}TM_IN_SYS_TIME\${ac_uC}1\${ac_uD} \${ac_eA}TM_IN_SYS_TIME\${ac_eB}TM_IN_SYS_TIME\${ac_eC}1\${ac_eD} " } fi rm -f conftest* test -n "$silent" || echo "checking for whether time.h and sys/time.h may both be included" cat > conftest.${ac_ext} < #include #include int main() { return 0; } int t() { struct tm *tp;; return 0; } EOF if eval $ac_compile; then rm -rf conftest* { test -n "$verbose" && \ echo " defining TIME_WITH_SYS_TIME" echo "#define" TIME_WITH_SYS_TIME "1" >> confdefs.h DEFS="$DEFS -DTIME_WITH_SYS_TIME=1" ac_sed_defs="${ac_sed_defs}\${ac_dA}TIME_WITH_SYS_TIME\${ac_dB}TIME_WITH_SYS_TIME\${ac_dC}1\${ac_dD} \${ac_uA}TIME_WITH_SYS_TIME\${ac_uB}TIME_WITH_SYS_TIME\${ac_uC}1\${ac_uD} \${ac_eA}TIME_WITH_SYS_TIME\${ac_eB}TIME_WITH_SYS_TIME\${ac_eC}1\${ac_eD} " } fi rm -f conftest* ac_decl='#include ' case "$DEFS" in *TM_IN_SYS_TIME*) ac_decl="$ac_decl #include " ;; *) ac_decl="$ac_decl #include " ;; esac test -n "$silent" || echo "checking for tm_zone in struct tm" cat > conftest.${ac_ext} <> confdefs.h DEFS="$DEFS -DHAVE_TM_ZONE=1" ac_sed_defs="${ac_sed_defs}\${ac_dA}HAVE_TM_ZONE\${ac_dB}HAVE_TM_ZONE\${ac_dC}1\${ac_dD} \${ac_uA}HAVE_TM_ZONE\${ac_uB}HAVE_TM_ZONE\${ac_uC}1\${ac_uD} \${ac_eA}HAVE_TM_ZONE\${ac_eB}HAVE_TM_ZONE\${ac_eC}1\${ac_eD} " } else rm -rf conftest* ac_no_tm_zone=1 fi rm -f conftest* if test -n "$ac_no_tm_zone"; then test -n "$silent" || echo "checking for tzname" cat > conftest.${ac_ext} < #ifndef tzname /* For SGI. */ extern char *tzname[]; /* RS6000 and others want it this way. */ #endif int main() { return 0; } int t() { atoi(*tzname);; return 0; } EOF if eval $ac_compile; then rm -rf conftest* { test -n "$verbose" && \ echo " defining HAVE_TZNAME" echo "#define" HAVE_TZNAME "1" >> confdefs.h DEFS="$DEFS -DHAVE_TZNAME=1" ac_sed_defs="${ac_sed_defs}\${ac_dA}HAVE_TZNAME\${ac_dB}HAVE_TZNAME\${ac_dC}1\${ac_dD} \${ac_uA}HAVE_TZNAME\${ac_uB}HAVE_TZNAME\${ac_uC}1\${ac_uD} \${ac_eA}HAVE_TZNAME\${ac_eB}HAVE_TZNAME\${ac_eC}1\${ac_eD} " } fi rm -f conftest* fi test -n "$silent" || echo "checking for directory library header" ac_dir_header= if test -z "$ac_dir_header"; then test -n "$silent" || echo "checking for dirent.h" cat > conftest.${ac_ext} < #include int main() { return 0; } int t() { DIR *dirp = 0;; return 0; } EOF if eval $ac_compile; then rm -rf conftest* { test -n "$verbose" && \ echo " defining DIRENT" echo "#define" DIRENT "1" >> confdefs.h DEFS="$DEFS -DDIRENT=1" ac_sed_defs="${ac_sed_defs}\${ac_dA}DIRENT\${ac_dB}DIRENT\${ac_dC}1\${ac_dD} \${ac_uA}DIRENT\${ac_uB}DIRENT\${ac_uC}1\${ac_uD} \${ac_eA}DIRENT\${ac_eB}DIRENT\${ac_eC}1\${ac_eD} " } ac_dir_header=dirent.h fi rm -f conftest* fi if test -z "$ac_dir_header"; then test -n "$silent" || echo "checking for sys/ndir.h" cat > conftest.${ac_ext} < #include int main() { return 0; } int t() { DIR *dirp = 0;; return 0; } EOF if eval $ac_compile; then rm -rf conftest* { test -n "$verbose" && \ echo " defining SYSNDIR" echo "#define" SYSNDIR "1" >> confdefs.h DEFS="$DEFS -DSYSNDIR=1" ac_sed_defs="${ac_sed_defs}\${ac_dA}SYSNDIR\${ac_dB}SYSNDIR\${ac_dC}1\${ac_dD} \${ac_uA}SYSNDIR\${ac_uB}SYSNDIR\${ac_uC}1\${ac_uD} \${ac_eA}SYSNDIR\${ac_eB}SYSNDIR\${ac_eC}1\${ac_eD} " } ac_dir_header=sys/ndir.h fi rm -f conftest* fi if test -z "$ac_dir_header"; then test -n "$silent" || echo "checking for sys/dir.h" cat > conftest.${ac_ext} < #include int main() { return 0; } int t() { DIR *dirp = 0;; return 0; } EOF if eval $ac_compile; then rm -rf conftest* { test -n "$verbose" && \ echo " defining SYSDIR" echo "#define" SYSDIR "1" >> confdefs.h DEFS="$DEFS -DSYSDIR=1" ac_sed_defs="${ac_sed_defs}\${ac_dA}SYSDIR\${ac_dB}SYSDIR\${ac_dC}1\${ac_dD} \${ac_uA}SYSDIR\${ac_uB}SYSDIR\${ac_uC}1\${ac_uD} \${ac_eA}SYSDIR\${ac_eB}SYSDIR\${ac_eC}1\${ac_eD} " } ac_dir_header=sys/dir.h fi rm -f conftest* fi if test -z "$ac_dir_header"; then test -n "$silent" || echo "checking for ndir.h" cat > conftest.${ac_ext} < #include int main() { return 0; } int t() { DIR *dirp = 0;; return 0; } EOF if eval $ac_compile; then rm -rf conftest* { test -n "$verbose" && \ echo " defining NDIR" echo "#define" NDIR "1" >> confdefs.h DEFS="$DEFS -DNDIR=1" ac_sed_defs="${ac_sed_defs}\${ac_dA}NDIR\${ac_dB}NDIR\${ac_dC}1\${ac_dD} \${ac_uA}NDIR\${ac_uB}NDIR\${ac_uC}1\${ac_uD} \${ac_eA}NDIR\${ac_eB}NDIR\${ac_eC}1\${ac_eD} " } ac_dir_header=ndir.h fi rm -f conftest* fi test -n "$silent" || echo "checking for closedir return value" cat > conftest.${ac_ext} < #include <$ac_dir_header> int closedir(); main() { exit(closedir(opendir(".")) != 0); } EOF eval $ac_compile if test -s conftest && (./conftest; exit) 2>/dev/null; then : else { test -n "$verbose" && \ echo " defining VOID_CLOSEDIR" echo "#define" VOID_CLOSEDIR "1" >> confdefs.h DEFS="$DEFS -DVOID_CLOSEDIR=1" ac_sed_defs="${ac_sed_defs}\${ac_dA}VOID_CLOSEDIR\${ac_dB}VOID_CLOSEDIR\${ac_dC}1\${ac_dD} \${ac_uA}VOID_CLOSEDIR\${ac_uB}VOID_CLOSEDIR\${ac_uC}1\${ac_uD} \${ac_eA}VOID_CLOSEDIR\${ac_eB}VOID_CLOSEDIR\${ac_eC}1\${ac_eD} " } fi rm -fr conftest* test -n "$silent" || echo "checking for Xenix" cat > conftest.${ac_ext} < conftest.out 2>&1" if egrep "yes" conftest.out >/dev/null 2>&1; then rm -rf conftest* XENIX=1 fi rm -f conftest* if test -n "$XENIX"; then LIBS="$LIBS -lx" case "$DEFS" in *SYSNDIR*) ;; *) LIBS="-ldir $LIBS" ;; # Make sure -ldir precedes any -lx. esac fi ac_save_LIBS="${LIBS}" LIBS="${LIBS} -lsun" ac_have_lib="" test -n "$silent" || echo "checking for -lsun" cat > conftest.${ac_ext} < conftest.${ac_ext} < #include #ifdef S_ISBLK #if S_ISBLK (S_IFDIR) You lose. #endif #ifdef S_IFCHR #if S_ISBLK (S_IFCHR) You lose. #endif #endif /* S_IFCHR */ #endif /* S_ISBLK */ #ifdef S_ISLNK #if S_ISLNK (S_IFREG) You lose. #endif #endif /* S_ISLNK */ #ifdef S_ISSOCK #if S_ISSOCK (S_IFREG) You lose. #endif #endif /* S_ISSOCK */ EOF eval "$ac_cpp conftest.${ac_ext} > conftest.out 2>&1" if egrep "You lose" conftest.out >/dev/null 2>&1; then rm -rf conftest* { test -n "$verbose" && \ echo " defining STAT_MACROS_BROKEN" echo "#define" STAT_MACROS_BROKEN "1" >> confdefs.h DEFS="$DEFS -DSTAT_MACROS_BROKEN=1" ac_sed_defs="${ac_sed_defs}\${ac_dA}STAT_MACROS_BROKEN\${ac_dB}STAT_MACROS_BROKEN\${ac_dC}1\${ac_dD} \${ac_uA}STAT_MACROS_BROKEN\${ac_uB}STAT_MACROS_BROKEN\${ac_uC}1\${ac_uD} \${ac_eA}STAT_MACROS_BROKEN\${ac_eB}STAT_MACROS_BROKEN\${ac_eC}1\${ac_eD} " } fi rm -f conftest* # Needed on SysV for shadow passwords. ac_save_LIBS="${LIBS}" LIBS="${LIBS} -lsec" ac_have_lib="" test -n "$silent" || echo "checking for -lsec" cat > conftest.${ac_ext} <> confdefs.h DEFS="$DEFS -DHAVE_LIBSEC=1" ac_sed_defs="${ac_sed_defs}\${ac_dA}HAVE_LIBSEC\${ac_dB}HAVE_LIBSEC\${ac_dC}1\${ac_dD} \${ac_uA}HAVE_LIBSEC\${ac_uB}HAVE_LIBSEC\${ac_uC}1\${ac_uD} \${ac_eA}HAVE_LIBSEC\${ac_eB}HAVE_LIBSEC\${ac_eC}1\${ac_eD} " } LIBS="${LIBS} -lsec" fi # Needed on Linux for shadow passwords. ac_save_LIBS="${LIBS}" LIBS="${LIBS} -lshadow" ac_have_lib="" test -n "$silent" || echo "checking for -lshadow" cat > conftest.${ac_ext} <> confdefs.h DEFS="$DEFS -DHAVE_LIBSHADOW=1" ac_sed_defs="${ac_sed_defs}\${ac_dA}HAVE_LIBSHADOW\${ac_dB}HAVE_LIBSHADOW\${ac_dC}1\${ac_dD} \${ac_uA}HAVE_LIBSHADOW\${ac_uB}HAVE_LIBSHADOW\${ac_uC}1\${ac_uD} \${ac_eA}HAVE_LIBSHADOW\${ac_eB}HAVE_LIBSHADOW\${ac_eC}1\${ac_eD} " } LIBS="${LIBS} -lshadow" fi test -n "$silent" || echo "checking for shadow password routines" echo '#include "confdefs.h" #include ' > conftest.${ac_ext} eval "$ac_cpp conftest.${ac_ext} > conftest.out 2>&1" if egrep "sp_pwdp" conftest.out >/dev/null 2>&1; then rm -rf conftest* test -n "$silent" || echo "checking for getspnam" cat > conftest.${ac_ext} < int main() { return 0; } int t() { /* The GNU C library defines this for functions which it implements to always fail with ENOSYS. Some functions are actually named something starting with __ and the normal name is an alias. */ #if defined (__stub_getspnam) || defined (__stub___getspnam) choke me #else /* Override any gcc2 internal prototype to avoid an error. */ extern char getspnam(); getspnam(); #endif ; return 0; } EOF if eval $ac_compile; then rm -rf conftest* { test -n "$verbose" && \ echo " defining HAVE_SHADOW_H" echo "#define" HAVE_SHADOW_H "1" >> confdefs.h DEFS="$DEFS -DHAVE_SHADOW_H=1" ac_sed_defs="${ac_sed_defs}\${ac_dA}HAVE_SHADOW_H\${ac_dB}HAVE_SHADOW_H\${ac_dC}1\${ac_dD} \${ac_uA}HAVE_SHADOW_H\${ac_uB}HAVE_SHADOW_H\${ac_uC}1\${ac_uD} \${ac_eA}HAVE_SHADOW_H\${ac_eB}HAVE_SHADOW_H\${ac_eC}1\${ac_eD} " } fi rm -f conftest* fi rm -f conftest* # SCO-ODT-3.0 is reported to need this library for crypt. ac_save_LIBS="${LIBS}" LIBS="${LIBS} -lufc" ac_have_lib="" test -n "$silent" || echo "checking for -lufc" cat > conftest.${ac_ext} <> confdefs.h DEFS="$DEFS -DHAVE_LIBUFC=1" ac_sed_defs="${ac_sed_defs}\${ac_dA}HAVE_LIBUFC\${ac_dB}HAVE_LIBUFC\${ac_dC}1\${ac_dD} \${ac_uA}HAVE_LIBUFC\${ac_uB}HAVE_LIBUFC\${ac_uC}1\${ac_uD} \${ac_eA}HAVE_LIBUFC\${ac_eB}HAVE_LIBUFC\${ac_eC}1\${ac_eD} " } LIBS="${LIBS} -lufc" fi # The preferred way to propogate these variables is regular @ substitutions. if test -n "$prefix"; then ac_prsub="s%^prefix\\([ ]*\\)=\\([ ]*\\).*$%prefix\\1=\\2$prefix%" else prefix=/usr/local fi if test -n "$exec_prefix"; then ac_prsub="$ac_prsub s%^exec_prefix\\([ ]*\\)=\\([ ]*\\).*$%exec_prefix\\1=\\2$exec_prefix%" else exec_prefix='${prefix}' # Let make expand it. fi # Any assignment to VPATH causes Sun make to only execute # the first set of double-colon rules, so remove it if not needed. # If there is a colon in the path, we need to keep it. if test "x$srcdir" = x.; then ac_vpsub='/^[ ]*VPATH[ ]*=[^:]*$/d' fi # Quote sed substitution magic chars in DEFS. cat >conftest.def < config.status </dev/null | sed 1q`: # # $0 $configure_args ac_cs_usage="Usage: config.status [--recheck] [--version] [--help]" for ac_option do case "\$ac_option" in -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r) echo running \${CONFIG_SHELL-/bin/sh} $0 $configure_args --no-create exec \${CONFIG_SHELL-/bin/sh} $0 $configure_args --no-create ;; -version | --version | --versio | --versi | --vers | --ver | --ve | --v) echo "config.status generated by autoconf version 1.11" exit 0 ;; -help | --help | --hel | --he | --h) echo "\$ac_cs_usage"; exit 0 ;; *) echo "\$ac_cs_usage"; exit 1 ;; esac done trap 'rm -fr Makefile lib/Makefile src/Makefile man/Makefile config.h conftest*; exit 1' 1 2 15 PROGS='$PROGS' MAN='$MAN' SET_MAKE='$SET_MAKE' CC='$CC' CFLAGS='$CFLAGS' LDFLAGS='$LDFLAGS' CPP='$CPP' INSTALL='$INSTALL' INSTALL_PROGRAM='$INSTALL_PROGRAM' INSTALL_DATA='$INSTALL_DATA' RANLIB='$RANLIB' YACC='$YACC' LIBOBJS='$LIBOBJS' ALLOCA='$ALLOCA' LIBS='$LIBS' srcdir='$srcdir' top_srcdir='$top_srcdir' prefix='$prefix' exec_prefix='$exec_prefix' ac_prsub='$ac_prsub' ac_vpsub='$ac_vpsub' extrasub='$extrasub' EOF cat >> config.status <<\EOF ac_given_srcdir=$srcdir CONFIG_FILES=${CONFIG_FILES-"Makefile lib/Makefile src/Makefile man/Makefile"} for ac_file in .. ${CONFIG_FILES}; do if test "x$ac_file" != x..; then # Remove last slash and all that follows it. Not all systems have dirname. ac_dir=`echo $ac_file|sed 's%/[^/][^/]*$%%'` if test "$ac_dir" != "$ac_file" && test "$ac_dir" != .; then # The file is in a subdirectory. test ! -d "$ac_dir" && mkdir "$ac_dir" ac_dir_suffix="/$ac_dir" else ac_dir_suffix= fi # A "../" for each directory in $ac_dir_suffix. ac_dots=`echo $ac_dir_suffix|sed 's%/[^/]*%../%g'` case "$ac_given_srcdir" in .) srcdir=. if test -z "$ac_dir_suffix"; then top_srcdir=. else top_srcdir=`echo $ac_dots|sed 's%/$%%'`; fi ;; /*) srcdir="$ac_given_srcdir$ac_dir_suffix"; top_srcdir="$ac_given_srcdir" ;; *) # Relative path. srcdir="$ac_dots$ac_given_srcdir$ac_dir_suffix" top_srcdir="$ac_dots$ac_given_srcdir" ;; esac echo creating "$ac_file" rm -f "$ac_file" comment_str="Generated automatically from `echo $ac_file|sed 's|.*/||'`.in by configure." case "$ac_file" in *.c | *.h | *.C | *.cc | *.m ) echo "/* $comment_str */" > "$ac_file" ;; * ) echo "# $comment_str" > "$ac_file" ;; esac sed -e " $ac_prsub $ac_vpsub $extrasub s%@PROGS@%$PROGS%g s%@MAN@%$MAN%g s%@SET_MAKE@%$SET_MAKE%g s%@CC@%$CC%g s%@CFLAGS@%$CFLAGS%g s%@LDFLAGS@%$LDFLAGS%g s%@CPP@%$CPP%g s%@INSTALL@%$INSTALL%g s%@INSTALL_PROGRAM@%$INSTALL_PROGRAM%g s%@INSTALL_DATA@%$INSTALL_DATA%g s%@RANLIB@%$RANLIB%g s%@YACC@%$YACC%g s%@LIBOBJS@%$LIBOBJS%g s%@ALLOCA@%$ALLOCA%g s%@LIBS@%$LIBS%g s%@srcdir@%$srcdir%g s%@top_srcdir@%$top_srcdir%g s%@prefix@%$prefix%g s%@exec_prefix@%$exec_prefix%g s%@DEFS@%-DHAVE_CONFIG_H%" $ac_given_srcdir/${ac_file}.in >> $ac_file fi; done # These sed commands are put into ac_sed_defs when defining a macro. # They are broken into pieces to make the sed script easier to manage. # They are passed to sed as "A NAME B NAME C VALUE D", where NAME # is the cpp macro being defined and VALUE is the value it is being given. # Each defining turns into a single global substitution command. # Hopefully no one uses "!" as a variable value. # Other candidates for the sed separators, like , and @, do get used. # # ac_d sets the value in "#define NAME VALUE" lines. ac_dA='s!^\([ ]*\)#\([ ]*define[ ][ ]*\)' ac_dB='\([ ][ ]*\)[^ ]*!\1#\2' ac_dC='\3' ac_dD='!g' # ac_u turns "#undef NAME" with trailing blanks into "#define NAME VALUE". ac_uA='s!^\([ ]*\)#\([ ]*\)undef\([ ][ ]*\)' ac_uB='\([ ]\)!\1#\2define\3' ac_uC=' ' ac_uD='\4!g' # ac_e turns "#undef NAME" without trailing blanks into "#define NAME VALUE". ac_eA='s!^\([ ]*\)#\([ ]*\)undef\([ ][ ]*\)' ac_eB='$!\1#\2define\3' ac_eC=' ' ac_eD='!g' rm -f conftest.sed EOF # Turn off quoting long enough to insert the sed commands. rm -f conftest.sh cat > conftest.sh < conftest.s1 # Like head -9. sed 1,${ac_max_sh_lines}d conftest.sh > conftest.s2 # Like tail +10. # Write a limited-size here document to append to conftest.sed. echo 'cat >> conftest.sed <> config.status cat conftest.s1 >> config.status echo 'CONFEOF' >> config.status rm -f conftest.s1 conftest.sh mv conftest.s2 conftest.sh done rm -f conftest.sh # Now back to your regularly scheduled config.status. cat >> config.status <<\EOF # This sed command replaces #undef's with comments. This is necessary, for # example, in the case of _POSIX_SOURCE, which is predefined and required # on some systems where configure will not decide to define it in # config.h. cat >> conftest.sed <<\CONFEOF s,^[ ]*#[ ]*undef[ ][ ]*[a-zA-Z_][a-zA-Z_0-9]*,/* & */, CONFEOF rm -f conftest.h # Break up the sed commands because old seds have small limits. ac_max_sed_lines=20 CONFIG_HEADERS=${CONFIG_HEADERS-"config.h"} for ac_file in .. ${CONFIG_HEADERS}; do if test "x$ac_file" != x..; then echo creating $ac_file cp $ac_given_srcdir/$ac_file.in conftest.h1 cp conftest.sed conftest.stm while : do ac_lines=`grep -c . conftest.stm` if test -z "$ac_lines" || test "$ac_lines" -eq 0; then break; fi rm -f conftest.s1 conftest.s2 conftest.h2 sed ${ac_max_sed_lines}q conftest.stm > conftest.s1 # Like head -20. sed 1,${ac_max_sed_lines}d conftest.stm > conftest.s2 # Like tail +21. sed -f conftest.s1 < conftest.h1 > conftest.h2 rm -f conftest.s1 conftest.h1 conftest.stm mv conftest.h2 conftest.h1 mv conftest.s2 conftest.stm done rm -f conftest.stm conftest.h echo "/* $ac_file. Generated automatically by configure. */" > conftest.h cat conftest.h1 >> conftest.h rm -f conftest.h1 if cmp -s $ac_file conftest.h 2>/dev/null; then # The file exists and we would not be changing it. echo "$ac_file is unchanged" rm -f conftest.h else rm -f $ac_file mv conftest.h $ac_file fi fi; done rm -f conftest.sed # Makefile uses this timestamp file to record whether config.h is up to date. touch stamp-config exit 0 EOF chmod +x config.status # Some shells look in PATH for config.status without the "./". test -n "$no_create" || ${CONFIG_SHELL-/bin/sh} ./config.status sh-utils-1.10/configure.in100644 74504 1 10767 5566703627 15107 0ustar meyeringdaemondnl Process this file with autoconf to produce a configure script. AC_INIT(src/stty.c) AC_CONFIG_HEADER(config.h) AC_SUBST(PROGS)dnl AC_SUBST(MAN)dnl AC_SET_MAKE # We want these before the checks, so the checks can modify their values. test -z "$CFLAGS" && CFLAGS=-g auto_cflags=1 AC_PROG_CC # If we're using gcc and the user hasn't specified CFLAGS, add -O to CFLAGS. test -n "$GCC" && test -n "$auto_cflags" && CFLAGS="$CFLAGS -O" AC_SUBST(CFLAGS)dnl AC_SUBST(LDFLAGS)dnl AC_PROG_CPP AC_GCC_TRADITIONAL AC_PROG_INSTALL case "$INSTALL" in \./install\.sh*) INSTALL=".$INSTALL" ; AC_VERBOSE(adjusting INSTALL to $INSTALL) ;; *) ;; esac AC_PROG_RANLIB AC_PROG_YACC AC_AIX AC_MINIX AC_ISC_POSIX AC_SCO_INTL AC_FUNC_CHECK(uname, PROGS="$PROGS uname" MAN="$MAN uname.1" have_uname=1) AC_CONST AC_STDC_HEADERS AC_HAVE_FUNCS(strerror ftime memcpy bcopy gettimeofday syslog initgroups \ isascii sethostname sysinfo) # This check must be performed before HAVE_SYSLOG_H can be defined. case "$DEFS" in *-DHAVE_SYSLOG*) ;; *) # syslog is not in the default libraries. See if it's in some other. saved_LIBS="$LIBS" for lib in bsd socket inet; do AC_CHECKING(for syslog in -l$lib) LIBS="$saved_LIBS -l$lib" AC_HAVE_FUNCS(syslog) case "$DEFS" in *-DHAVE_SYSLOG*) break ;; *) ;; esac LIBS="$saved_LIBS" done ;; esac # SCO-ODT-3.0 is reported to need -los to link programs using initgroups case "$DEFS" in *-DHAVE_INITGROUPS*) ;; *) # initgroups is not in the default libraries. See if it's in some other. saved_LIBS="$LIBS" for lib in os; do AC_CHECKING(for initgroups in -l$lib) LIBS="$saved_LIBS -l$lib" AC_HAVE_FUNCS(initgroups) case "$DEFS" in *-DHAVE_INITGROUPS*) break ;; *) ;; esac LIBS="$saved_LIBS" done ;; esac AC_HAVE_HEADERS(string.h fcntl.h limits.h syslog.h sys/time.h unistd.h \ sys/timeb.h float.h sys/systeminfo.h) AC_UID_T AC_GETGROUPS_T AC_SIZE_T AC_REPLACE_FUNCS(gethostname getusershell memcmp mktime stime \ strcspn strstr strtol strtoul strtod) case "$LIBOBJS" in *memcmp*) ;; *) AC_CHECKING(whether memcmp is 8-bit clean) AC_TEST_PROGRAM([ main() { char c0 = 0x40, c1 = 0x80, c2 = 0x81; exit(memcmp(&c0, &c2, 1) < 0 && memcmp(&c1, &c2, 1) < 0 ? 0 : 1); } ],[ AC_VERBOSE(memcmp is 8-bit clean) ],[ AC_WARN(memcmp is NOT 8-bit clean -- using replacement) LIBOBJS="$LIBOBJS memcmp.o" ]) ;; esac AC_COMPILE_CHECK(setpriority, [#include #include ], [setpriority(0, 0, 0);], PROGS="$PROGS nice nohup" MAN="$MAN nice.1 nohup.1") case "$PROGS" in *nice*) ;; *) AC_COMPILE_CHECK(nice, , nice();, AC_DEFINE(NICE_PRIORITY) PROGS="$PROGS nice nohup" MAN="$MAN nice.1 nohup.1") ;; esac case "$LIBOBJS" in *gethostname*) test -n "$have_uname" && AC_DEFINE(HAVE_UNAME) ;; esac AC_COMPILE_CHECK(ut_host in struct utmp, [#include #include ], [struct utmp ut; ut.ut_host;], AC_DEFINE(HAVE_UT_HOST)) case "$DEFS" in *HAVE_UT_HOST*) ;; *) AC_COMPILE_CHECK(ut_host in struct utmpx, [#include #include ], [struct utmpx ut; ut.ut_host;], AC_DEFINE(HAVE_UTMPX_H) AC_DEFINE(HAVE_UT_HOST)) ;; esac AC_COMPILE_CHECK(POSIX termios, [#include #include #include ], [/* SunOS 4.0.3 has termios.h but not the library calls. */ tcgetattr(0, 0);], have_termios=1) if test -n "$have_termios"; then PROGS="$PROGS stty" MAN="$MAN stty.1" AC_COMPILE_CHECK(c_line in struct termios, [#include #include ], [struct termios t; t.c_line;], AC_DEFINE(HAVE_C_LINE)) AC_COMPILE_CHECK(TIOCGWINSZ in termios.h, [#include #include ], [int x = TIOCGWINSZ;], have_tiocgwinsz=1) fi if test -z "$have_tiocgwinsz"; then AC_COMPILE_CHECK(TIOCGWINSZ in sys/ioctl.h, [#include #include ], [int x = TIOCGWINSZ;], AC_DEFINE(GWINSZ_IN_SYS_IOCTL)) fi AC_HEADER_CHECK([sys/ptem.h], AC_DEFINE(WINSIZE_IN_PTEM)) AC_VPRINTF AC_ALLOCA AC_STRUCT_TM AC_TIME_WITH_SYS_TIME AC_TIMEZONE AC_XENIX_DIR AC_IRIX_SUN AC_STAT_MACROS_BROKEN # Needed on SysV for shadow passwords. AC_HAVE_LIBRARY(sec) # Needed on Linux for shadow passwords. AC_HAVE_LIBRARY(shadow) AC_CHECKING(for shadow password routines) AC_HEADER_EGREP(sp_pwdp, shadow.h, AC_FUNC_CHECK(getspnam, AC_DEFINE(HAVE_SHADOW_H))) # SCO-ODT-3.0 is reported to need this library for crypt. AC_HAVE_LIBRARY(ufc) AC_OUTPUT(Makefile lib/Makefile src/Makefile man/Makefile, [ # Makefile uses this timestamp file to record whether config.h is up to date. touch stamp-config]) sh-utils-1.10/config.h.in100666 74504 1 11717 5566753660 14623 0ustar meyeringdaemon/* config.h.in. Generated automatically from configure.in by autoheader. */ /* Define if on AIX 3. System headers sometimes define this. We just want to avoid a redefinition error message. */ #ifndef _ALL_SOURCE #undef _ALL_SOURCE #endif /* Define if using alloca.c. */ #undef C_ALLOCA /* Define to empty if the keyword does not work. */ #undef const /* Define to one of _getb67, GETB67, getb67 for Cray-2 and Cray-YMP systems. This function is required for alloca.c support on those systems. */ #undef CRAY_STACKSEG_END /* Define if you have dirent.h. */ #undef DIRENT /* Define to the type of elements in the array set by `getgroups'. Usually this is either `int' or `gid_t'. */ #undef GETGROUPS_T /* Define to `int' if doesn't define. */ #undef gid_t /* Define if you have alloca.h and it should be used (not Ultrix). */ #undef HAVE_ALLOCA_H /* Define if you don't have vprintf but do have _doprnt. */ #undef HAVE_DOPRNT /* Define if your struct tm has tm_zone. */ #undef HAVE_TM_ZONE /* Define if you don't have tm_zone but do have the external array tzname. */ #undef HAVE_TZNAME /* Define if you have the vprintf function. */ #undef HAVE_VPRINTF /* Define if on MINIX. */ #undef _MINIX /* Define if you don't have dirent.h, but have ndir.h. */ #undef NDIR /* Define if the system does not provide POSIX.1 features except with this defined. */ #undef _POSIX_1_SOURCE /* Define if you need to in order for stat and other things to work. */ #undef _POSIX_SOURCE /* Define to `unsigned' if doesn't define. */ #undef size_t /* If using the C implementation of alloca, define if you know the direction of stack growth for your system; otherwise it will be automatically deduced at run-time. STACK_DIRECTION > 0 => grows toward higher addresses STACK_DIRECTION < 0 => grows toward lower addresses STACK_DIRECTION = 0 => direction of growth unknown */ #undef STACK_DIRECTION /* Define if the `S_IS*' macros in do not work properly. */ #undef STAT_MACROS_BROKEN /* Define if you have the ANSI C header files. */ #undef STDC_HEADERS /* Define if you don't have dirent.h, but have sys/dir.h. */ #undef SYSDIR /* Define if you don't have dirent.h, but have sys/ndir.h. */ #undef SYSNDIR /* Define if you can safely include both and . */ #undef TIME_WITH_SYS_TIME /* Define if your declares struct tm. */ #undef TM_IN_SYS_TIME /* Define to `int' if doesn't define. */ #undef uid_t /* Define if the closedir function returns void instead of int. */ #undef VOID_CLOSEDIR /* Define if your system defines TIOCGWINSZ in sys/ioctl.h. */ #undef GWINSZ_IN_SYS_IOCTL /* Define if your system's definition of `struct termios' has a member named c_line. */ #undef HAVE_C_LINE /* Define if your system has SysV shadow passwords and the shadow.h header. */ #undef HAVE_SHADOW_H /* Define if your system lacks gethostname but has the uname system call. */ #undef HAVE_UNAME /* Define if your system's struct utmp has a member named ut_host. */ #undef HAVE_UT_HOST /* Define if you have the header file. */ #undef HAVE_UTMPX_H /* Define if your system lacks the getpriority and setpriority system calls, but has `nice' instead. */ #undef NICE_PRIORITY /* Define if your system defines `struct winsize' in sys/ptem.h. */ #undef WINSIZE_IN_PTEM /* Define if you have bcopy. */ #undef HAVE_BCOPY /* Define if you have ftime. */ #undef HAVE_FTIME /* Define if you have gettimeofday. */ #undef HAVE_GETTIMEOFDAY /* Define if you have initgroups. */ #undef HAVE_INITGROUPS /* Define if you have isascii. */ #undef HAVE_ISASCII /* Define if you have memcpy. */ #undef HAVE_MEMCPY /* Define if you have sethostname. */ #undef HAVE_SETHOSTNAME /* Define if you have strerror. */ #undef HAVE_STRERROR /* Define if you have sysinfo. */ #undef HAVE_SYSINFO /* Define if you have syslog. */ #undef HAVE_SYSLOG /* Define if you have the header file. */ #undef HAVE_FCNTL_H /* Define if you have the header file. */ #undef HAVE_FLOAT_H /* Define if you have the header file. */ #undef HAVE_LIMITS_H /* Define if you have the header file. */ #undef HAVE_STRING_H /* Define if you have the header file. */ #undef HAVE_SYS_SYSTEMINFO_H /* Define if you have the header file. */ #undef HAVE_SYS_TIME_H /* Define if you have the header file. */ #undef HAVE_SYS_TIMEB_H /* Define if you have the header file. */ #undef HAVE_SYSLOG_H /* Define if you have the header file. */ #undef HAVE_UNISTD_H /* Define if you have the intl library (-lintl). */ #undef HAVE_LIBINTL /* Define if you have the sec library (-lsec). */ #undef HAVE_LIBSEC /* Define if you have the shadow library (-lshadow). */ #undef HAVE_LIBSHADOW /* Define if you have the sun library (-lsun). */ #undef HAVE_LIBSUN /* Define if you have the ufc library (-lufc). */ #undef HAVE_LIBUFC sh-utils-1.10/acconfig.h100644 74504 13 3137 5476303557 14225 0ustar meyeringuser/* acconfig.h This file is in the public domain. Descriptive text for the C preprocessor macros that the distributed Autoconf macros can define. No software package will use all of them; autoheader copies the ones your configure.in uses into your configuration header file templates. The entries are in sort -df order: alphabetical, case insensitive, ignoring punctuation (such as underscores). Although this order can split up related entries, it makes it easier to check whether a given entry is in the file. Leave the following blank line there!! Autoheader needs it. */ /* Define if your system defines TIOCGWINSZ in sys/ioctl.h. */ #undef GWINSZ_IN_SYS_IOCTL /* Define if your system's definition of `struct termios' has a member named c_line. */ #undef HAVE_C_LINE /* Define if your system has SysV shadow passwords and the shadow.h header. */ #undef HAVE_SHADOW_H /* Define if your system lacks gethostname but has the uname system call. */ #undef HAVE_UNAME /* Define if your system's struct utmp has a member named ut_host. */ #undef HAVE_UT_HOST /* Define if you have the header file. */ #undef HAVE_UTMPX_H /* Define if your system lacks the getpriority and setpriority system calls, but has `nice' instead. */ #undef NICE_PRIORITY /* Define if your system defines `struct winsize' in sys/ptem.h. */ #undef WINSIZE_IN_PTEM /* Leave that blank line there!! Autoheader needs it. If you're adding to this file, keep in mind: The entries are in sort -df order: alphabetical, case insensitive, ignoring punctuation (such as underscores). */ sh-utils-1.10/mkinstalldirs100555 21570 1 1211 5544731612 14257 0ustar djmdaemon#!/bin/sh # mkinstalldirs --- make directory hierarchy # Author: Noah Friedman # Created: 1993-05-16 # Last modified: 1994-03-25 # Public domain errstatus=0 for file in ${1+"$@"} ; do set fnord `echo ":$file" | sed -ne 's/^:\//#/;s/^://;s/\// /g;s/^#/\//;p'` shift pathcomp= for d in ${1+"$@"} ; do pathcomp="$pathcomp$d" case "$pathcomp" in -* ) pathcomp=./$pathcomp ;; esac if test ! -d "$pathcomp"; then echo "mkdir $pathcomp" 1>&2 mkdir "$pathcomp" || errstatus=$? fi pathcomp="$pathcomp/" done done exit $errstatus # mkinstalldirs ends here sh-utils-1.10/install.sh100555 21570 1 11065 5557534416 13515 0ustar djmdaemon#!/bin/sh # # install - install a program, script, or datafile # This comes from X11R5. # # $XConsortium: install.sh,v 1.2 89/12/18 14:47:22 jim Exp $ # # This script is compatible with the BSD install script, but was written # from scratch. # # set DOITPROG to echo to test this script # Don't use :- since 4.3BSD and earlier shells don't like it. doit="${DOITPROG-}" # put in absolute paths if you don't have them in your path; or use env. vars. mvprog="${MVPROG-mv}" cpprog="${CPPROG-cp}" chmodprog="${CHMODPROG-chmod}" chownprog="${CHOWNPROG-chown}" chgrpprog="${CHGRPPROG-chgrp}" stripprog="${STRIPPROG-strip}" rmprog="${RMPROG-rm}" mkdirprog="${MKDIRPROG-mkdir}" tranformbasename="" transform_arg="" instcmd="$mvprog" chmodcmd="$chmodprog 0755" chowncmd="" chgrpcmd="" stripcmd="" rmcmd="$rmprog -f" mvcmd="$mvprog" src="" dst="" dir_arg="" while [ x"$1" != x ]; do case $1 in -c) instcmd="$cpprog" shift continue;; -d) dir_arg=true shift continue;; -m) chmodcmd="$chmodprog $2" shift shift continue;; -o) chowncmd="$chownprog $2" shift shift continue;; -g) chgrpcmd="$chgrpprog $2" shift shift continue;; -s) stripcmd="$stripprog" shift continue;; -t=*) transformarg=`echo $1 | sed 's/-t=//'` shift continue;; -b=*) transformbasename=`echo $1 | sed 's/-b=//'` shift continue;; *) if [ x"$src" = x ] then src=$1 else # this colon is to work around a 386BSD /bin/sh bug : dst=$1 fi shift continue;; esac done if [ x"$src" = x ] then echo "install: no input file specified" exit 1 else true fi if [ x"$dir_arg" != x ]; then dst=$src src="" if [ -d $dst ]; then instcmd=: else instcmd=mkdir fi else # Waiting for this to be detected by the "$instcmd $src $dsttmp" command # might cause directories to be created, which would be especially bad # if $src (and thus $dsttmp) contains '*'. if [ -f $src -o -d $src ] then true else echo "install: $src does not exist" exit 1 fi if [ x"$dst" = x ] then echo "install: no destination specified" exit 1 else true fi # If destination is a directory, append the input filename; if your system # does not like double slashes in filenames, you may need to add some logic if [ -d $dst ] then dst="$dst"/`basename $src` else true fi fi ## this sed command emulates the dirname command dstdir=`echo $dst | sed -e 's,[^/]*$,,;s,/$,,;s,^$,.,'` # Make sure that the destination directory exists. # this part is taken from Noah Friedman's mkinstalldirs script # Skip lots of stat calls in the usual case. if [ ! -d "$dstdir" ]; then defaultIFS=' ' IFS="${IFS-${defaultIFS}}" oIFS="${IFS}" # Some sh's can't handle IFS=/ for some reason. IFS='%' set - `echo ${dstdir} | sed -e 's@/@%@g' -e 's@^%@/@'` IFS="${oIFS}" pathcomp='' while [ $# -ne 0 ] ; do pathcomp="${pathcomp}${1}" shift if [ ! -d "${pathcomp}" ] ; then $mkdirprog "${pathcomp}" else true fi pathcomp="${pathcomp}/" done fi if [ x"$dir_arg" != x ] then $doit $instcmd $dst && if [ x"$chowncmd" != x ]; then $doit $chowncmd $dst; else true ; fi && if [ x"$chgrpcmd" != x ]; then $doit $chgrpcmd $dst; else true ; fi && if [ x"$stripcmd" != x ]; then $doit $stripcmd $dst; else true ; fi && if [ x"$chmodcmd" != x ]; then $doit $chmodcmd $dst; else true ; fi else # If we're going to rename the final executable, determine the name now. if [ x"$transformarg" = x ] then dstfile=`basename $dst` else dstfile=`basename $dst $transformbasename | sed $transformarg`$transformbasename fi # don't allow the sed command to completely eliminate the filename if [ x"$dstfile" = x ] then dstfile=`basename $dst` else true fi # Make a temp file name in the proper directory. dsttmp=$dstdir/#inst.$$# # Move or copy the file name to the temp name $doit $instcmd $src $dsttmp && trap "rm -f ${dsttmp}" 0 && # and set any options; do chmod last to preserve setuid bits # If any of these fail, we abort the whole thing. If we want to # ignore errors from any of these, just make sure not to ignore # errors from the above "$doit $instcmd $src $dsttmp" command. if [ x"$chowncmd" != x ]; then $doit $chowncmd $dsttmp; else true;fi && if [ x"$chgrpcmd" != x ]; then $doit $chgrpcmd $dsttmp; else true;fi && if [ x"$stripcmd" != x ]; then $doit $stripcmd $dsttmp; else true;fi && if [ x"$chmodcmd" != x ]; then $doit $chmodcmd $dsttmp; else true;fi && # Now rename the file to the real destination. $doit $rmcmd -f $dstdir/$dstfile && $doit $mvcmd $dsttmp $dstdir/$dstfile fi && exit 0 sh-utils-1.10/lib/ 40777 74504 1 0 5566761472 13222 5ustar meyeringdaemonsh-utils-1.10/lib/Makefile.in100666 74504 1 5761 5566761045 15371 0ustar meyeringdaemon# Makefile for library files used by GNU shell utilities. # Copyright (C) 1991, 1992, 1993, 1994 Free Software Foundation, Inc. # 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 2, 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, write to the Free Software # Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. SHELL = /bin/sh srcdir = @srcdir@ VPATH = @srcdir@ CC = @CC@ AR = ar RANLIB = @RANLIB@ DEFS = -DCONFIG_BROKETS @DEFS@ CFLAGS = @CFLAGS@ YACC = @YACC@ SOURCES = regex.c getdate.y basename.c error.c stripslash.c xmalloc.c \ xstrdup.c full-write.c putenv.c getopt.c getopt1.c getugroups.c \ posixtm.y strftime.c gethostname.c getusershell.c memcmp.c mktime.c stime.c \ strcspn.c strstr.c strtol.c strtoul.c strtod.c alloca.c xgetcwd.c \ xgethostname.c OBJECTS = regex.o getdate.o posixtm.o strftime.o basename.o error.o \ stripslash.o xmalloc.o xgetcwd.o xgethostname.o \ xstrdup.o full-write.o putenv.o getopt.o getopt1.o getugroups.o \ @LIBOBJS@ @ALLOCA@ DISTFILES = Makefile.in getopt.h regex.h pathmax.h \ getdate.c posixtm.c $(SOURCES) all: libshu.a .c.o: $(CC) -c $(CPPFLAGS) $(DEFS) -I.. -I$(srcdir) $(CFLAGS) $< Makefile: ../config.status Makefile.in CONFIG_FILES=$@ CONFIG_HEADERS= ../config.status install: all uninstall: TAGS: $(SOURCES) etags $(SOURCES) check: clean: rm -f *.a *.o mostlyclean: clean distclean: clean rm -f Makefile *.tab.c getdate.c *posixtm.c realclean: distclean rm -f TAGS dist: $(DISTFILES) for file in $(DISTFILES); do \ ln $$file ../`cat ../.fname`/lib \ || cp -p $$file ../`cat ../.fname`/lib; \ done libshu.a: $(OBJECTS) rm -f $@ $(AR) cr $@ $(OBJECTS) -$(RANLIB) $@ # Since this directory contains two parsers, we have to be careful to avoid # running two $(YACC)s during parallel makes. See below. getdate.c: getdate.y @echo expect 10 shift/reduce conflicts $(YACC) $(srcdir)/getdate.y mv y.tab.c getdate.c # Make the rename atomic, in case sed is interrupted and later rerun. # The artificial dependency on getdate.c keeps the two parsers from being # built in parallel. Enforcing this little bit of sequentiality lets # everyone (even those without bison) still run mostly parallel builds. posixtm.c: posixtm.y getdate.c $(YACC) $(srcdir)/posixtm.y mv y.tab.c posixtm.tab.c sed -e 's/yy/zz/g' posixtm.tab.c > tposixtm.c mv tposixtm.c posixtm.c rm -f posixtm.tab.c getopt1.o: getopt.h regex.o: regex.h $(OBJECTS): ../config.h # Tell versions [3.59,3.63) of GNU make not to export all variables. # Otherwise a system limit (for SysV at least) may be exceeded. .NOEXPORT: sh-utils-1.10/lib/getopt.h100555 21570 1 10474 5563566471 13742 0ustar djmdaemon/* Declarations for getopt. Copyright (C) 1989, 1990, 1991, 1992, 1993 Free Software Foundation, Inc. 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 2, 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, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ #ifndef _GETOPT_H #define _GETOPT_H 1 #ifdef __cplusplus extern "C" { #endif /* For communication from `getopt' to the caller. When `getopt' finds an option that takes an argument, the argument value is returned here. Also, when `ordering' is RETURN_IN_ORDER, each non-option ARGV-element is returned here. */ extern char *optarg; /* Index in ARGV of the next element to be scanned. This is used for communication to and from the caller and for communication between successive calls to `getopt'. On entry to `getopt', zero means this is the first call; initialize. When `getopt' returns EOF, this is the index of the first of the non-option elements that the caller should itself scan. Otherwise, `optind' communicates from one call to the next how much of ARGV has been scanned so far. */ extern int optind; /* Callers store zero here to inhibit the error message `getopt' prints for unrecognized options. */ extern int opterr; /* Set to an option character which was unrecognized. */ extern int optopt; /* Describe the long-named options requested by the application. The LONG_OPTIONS argument to getopt_long or getopt_long_only is a vector of `struct option' terminated by an element containing a name which is zero. The field `has_arg' is: no_argument (or 0) if the option does not take an argument, required_argument (or 1) if the option requires an argument, optional_argument (or 2) if the option takes an optional argument. If the field `flag' is not NULL, it points to a variable that is set to the value given in the field `val' when the option is found, but left unchanged if the option is not found. To have a long-named option do something other than set an `int' to a compiled-in constant, such as set a value from `optarg', set the option's `flag' field to zero and its `val' field to a nonzero value (the equivalent single-letter option character, if there is one). For long options that have a zero `flag' field, `getopt' returns the contents of the `val' field. */ struct option { #if __STDC__ const char *name; #else char *name; #endif /* has_arg can't be an enum because some compilers complain about type mismatches in all the code that assumes it is an int. */ int has_arg; int *flag; int val; }; /* Names for the values of the `has_arg' field of `struct option'. */ #define no_argument 0 #define required_argument 1 #define optional_argument 2 #if __STDC__ #if defined(__GNU_LIBRARY__) /* Many other libraries have conflicting prototypes for getopt, with differences in the consts, in stdlib.h. To avoid compilation errors, only prototype getopt for the GNU C library. */ extern int getopt (int argc, char *const *argv, const char *shortopts); #else /* not __GNU_LIBRARY__ */ extern int getopt (); #endif /* not __GNU_LIBRARY__ */ extern int getopt_long (int argc, char *const *argv, const char *shortopts, const struct option *longopts, int *longind); extern int getopt_long_only (int argc, char *const *argv, const char *shortopts, const struct option *longopts, int *longind); /* Internal only. Users should not call this directly. */ extern int _getopt_internal (int argc, char *const *argv, const char *shortopts, const struct option *longopts, int *longind, int long_only); #else /* not __STDC__ */ extern int getopt (); extern int getopt_long (); extern int getopt_long_only (); extern int _getopt_internal (); #endif /* not __STDC__ */ #ifdef __cplusplus } #endif #endif /* _GETOPT_H */ sh-utils-1.10/lib/regex.h100666 12241 1 44406 5401254205 14233 0ustar rolanddaemon/* Definitions for data structures and routines for the regular expression library, version 0.12. Copyright (C) 1985, 89, 90, 91, 92, 1993 Free Software Foundation, Inc. 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 2, 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, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #ifndef __REGEXP_LIBRARY_H__ #define __REGEXP_LIBRARY_H__ /* POSIX says that must be included (by the caller) before . */ #ifdef VMS /* VMS doesn't have `size_t' in , even though POSIX says it should be there. */ #include #endif /* The following bits are used to determine the regexp syntax we recognize. The set/not-set meanings are chosen so that Emacs syntax remains the value 0. The bits are given in alphabetical order, and the definitions shifted by one from the previous bit; thus, when we add or remove a bit, only one other definition need change. */ typedef unsigned reg_syntax_t; /* If this bit is not set, then \ inside a bracket expression is literal. If set, then such a \ quotes the following character. */ #define RE_BACKSLASH_ESCAPE_IN_LISTS (1) /* If this bit is not set, then + and ? are operators, and \+ and \? are literals. If set, then \+ and \? are operators and + and ? are literals. */ #define RE_BK_PLUS_QM (RE_BACKSLASH_ESCAPE_IN_LISTS << 1) /* If this bit is set, then character classes are supported. They are: [:alpha:], [:upper:], [:lower:], [:digit:], [:alnum:], [:xdigit:], [:space:], [:print:], [:punct:], [:graph:], and [:cntrl:]. If not set, then character classes are not supported. */ #define RE_CHAR_CLASSES (RE_BK_PLUS_QM << 1) /* If this bit is set, then ^ and $ are always anchors (outside bracket expressions, of course). If this bit is not set, then it depends: ^ is an anchor if it is at the beginning of a regular expression or after an open-group or an alternation operator; $ is an anchor if it is at the end of a regular expression, or before a close-group or an alternation operator. This bit could be (re)combined with RE_CONTEXT_INDEP_OPS, because POSIX draft 11.2 says that * etc. in leading positions is undefined. We already implemented a previous draft which made those constructs invalid, though, so we haven't changed the code back. */ #define RE_CONTEXT_INDEP_ANCHORS (RE_CHAR_CLASSES << 1) /* If this bit is set, then special characters are always special regardless of where they are in the pattern. If this bit is not set, then special characters are special only in some contexts; otherwise they are ordinary. Specifically, * + ? and intervals are only special when not after the beginning, open-group, or alternation operator. */ #define RE_CONTEXT_INDEP_OPS (RE_CONTEXT_INDEP_ANCHORS << 1) /* If this bit is set, then *, +, ?, and { cannot be first in an re or immediately after an alternation or begin-group operator. */ #define RE_CONTEXT_INVALID_OPS (RE_CONTEXT_INDEP_OPS << 1) /* If this bit is set, then . matches newline. If not set, then it doesn't. */ #define RE_DOT_NEWLINE (RE_CONTEXT_INVALID_OPS << 1) /* If this bit is set, then . doesn't match NUL. If not set, then it does. */ #define RE_DOT_NOT_NULL (RE_DOT_NEWLINE << 1) /* If this bit is set, nonmatching lists [^...] do not match newline. If not set, they do. */ #define RE_HAT_LISTS_NOT_NEWLINE (RE_DOT_NOT_NULL << 1) /* If this bit is set, either \{...\} or {...} defines an interval, depending on RE_NO_BK_BRACES. If not set, \{, \}, {, and } are literals. */ #define RE_INTERVALS (RE_HAT_LISTS_NOT_NEWLINE << 1) /* If this bit is set, +, ? and | aren't recognized as operators. If not set, they are. */ #define RE_LIMITED_OPS (RE_INTERVALS << 1) /* If this bit is set, newline is an alternation operator. If not set, newline is literal. */ #define RE_NEWLINE_ALT (RE_LIMITED_OPS << 1) /* If this bit is set, then `{...}' defines an interval, and \{ and \} are literals. If not set, then `\{...\}' defines an interval. */ #define RE_NO_BK_BRACES (RE_NEWLINE_ALT << 1) /* If this bit is set, (...) defines a group, and \( and \) are literals. If not set, \(...\) defines a group, and ( and ) are literals. */ #define RE_NO_BK_PARENS (RE_NO_BK_BRACES << 1) /* If this bit is set, then \ matches . If not set, then \ is a back-reference. */ #define RE_NO_BK_REFS (RE_NO_BK_PARENS << 1) /* If this bit is set, then | is an alternation operator, and \| is literal. If not set, then \| is an alternation operator, and | is literal. */ #define RE_NO_BK_VBAR (RE_NO_BK_REFS << 1) /* If this bit is set, then an ending range point collating higher than the starting range point, as in [z-a], is invalid. If not set, then when ending range point collates higher than the starting range point, the range is ignored. */ #define RE_NO_EMPTY_RANGES (RE_NO_BK_VBAR << 1) /* If this bit is set, then an unmatched ) is ordinary. If not set, then an unmatched ) is invalid. */ #define RE_UNMATCHED_RIGHT_PAREN_ORD (RE_NO_EMPTY_RANGES << 1) /* This global variable defines the particular regexp syntax to use (for some interfaces). When a regexp is compiled, the syntax used is stored in the pattern buffer, so changing this does not affect already-compiled regexps. */ extern reg_syntax_t re_syntax_options; /* Define combinations of the above bits for the standard possibilities. (The [[[ comments delimit what gets put into the Texinfo file, so don't delete them!) */ /* [[[begin syntaxes]]] */ #define RE_SYNTAX_EMACS 0 #define RE_SYNTAX_AWK \ (RE_BACKSLASH_ESCAPE_IN_LISTS | RE_DOT_NOT_NULL \ | RE_NO_BK_PARENS | RE_NO_BK_REFS \ | RE_NO_BK_VBAR | RE_NO_EMPTY_RANGES \ | RE_UNMATCHED_RIGHT_PAREN_ORD) #define RE_SYNTAX_POSIX_AWK \ (RE_SYNTAX_POSIX_EXTENDED | RE_BACKSLASH_ESCAPE_IN_LISTS) #define RE_SYNTAX_GREP \ (RE_BK_PLUS_QM | RE_CHAR_CLASSES \ | RE_HAT_LISTS_NOT_NEWLINE | RE_INTERVALS \ | RE_NEWLINE_ALT) #define RE_SYNTAX_EGREP \ (RE_CHAR_CLASSES | RE_CONTEXT_INDEP_ANCHORS \ | RE_CONTEXT_INDEP_OPS | RE_HAT_LISTS_NOT_NEWLINE \ | RE_NEWLINE_ALT | RE_NO_BK_PARENS \ | RE_NO_BK_VBAR) #define RE_SYNTAX_POSIX_EGREP \ (RE_SYNTAX_EGREP | RE_INTERVALS | RE_NO_BK_BRACES) /* P1003.2/D11.2, section 4.20.7.1, lines 5078ff. */ #define RE_SYNTAX_ED RE_SYNTAX_POSIX_BASIC #define RE_SYNTAX_SED RE_SYNTAX_POSIX_BASIC /* Syntax bits common to both basic and extended POSIX regex syntax. */ #define _RE_SYNTAX_POSIX_COMMON \ (RE_CHAR_CLASSES | RE_DOT_NEWLINE | RE_DOT_NOT_NULL \ | RE_INTERVALS | RE_NO_EMPTY_RANGES) #define RE_SYNTAX_POSIX_BASIC \ (_RE_SYNTAX_POSIX_COMMON | RE_BK_PLUS_QM) /* Differs from ..._POSIX_BASIC only in that RE_BK_PLUS_QM becomes RE_LIMITED_OPS, i.e., \? \+ \| are not recognized. Actually, this isn't minimal, since other operators, such as \`, aren't disabled. */ #define RE_SYNTAX_POSIX_MINIMAL_BASIC \ (_RE_SYNTAX_POSIX_COMMON | RE_LIMITED_OPS) #define RE_SYNTAX_POSIX_EXTENDED \ (_RE_SYNTAX_POSIX_COMMON | RE_CONTEXT_INDEP_ANCHORS \ | RE_CONTEXT_INDEP_OPS | RE_NO_BK_BRACES \ | RE_NO_BK_PARENS | RE_NO_BK_VBAR \ | RE_UNMATCHED_RIGHT_PAREN_ORD) /* Differs from ..._POSIX_EXTENDED in that RE_CONTEXT_INVALID_OPS replaces RE_CONTEXT_INDEP_OPS and RE_NO_BK_REFS is added. */ #define RE_SYNTAX_POSIX_MINIMAL_EXTENDED \ (_RE_SYNTAX_POSIX_COMMON | RE_CONTEXT_INDEP_ANCHORS \ | RE_CONTEXT_INVALID_OPS | RE_NO_BK_BRACES \ | RE_NO_BK_PARENS | RE_NO_BK_REFS \ | RE_NO_BK_VBAR | RE_UNMATCHED_RIGHT_PAREN_ORD) /* [[[end syntaxes]]] */ /* Maximum number of duplicates an interval can allow. Some systems (erroneously) define this in other header files, but we want our value, so remove any previous define. */ #ifdef RE_DUP_MAX #undef RE_DUP_MAX #endif #define RE_DUP_MAX ((1 << 15) - 1) /* POSIX `cflags' bits (i.e., information for `regcomp'). */ /* If this bit is set, then use extended regular expression syntax. If not set, then use basic regular expression syntax. */ #define REG_EXTENDED 1 /* If this bit is set, then ignore case when matching. If not set, then case is significant. */ #define REG_ICASE (REG_EXTENDED << 1) /* If this bit is set, then anchors do not match at newline characters in the string. If not set, then anchors do match at newlines. */ #define REG_NEWLINE (REG_ICASE << 1) /* If this bit is set, then report only success or fail in regexec. If not set, then returns differ between not matching and errors. */ #define REG_NOSUB (REG_NEWLINE << 1) /* POSIX `eflags' bits (i.e., information for regexec). */ /* If this bit is set, then the beginning-of-line operator doesn't match the beginning of the string (presumably because it's not the beginning of a line). If not set, then the beginning-of-line operator does match the beginning of the string. */ #define REG_NOTBOL 1 /* Like REG_NOTBOL, except for the end-of-line. */ #define REG_NOTEOL (1 << 1) /* If any error codes are removed, changed, or added, update the `re_error_msg' table in regex.c. */ typedef enum { REG_NOERROR = 0, /* Success. */ REG_NOMATCH, /* Didn't find a match (for regexec). */ /* POSIX regcomp return error codes. (In the order listed in the standard.) */ REG_BADPAT, /* Invalid pattern. */ REG_ECOLLATE, /* Not implemented. */ REG_ECTYPE, /* Invalid character class name. */ REG_EESCAPE, /* Trailing backslash. */ REG_ESUBREG, /* Invalid back reference. */ REG_EBRACK, /* Unmatched left bracket. */ REG_EPAREN, /* Parenthesis imbalance. */ REG_EBRACE, /* Unmatched \{. */ REG_BADBR, /* Invalid contents of \{\}. */ REG_ERANGE, /* Invalid range end. */ REG_ESPACE, /* Ran out of memory. */ REG_BADRPT, /* No preceding re for repetition op. */ /* Error codes we've added. */ REG_EEND, /* Premature end. */ REG_ESIZE, /* Compiled pattern bigger than 2^16 bytes. */ REG_ERPAREN /* Unmatched ) or \); not returned from regcomp. */ } reg_errcode_t; /* This data structure represents a compiled pattern. Before calling the pattern compiler, the fields `buffer', `allocated', `fastmap', `translate', and `no_sub' can be set. After the pattern has been compiled, the `re_nsub' field is available. All other fields are private to the regex routines. */ struct re_pattern_buffer { /* [[[begin pattern_buffer]]] */ /* Space that holds the compiled pattern. It is declared as `unsigned char *' because its elements are sometimes used as array indexes. */ unsigned char *buffer; /* Number of bytes to which `buffer' points. */ unsigned long allocated; /* Number of bytes actually used in `buffer'. */ unsigned long used; /* Syntax setting with which the pattern was compiled. */ reg_syntax_t syntax; /* Pointer to a fastmap, if any, otherwise zero. re_search uses the fastmap, if there is one, to skip over impossible starting points for matches. */ char *fastmap; /* Either a translate table to apply to all characters before comparing them, or zero for no translation. The translation is applied to a pattern when it is compiled and to a string when it is matched. */ char *translate; /* Number of subexpressions found by the compiler. */ size_t re_nsub; /* Zero if this pattern cannot match the empty string, one else. Well, in truth it's used only in `re_search_2', to see whether or not we should use the fastmap, so we don't set this absolutely perfectly; see `re_compile_fastmap' (the `duplicate' case). */ unsigned can_be_null : 1; /* If REGS_UNALLOCATED, allocate space in the `regs' structure for `max (RE_NREGS, re_nsub + 1)' groups. If REGS_REALLOCATE, reallocate space if necessary. If REGS_FIXED, use what's there. */ #define REGS_UNALLOCATED 0 #define REGS_REALLOCATE 1 #define REGS_FIXED 2 unsigned regs_allocated : 2; /* Set to zero when `regex_compile' compiles a pattern; set to one by `re_compile_fastmap' if it updates the fastmap. */ unsigned fastmap_accurate : 1; /* If set, `re_match_2' does not return information about subexpressions. */ unsigned no_sub : 1; /* If set, a beginning-of-line anchor doesn't match at the beginning of the string. */ unsigned not_bol : 1; /* Similarly for an end-of-line anchor. */ unsigned not_eol : 1; /* If true, an anchor at a newline matches. */ unsigned newline_anchor : 1; /* [[[end pattern_buffer]]] */ }; typedef struct re_pattern_buffer regex_t; /* search.c (search_buffer) in Emacs needs this one opcode value. It is defined both in `regex.c' and here. */ #define RE_EXACTN_VALUE 1 /* Type for byte offsets within the string. POSIX mandates this. */ typedef int regoff_t; /* This is the structure we store register match data in. See regex.texinfo for a full description of what registers match. */ struct re_registers { unsigned num_regs; regoff_t *start; regoff_t *end; }; /* If `regs_allocated' is REGS_UNALLOCATED in the pattern buffer, `re_match_2' returns information about at least this many registers the first time a `regs' structure is passed. */ #ifndef RE_NREGS #define RE_NREGS 30 #endif /* POSIX specification for registers. Aside from the different names than `re_registers', POSIX uses an array of structures, instead of a structure of arrays. */ typedef struct { regoff_t rm_so; /* Byte offset from string's start to substring's start. */ regoff_t rm_eo; /* Byte offset from string's start to substring's end. */ } regmatch_t; /* Declarations for routines. */ /* To avoid duplicating every routine declaration -- once with a prototype (if we are ANSI), and once without (if we aren't) -- we use the following macro to declare argument types. This unfortunately clutters up the declarations a bit, but I think it's worth it. */ #if __STDC__ #define _RE_ARGS(args) args #else /* not __STDC__ */ #define _RE_ARGS(args) () #endif /* not __STDC__ */ /* Sets the current default syntax to SYNTAX, and return the old syntax. You can also simply assign to the `re_syntax_options' variable. */ extern reg_syntax_t re_set_syntax _RE_ARGS ((reg_syntax_t syntax)); /* Compile the regular expression PATTERN, with length LENGTH and syntax given by the global `re_syntax_options', into the buffer BUFFER. Return NULL if successful, and an error string if not. */ extern const char *re_compile_pattern _RE_ARGS ((const char *pattern, int length, struct re_pattern_buffer *buffer)); /* Compile a fastmap for the compiled pattern in BUFFER; used to accelerate searches. Return 0 if successful and -2 if was an internal error. */ extern int re_compile_fastmap _RE_ARGS ((struct re_pattern_buffer *buffer)); /* Search in the string STRING (with length LENGTH) for the pattern compiled into BUFFER. Start searching at position START, for RANGE characters. Return the starting position of the match, -1 for no match, or -2 for an internal error. Also return register information in REGS (if REGS and BUFFER->no_sub are nonzero). */ extern int re_search _RE_ARGS ((struct re_pattern_buffer *buffer, const char *string, int length, int start, int range, struct re_registers *regs)); /* Like `re_search', but search in the concatenation of STRING1 and STRING2. Also, stop searching at index START + STOP. */ extern int re_search_2 _RE_ARGS ((struct re_pattern_buffer *buffer, const char *string1, int length1, const char *string2, int length2, int start, int range, struct re_registers *regs, int stop)); /* Like `re_search', but return how many characters in STRING the regexp in BUFFER matched, starting at position START. */ extern int re_match _RE_ARGS ((struct re_pattern_buffer *buffer, const char *string, int length, int start, struct re_registers *regs)); /* Relates to `re_match' as `re_search_2' relates to `re_search'. */ extern int re_match_2 _RE_ARGS ((struct re_pattern_buffer *buffer, const char *string1, int length1, const char *string2, int length2, int start, struct re_registers *regs, int stop)); /* Set REGS to hold NUM_REGS registers, storing them in STARTS and ENDS. Subsequent matches using BUFFER and REGS will use this memory for recording register information. STARTS and ENDS must be allocated with malloc, and must each be at least `NUM_REGS * sizeof (regoff_t)' bytes long. If NUM_REGS == 0, then subsequent matches should allocate their own register data. Unless this function is called, the first search or match using PATTERN_BUFFER will allocate its own register data, without freeing the old data. */ extern void re_set_registers _RE_ARGS ((struct re_pattern_buffer *buffer, struct re_registers *regs, unsigned num_regs, regoff_t *starts, regoff_t *ends)); /* 4.2 bsd compatibility. */ extern char *re_comp _RE_ARGS ((const char *)); extern int re_exec _RE_ARGS ((const char *)); /* POSIX compatibility. */ extern int regcomp _RE_ARGS ((regex_t *preg, const char *pattern, int cflags)); extern int regexec _RE_ARGS ((const regex_t *preg, const char *string, size_t nmatch, regmatch_t pmatch[], int eflags)); extern size_t regerror _RE_ARGS ((int errcode, const regex_t *preg, char *errbuf, size_t errbuf_size)); extern void regfree _RE_ARGS ((regex_t *preg)); #endif /* not __REGEXP_LIBRARY_H__ */ /* Local variables: make-backup-files: t version-control: t trim-versions-without-asking: nil End: */ sh-utils-1.10/lib/pathmax.h100666 21570 1 3241 5413637205 14043 0ustar djmdaemon/* Define PATH_MAX somehow. Requires sys/types.h. Copyright (C) 1992 Free Software Foundation, Inc. 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 2, 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, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #ifndef _PATHMAX_H #define _PATHMAX_H #ifdef HAVE_UNISTD_H #include #endif /* Non-POSIX BSD systems might have gcc's limits.h, which doesn't define PATH_MAX but might cause redefinition warnings when sys/param.h is later included (as on MORE/BSD 4.3). */ #if defined(_POSIX_VERSION) || (defined(HAVE_LIMITS_H) && !defined(__GNUC__)) #include #endif #ifndef _POSIX_PATH_MAX #define _POSIX_PATH_MAX 255 #endif #if !defined(PATH_MAX) && defined(_PC_PATH_MAX) #define PATH_MAX (pathconf ("/", _PC_PATH_MAX) < 1 ? 1024 : pathconf ("/", _PC_PATH_MAX)) #endif /* Don't include sys/param.h if it already has been. */ #if !defined(PATH_MAX) && !defined(MAXPATHLEN) && !defined(__MSDOS__) #include #endif #if !defined(PATH_MAX) && defined(MAXPATHLEN) #define PATH_MAX MAXPATHLEN #endif #ifndef PATH_MAX #define PATH_MAX _POSIX_PATH_MAX #endif #endif /* _PATHMAX_H */ sh-utils-1.10/lib/getdate.c100666 74504 1 136776 5566761154 15161 0ustar meyeringdaemon /* A Bison parser, made from ./getdate.y with Bison version GNU Bison version 1.22 */ #define YYBISON 1 /* Identify Bison output. */ #define tAGO 258 #define tDAY 259 #define tDAYZONE 260 #define tID 261 #define tMERIDIAN 262 #define tMINUTE_UNIT 263 #define tMONTH 264 #define tMONTH_UNIT 265 #define tSEC_UNIT 266 #define tSNUMBER 267 #define tUNUMBER 268 #define tZONE 269 #define tDST 270 #line 1 "./getdate.y" /* ** Originally written by Steven M. Bellovin while ** at the University of North Carolina at Chapel Hill. Later tweaked by ** a couple of people on Usenet. Completely overhauled by Rich $alz ** and Jim Berets in August, 1990; ** send any email to Rich. ** ** This grammar has 10 shift/reduce conflicts. ** ** This code is in the public domain and has no copyright. */ /* SUPPRESS 287 on yaccpar_sccsid *//* Unused static variable */ /* SUPPRESS 288 on yyerrlab *//* Label unused */ #ifdef HAVE_CONFIG_H #if defined (emacs) || defined (CONFIG_BROKETS) #include #else #include "config.h" #endif #endif /* Since the code of getdate.y is not included in the Emacs executable itself, there is no need to #define static in this file. Even if the code were included in the Emacs executable, it probably wouldn't do any harm to #undef it here; this will only cause problems if we try to write to a static variable, which I don't think this code needs to do. */ #ifdef emacs #undef static #endif #include #include /* The code at the top of get_date which figures out the offset of the current time zone checks various CPP symbols to see if special tricks are need, but defaults to using the gettimeofday system call. Include if that will be used. */ #if defined(vms) #include #include #else #include #ifdef TIME_WITH_SYS_TIME #include #include #else #ifdef HAVE_SYS_TIME_H #include #else #include #endif #endif #ifdef timezone #undef timezone /* needed for sgi */ #endif #if defined(HAVE_SYS_TIMEB_H) #include #else /* ** We use the obsolete `struct timeb' as part of our interface! ** Since the system doesn't have it, we define it here; ** our callers must do likewise. */ struct timeb { time_t time; /* Seconds since the epoch */ unsigned short millitm; /* Field not used */ short timezone; /* Minutes west of GMT */ short dstflag; /* Field not used */ }; #endif /* defined(HAVE_SYS_TIMEB_H) */ #endif /* defined(vms) */ #if defined (STDC_HEADERS) || defined (USG) #include #endif /* Some old versions of bison generate parsers that use bcopy. That loses on systems that don't provide the function, so we have to redefine it here. */ #if !defined (HAVE_BCOPY) && defined (HAVE_MEMCPY) && !defined (bcopy) #define bcopy(from, to, len) memcpy ((to), (from), (len)) #endif extern struct tm *gmtime(); extern struct tm *localtime(); #define yyparse getdate_yyparse #define yylex getdate_yylex #define yyerror getdate_yyerror static int yylex (); static int yyerror (); #define EPOCH 1970 #define HOUR(x) ((time_t)(x) * 60) #define SECSPERDAY (24L * 60L * 60L) /* ** An entry in the lexical lookup table. */ typedef struct _TABLE { char *name; int type; time_t value; } TABLE; /* ** Daylight-savings mode: on, off, or not yet known. */ typedef enum _DSTMODE { DSTon, DSToff, DSTmaybe } DSTMODE; /* ** Meridian: am, pm, or 24-hour style. */ typedef enum _MERIDIAN { MERam, MERpm, MER24 } MERIDIAN; /* ** Global variables. We could get rid of most of these by using a good ** union as the yacc stack. (This routine was originally written before ** yacc had the %union construct.) Maybe someday; right now we only use ** the %union very rarely. */ static char *yyInput; static DSTMODE yyDSTmode; static time_t yyDayOrdinal; static time_t yyDayNumber; static int yyHaveDate; static int yyHaveDay; static int yyHaveRel; static int yyHaveTime; static int yyHaveZone; static time_t yyTimezone; static time_t yyDay; static time_t yyHour; static time_t yyMinutes; static time_t yyMonth; static time_t yySeconds; static time_t yyYear; static MERIDIAN yyMeridian; static time_t yyRelMonth; static time_t yyRelSeconds; #line 163 "./getdate.y" typedef union { time_t Number; enum _MERIDIAN Meridian; } YYSTYPE; #ifndef YYLTYPE typedef struct yyltype { int timestamp; int first_line; int first_column; int last_line; int last_column; char *text; } yyltype; #define YYLTYPE yyltype #endif #include #ifndef __cplusplus #ifndef __STDC__ #define const #endif #endif #define YYFINAL 52 #define YYFLAG -32768 #define YYNTBASE 19 #define YYTRANSLATE(x) ((unsigned)(x) <= 270 ? yytranslate[x] : 29) static const char yytranslate[] = { 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 17, 2, 2, 18, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 16, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 }; #if YYDEBUG != 0 static const short yyprhs[] = { 0, 0, 1, 4, 6, 8, 10, 12, 14, 16, 19, 24, 29, 36, 43, 45, 47, 50, 52, 55, 58, 62, 68, 72, 76, 79, 84, 87, 91, 94, 96, 99, 102, 104, 107, 110, 112, 115, 118, 120, 122, 123 }; static const short yyrhs[] = { -1, 19, 20, 0, 21, 0, 22, 0, 24, 0, 23, 0, 25, 0, 27, 0, 13, 7, 0, 13, 16, 13, 28, 0, 13, 16, 13, 12, 0, 13, 16, 13, 16, 13, 28, 0, 13, 16, 13, 16, 13, 12, 0, 14, 0, 5, 0, 14, 15, 0, 4, 0, 4, 17, 0, 13, 4, 0, 13, 18, 13, 0, 13, 18, 13, 18, 13, 0, 13, 12, 12, 0, 13, 9, 12, 0, 9, 13, 0, 9, 13, 17, 13, 0, 13, 9, 0, 13, 9, 13, 0, 26, 3, 0, 26, 0, 13, 8, 0, 12, 8, 0, 8, 0, 12, 11, 0, 13, 11, 0, 11, 0, 12, 10, 0, 13, 10, 0, 10, 0, 13, 0, 0, 7, 0 }; #endif #if YYDEBUG != 0 static const short yyrline[] = { 0, 177, 178, 181, 184, 187, 190, 193, 196, 199, 205, 211, 218, 224, 234, 238, 242, 249, 253, 257, 263, 267, 272, 278, 284, 288, 293, 297, 304, 308, 311, 314, 317, 320, 323, 326, 329, 332, 335, 340, 367, 370 }; static const char * const yytname[] = { "$","error","$illegal.","tAGO","tDAY", "tDAYZONE","tID","tMERIDIAN","tMINUTE_UNIT","tMONTH","tMONTH_UNIT","tSEC_UNIT", "tSNUMBER","tUNUMBER","tZONE","tDST","':'","','","'/'","spec","item","time", "zone","day","date","rel","relunit","number","o_merid","" }; #endif static const short yyr1[] = { 0, 19, 19, 20, 20, 20, 20, 20, 20, 21, 21, 21, 21, 21, 22, 22, 22, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 25, 25, 26, 26, 26, 26, 26, 26, 26, 26, 26, 27, 28, 28 }; static const short yyr2[] = { 0, 0, 2, 1, 1, 1, 1, 1, 1, 2, 4, 4, 6, 6, 1, 1, 2, 1, 2, 2, 3, 5, 3, 3, 2, 4, 2, 3, 2, 1, 2, 2, 1, 2, 2, 1, 2, 2, 1, 1, 0, 1 }; static const short yydefact[] = { 1, 0, 17, 15, 32, 0, 38, 35, 0, 39, 14, 2, 3, 4, 6, 5, 7, 29, 8, 18, 24, 31, 36, 33, 19, 9, 30, 26, 37, 34, 0, 0, 0, 16, 28, 0, 23, 27, 22, 40, 20, 25, 41, 11, 0, 10, 0, 40, 21, 13, 12, 0, 0 }; static const short yydefgoto[] = { 1, 11, 12, 13, 14, 15, 16, 17, 18, 45 }; static const short yypact[] = {-32768, 0, -1,-32768,-32768, 4,-32768,-32768, 25, 11, -8, -32768,-32768,-32768,-32768,-32768,-32768, 21,-32768,-32768, 9, -32768,-32768,-32768,-32768,-32768,-32768, -10,-32768,-32768, 16, 19, 24,-32768,-32768, 26,-32768,-32768,-32768, 18, 13, -32768,-32768,-32768, 27,-32768, 28, -6,-32768,-32768,-32768, 38,-32768 }; static const short yypgoto[] = {-32768, -32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, -5 }; #define YYLAST 42 static const short yytable[] = { 51, 42, 36, 37, 2, 3, 49, 33, 4, 5, 6, 7, 8, 9, 10, 24, 19, 20, 25, 26, 27, 28, 29, 30, 34, 42, 35, 31, 38, 32, 43, 46, 39, 21, 44, 22, 23, 40, 52, 41, 47, 48, 50 }; static const short yycheck[] = { 0, 7, 12, 13, 4, 5, 12, 15, 8, 9, 10, 11, 12, 13, 14, 4, 17, 13, 7, 8, 9, 10, 11, 12, 3, 7, 17, 16, 12, 18, 12, 18, 13, 8, 16, 10, 11, 13, 0, 13, 13, 13, 47 }; /* -*-C-*- Note some compilers choke on comments on `#line' lines. */ #line 3 "/usr/local/lib/bison.simple" /* Skeleton output parser for bison, Copyright (C) 1984, 1989, 1990 Bob Corbett and Richard Stallman 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 1, 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, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #ifndef alloca #ifdef __GNUC__ #define alloca __builtin_alloca #else /* not GNU C. */ #if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi) #include #else /* not sparc */ #if defined (MSDOS) && !defined (__TURBOC__) #include #else /* not MSDOS, or __TURBOC__ */ #if defined(_AIX) #include #pragma alloca #else /* not MSDOS, __TURBOC__, or _AIX */ #ifdef __hpux #ifdef __cplusplus extern "C" { void *alloca (unsigned int); }; #else /* not __cplusplus */ void *alloca (); #endif /* not __cplusplus */ #endif /* __hpux */ #endif /* not _AIX */ #endif /* not MSDOS, or __TURBOC__ */ #endif /* not sparc. */ #endif /* not GNU C. */ #endif /* alloca not defined. */ /* This is the parser code that is written into each bison parser when the %semantic_parser declaration is not specified in the grammar. It was written by Richard Stallman by simplifying the hairy parser used when %semantic_parser is specified. */ /* Note: there must be only one dollar sign in this file. It is replaced by the list of actions, each action as one case of the switch. */ #define yyerrok (yyerrstatus = 0) #define yyclearin (yychar = YYEMPTY) #define YYEMPTY -2 #define YYEOF 0 #define YYACCEPT return(0) #define YYABORT return(1) #define YYERROR goto yyerrlab1 /* Like YYERROR except do call yyerror. This remains here temporarily to ease the transition to the new meaning of YYERROR, for GCC. Once GCC version 2 has supplanted version 1, this can go. */ #define YYFAIL goto yyerrlab #define YYRECOVERING() (!!yyerrstatus) #define YYBACKUP(token, value) \ do \ if (yychar == YYEMPTY && yylen == 1) \ { yychar = (token), yylval = (value); \ yychar1 = YYTRANSLATE (yychar); \ YYPOPSTACK; \ goto yybackup; \ } \ else \ { yyerror ("syntax error: cannot back up"); YYERROR; } \ while (0) #define YYTERROR 1 #define YYERRCODE 256 #ifndef YYPURE #define YYLEX yylex() #endif #ifdef YYPURE #ifdef YYLSP_NEEDED #define YYLEX yylex(&yylval, &yylloc) #else #define YYLEX yylex(&yylval) #endif #endif /* If nonreentrant, generate the variables here */ #ifndef YYPURE int yychar; /* the lookahead symbol */ YYSTYPE yylval; /* the semantic value of the */ /* lookahead symbol */ #ifdef YYLSP_NEEDED YYLTYPE yylloc; /* location data for the lookahead */ /* symbol */ #endif int yynerrs; /* number of parse errors so far */ #endif /* not YYPURE */ #if YYDEBUG != 0 int yydebug; /* nonzero means print parse trace */ /* Since this is uninitialized, it does not stop multiple parsers from coexisting. */ #endif /* YYINITDEPTH indicates the initial size of the parser's stacks */ #ifndef YYINITDEPTH #define YYINITDEPTH 200 #endif /* YYMAXDEPTH is the maximum size the stacks can grow to (effective only if the built-in stack extension method is used). */ #if YYMAXDEPTH == 0 #undef YYMAXDEPTH #endif #ifndef YYMAXDEPTH #define YYMAXDEPTH 10000 #endif /* Prevent warning if -Wstrict-prototypes. */ #ifdef __GNUC__ int yyparse (void); #endif #if __GNUC__ > 1 /* GNU C and GNU C++ define this. */ #define __yy_bcopy(FROM,TO,COUNT) __builtin_memcpy(TO,FROM,COUNT) #else /* not GNU C or C++ */ #ifndef __cplusplus /* This is the most reliable way to avoid incompatibilities in available built-in functions on various systems. */ static void __yy_bcopy (from, to, count) char *from; char *to; int count; { register char *f = from; register char *t = to; register int i = count; while (i-- > 0) *t++ = *f++; } #else /* __cplusplus */ /* This is the most reliable way to avoid incompatibilities in available built-in functions on various systems. */ static void __yy_bcopy (char *from, char *to, int count) { register char *f = from; register char *t = to; register int i = count; while (i-- > 0) *t++ = *f++; } #endif #endif #line 184 "/usr/local/lib/bison.simple" int yyparse() { register int yystate; register int yyn; register short *yyssp; register YYSTYPE *yyvsp; int yyerrstatus; /* number of tokens to shift before error messages enabled */ int yychar1 = 0; /* lookahead token as an internal (translated) token number */ short yyssa[YYINITDEPTH]; /* the state stack */ YYSTYPE yyvsa[YYINITDEPTH]; /* the semantic value stack */ short *yyss = yyssa; /* refer to the stacks thru separate pointers */ YYSTYPE *yyvs = yyvsa; /* to allow yyoverflow to reallocate them elsewhere */ #ifdef YYLSP_NEEDED YYLTYPE yylsa[YYINITDEPTH]; /* the location stack */ YYLTYPE *yyls = yylsa; YYLTYPE *yylsp; #define YYPOPSTACK (yyvsp--, yyssp--, yylsp--) #else #define YYPOPSTACK (yyvsp--, yyssp--) #endif int yystacksize = YYINITDEPTH; #ifdef YYPURE int yychar; YYSTYPE yylval; int yynerrs; #ifdef YYLSP_NEEDED YYLTYPE yylloc; #endif #endif YYSTYPE yyval; /* the variable used to return */ /* semantic values from the action */ /* routines */ int yylen; #if YYDEBUG != 0 if (yydebug) fprintf(stderr, "Starting parse\n"); #endif yystate = 0; yyerrstatus = 0; yynerrs = 0; yychar = YYEMPTY; /* Cause a token to be read. */ /* Initialize stack pointers. Waste one element of value and location stack so that they stay on the same level as the state stack. The wasted elements are never initialized. */ yyssp = yyss - 1; yyvsp = yyvs; #ifdef YYLSP_NEEDED yylsp = yyls; #endif /* Push a new state, which is found in yystate . */ /* In all cases, when you get here, the value and location stacks have just been pushed. so pushing a state here evens the stacks. */ yynewstate: *++yyssp = yystate; if (yyssp >= yyss + yystacksize - 1) { /* Give user a chance to reallocate the stack */ /* Use copies of these so that the &'s don't force the real ones into memory. */ YYSTYPE *yyvs1 = yyvs; short *yyss1 = yyss; #ifdef YYLSP_NEEDED YYLTYPE *yyls1 = yyls; #endif /* Get the current used size of the three stacks, in elements. */ int size = yyssp - yyss + 1; #ifdef yyoverflow /* Each stack pointer address is followed by the size of the data in use in that stack, in bytes. */ #ifdef YYLSP_NEEDED /* This used to be a conditional around just the two extra args, but that might be undefined if yyoverflow is a macro. */ yyoverflow("parser stack overflow", &yyss1, size * sizeof (*yyssp), &yyvs1, size * sizeof (*yyvsp), &yyls1, size * sizeof (*yylsp), &yystacksize); #else yyoverflow("parser stack overflow", &yyss1, size * sizeof (*yyssp), &yyvs1, size * sizeof (*yyvsp), &yystacksize); #endif yyss = yyss1; yyvs = yyvs1; #ifdef YYLSP_NEEDED yyls = yyls1; #endif #else /* no yyoverflow */ /* Extend the stack our own way. */ if (yystacksize >= YYMAXDEPTH) { yyerror("parser stack overflow"); return 2; } yystacksize *= 2; if (yystacksize > YYMAXDEPTH) yystacksize = YYMAXDEPTH; yyss = (short *) alloca (yystacksize * sizeof (*yyssp)); __yy_bcopy ((char *)yyss1, (char *)yyss, size * sizeof (*yyssp)); yyvs = (YYSTYPE *) alloca (yystacksize * sizeof (*yyvsp)); __yy_bcopy ((char *)yyvs1, (char *)yyvs, size * sizeof (*yyvsp)); #ifdef YYLSP_NEEDED yyls = (YYLTYPE *) alloca (yystacksize * sizeof (*yylsp)); __yy_bcopy ((char *)yyls1, (char *)yyls, size * sizeof (*yylsp)); #endif #endif /* no yyoverflow */ yyssp = yyss + size - 1; yyvsp = yyvs + size - 1; #ifdef YYLSP_NEEDED yylsp = yyls + size - 1; #endif #if YYDEBUG != 0 if (yydebug) fprintf(stderr, "Stack size increased to %d\n", yystacksize); #endif if (yyssp >= yyss + yystacksize - 1) YYABORT; } #if YYDEBUG != 0 if (yydebug) fprintf(stderr, "Entering state %d\n", yystate); #endif goto yybackup; yybackup: /* Do appropriate processing given the current state. */ /* Read a lookahead token if we need one and don't already have one. */ /* yyresume: */ /* First try to decide what to do without reference to lookahead token. */ yyn = yypact[yystate]; if (yyn == YYFLAG) goto yydefault; /* Not known => get a lookahead token if don't already have one. */ /* yychar is either YYEMPTY or YYEOF or a valid token in external form. */ if (yychar == YYEMPTY) { #if YYDEBUG != 0 if (yydebug) fprintf(stderr, "Reading a token: "); #endif yychar = YYLEX; } /* Convert token to internal form (in yychar1) for indexing tables with */ if (yychar <= 0) /* This means end of input. */ { yychar1 = 0; yychar = YYEOF; /* Don't call YYLEX any more */ #if YYDEBUG != 0 if (yydebug) fprintf(stderr, "Now at end of input.\n"); #endif } else { yychar1 = YYTRANSLATE(yychar); #if YYDEBUG != 0 if (yydebug) { fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]); /* Give the individual parser a way to print the precise meaning of a token, for further debugging info. */ #ifdef YYPRINT YYPRINT (stderr, yychar, yylval); #endif fprintf (stderr, ")\n"); } #endif } yyn += yychar1; if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1) goto yydefault; yyn = yytable[yyn]; /* yyn is what to do for this token type in this state. Negative => reduce, -yyn is rule number. Positive => shift, yyn is new state. New state is final state => don't bother to shift, just return success. 0, or most negative number => error. */ if (yyn < 0) { if (yyn == YYFLAG) goto yyerrlab; yyn = -yyn; goto yyreduce; } else if (yyn == 0) goto yyerrlab; if (yyn == YYFINAL) YYACCEPT; /* Shift the lookahead token. */ #if YYDEBUG != 0 if (yydebug) fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]); #endif /* Discard the token being shifted unless it is eof. */ if (yychar != YYEOF) yychar = YYEMPTY; *++yyvsp = yylval; #ifdef YYLSP_NEEDED *++yylsp = yylloc; #endif /* count tokens shifted since error; after three, turn off error status. */ if (yyerrstatus) yyerrstatus--; yystate = yyn; goto yynewstate; /* Do the default action for the current state. */ yydefault: yyn = yydefact[yystate]; if (yyn == 0) goto yyerrlab; /* Do a reduction. yyn is the number of a rule to reduce with. */ yyreduce: yylen = yyr2[yyn]; if (yylen > 0) yyval = yyvsp[1-yylen]; /* implement default value of the action */ #if YYDEBUG != 0 if (yydebug) { int i; fprintf (stderr, "Reducing via rule %d (line %d), ", yyn, yyrline[yyn]); /* Print the symbols being reduced, and their result. */ for (i = yyprhs[yyn]; yyrhs[i] > 0; i++) fprintf (stderr, "%s ", yytname[yyrhs[i]]); fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]); } #endif switch (yyn) { case 3: #line 181 "./getdate.y" { yyHaveTime++; ; break;} case 4: #line 184 "./getdate.y" { yyHaveZone++; ; break;} case 5: #line 187 "./getdate.y" { yyHaveDate++; ; break;} case 6: #line 190 "./getdate.y" { yyHaveDay++; ; break;} case 7: #line 193 "./getdate.y" { yyHaveRel++; ; break;} case 9: #line 199 "./getdate.y" { yyHour = yyvsp[-1].Number; yyMinutes = 0; yySeconds = 0; yyMeridian = yyvsp[0].Meridian; ; break;} case 10: #line 205 "./getdate.y" { yyHour = yyvsp[-3].Number; yyMinutes = yyvsp[-1].Number; yySeconds = 0; yyMeridian = yyvsp[0].Meridian; ; break;} case 11: #line 211 "./getdate.y" { yyHour = yyvsp[-3].Number; yyMinutes = yyvsp[-1].Number; yyMeridian = MER24; yyDSTmode = DSToff; yyTimezone = - (yyvsp[0].Number % 100 + (yyvsp[0].Number / 100) * 60); ; break;} case 12: #line 218 "./getdate.y" { yyHour = yyvsp[-5].Number; yyMinutes = yyvsp[-3].Number; yySeconds = yyvsp[-1].Number; yyMeridian = yyvsp[0].Meridian; ; break;} case 13: #line 224 "./getdate.y" { yyHour = yyvsp[-5].Number; yyMinutes = yyvsp[-3].Number; yySeconds = yyvsp[-1].Number; yyMeridian = MER24; yyDSTmode = DSToff; yyTimezone = - (yyvsp[0].Number % 100 + (yyvsp[0].Number / 100) * 60); ; break;} case 14: #line 234 "./getdate.y" { yyTimezone = yyvsp[0].Number; yyDSTmode = DSToff; ; break;} case 15: #line 238 "./getdate.y" { yyTimezone = yyvsp[0].Number; yyDSTmode = DSTon; ; break;} case 16: #line 243 "./getdate.y" { yyTimezone = yyvsp[-1].Number; yyDSTmode = DSTon; ; break;} case 17: #line 249 "./getdate.y" { yyDayOrdinal = 1; yyDayNumber = yyvsp[0].Number; ; break;} case 18: #line 253 "./getdate.y" { yyDayOrdinal = 1; yyDayNumber = yyvsp[-1].Number; ; break;} case 19: #line 257 "./getdate.y" { yyDayOrdinal = yyvsp[-1].Number; yyDayNumber = yyvsp[0].Number; ; break;} case 20: #line 263 "./getdate.y" { yyMonth = yyvsp[-2].Number; yyDay = yyvsp[0].Number; ; break;} case 21: #line 267 "./getdate.y" { yyMonth = yyvsp[-4].Number; yyDay = yyvsp[-2].Number; yyYear = yyvsp[0].Number; ; break;} case 22: #line 272 "./getdate.y" { /* ISO 8601 format. yyyy-mm-dd. */ yyYear = yyvsp[-2].Number; yyMonth = -yyvsp[-1].Number; yyDay = -yyvsp[0].Number; ; break;} case 23: #line 278 "./getdate.y" { /* e.g. 17-JUN-1992. */ yyDay = yyvsp[-2].Number; yyMonth = yyvsp[-1].Number; yyYear = -yyvsp[0].Number; ; break;} case 24: #line 284 "./getdate.y" { yyMonth = yyvsp[-1].Number; yyDay = yyvsp[0].Number; ; break;} case 25: #line 288 "./getdate.y" { yyMonth = yyvsp[-3].Number; yyDay = yyvsp[-2].Number; yyYear = yyvsp[0].Number; ; break;} case 26: #line 293 "./getdate.y" { yyMonth = yyvsp[0].Number; yyDay = yyvsp[-1].Number; ; break;} case 27: #line 297 "./getdate.y" { yyMonth = yyvsp[-1].Number; yyDay = yyvsp[-2].Number; yyYear = yyvsp[0].Number; ; break;} case 28: #line 304 "./getdate.y" { yyRelSeconds = -yyRelSeconds; yyRelMonth = -yyRelMonth; ; break;} case 30: #line 311 "./getdate.y" { yyRelSeconds += yyvsp[-1].Number * yyvsp[0].Number * 60L; ; break;} case 31: #line 314 "./getdate.y" { yyRelSeconds += yyvsp[-1].Number * yyvsp[0].Number * 60L; ; break;} case 32: #line 317 "./getdate.y" { yyRelSeconds += yyvsp[0].Number * 60L; ; break;} case 33: #line 320 "./getdate.y" { yyRelSeconds += yyvsp[-1].Number; ; break;} case 34: #line 323 "./getdate.y" { yyRelSeconds += yyvsp[-1].Number; ; break;} case 35: #line 326 "./getdate.y" { yyRelSeconds++; ; break;} case 36: #line 329 "./getdate.y" { yyRelMonth += yyvsp[-1].Number * yyvsp[0].Number; ; break;} case 37: #line 332 "./getdate.y" { yyRelMonth += yyvsp[-1].Number * yyvsp[0].Number; ; break;} case 38: #line 335 "./getdate.y" { yyRelMonth += yyvsp[0].Number; ; break;} case 39: #line 340 "./getdate.y" { if (yyHaveTime && yyHaveDate && !yyHaveRel) yyYear = yyvsp[0].Number; else { if(yyvsp[0].Number>10000) { yyHaveDate++; yyDay= (yyvsp[0].Number)%100; yyMonth= (yyvsp[0].Number/100)%100; yyYear = yyvsp[0].Number/10000; } else { yyHaveTime++; if (yyvsp[0].Number < 100) { yyHour = yyvsp[0].Number; yyMinutes = 0; } else { yyHour = yyvsp[0].Number / 100; yyMinutes = yyvsp[0].Number % 100; } yySeconds = 0; yyMeridian = MER24; } } ; break;} case 40: #line 367 "./getdate.y" { yyval.Meridian = MER24; ; break;} case 41: #line 370 "./getdate.y" { yyval.Meridian = yyvsp[0].Meridian; ; break;} } /* the action file gets copied in in place of this dollarsign */ #line 465 "/usr/local/lib/bison.simple" yyvsp -= yylen; yyssp -= yylen; #ifdef YYLSP_NEEDED yylsp -= yylen; #endif #if YYDEBUG != 0 if (yydebug) { short *ssp1 = yyss - 1; fprintf (stderr, "state stack now"); while (ssp1 != yyssp) fprintf (stderr, " %d", *++ssp1); fprintf (stderr, "\n"); } #endif *++yyvsp = yyval; #ifdef YYLSP_NEEDED yylsp++; if (yylen == 0) { yylsp->first_line = yylloc.first_line; yylsp->first_column = yylloc.first_column; yylsp->last_line = (yylsp-1)->last_line; yylsp->last_column = (yylsp-1)->last_column; yylsp->text = 0; } else { yylsp->last_line = (yylsp+yylen-1)->last_line; yylsp->last_column = (yylsp+yylen-1)->last_column; } #endif /* Now "shift" the result of the reduction. Determine what state that goes to, based on the state we popped back to and the rule number reduced by. */ yyn = yyr1[yyn]; yystate = yypgoto[yyn - YYNTBASE] + *yyssp; if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp) yystate = yytable[yystate]; else yystate = yydefgoto[yyn - YYNTBASE]; goto yynewstate; yyerrlab: /* here on detecting error */ if (! yyerrstatus) /* If not already recovering from an error, report this error. */ { ++yynerrs; #ifdef YYERROR_VERBOSE yyn = yypact[yystate]; if (yyn > YYFLAG && yyn < YYLAST) { int size = 0; char *msg; int x, count; count = 0; /* Start X at -yyn if nec to avoid negative indexes in yycheck. */ for (x = (yyn < 0 ? -yyn : 0); x < (sizeof(yytname) / sizeof(char *)); x++) if (yycheck[x + yyn] == x) size += strlen(yytname[x]) + 15, count++; msg = (char *) malloc(size + 15); if (msg != 0) { strcpy(msg, "parse error"); if (count < 5) { count = 0; for (x = (yyn < 0 ? -yyn : 0); x < (sizeof(yytname) / sizeof(char *)); x++) if (yycheck[x + yyn] == x) { strcat(msg, count == 0 ? ", expecting `" : " or `"); strcat(msg, yytname[x]); strcat(msg, "'"); count++; } } yyerror(msg); free(msg); } else yyerror ("parse error; also virtual memory exceeded"); } else #endif /* YYERROR_VERBOSE */ yyerror("parse error"); } goto yyerrlab1; yyerrlab1: /* here on error raised explicitly by an action */ if (yyerrstatus == 3) { /* if just tried and failed to reuse lookahead token after an error, discard it. */ /* return failure if at end of input */ if (yychar == YYEOF) YYABORT; #if YYDEBUG != 0 if (yydebug) fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]); #endif yychar = YYEMPTY; } /* Else will try to reuse lookahead token after shifting the error token. */ yyerrstatus = 3; /* Each real token shifted decrements this */ goto yyerrhandle; yyerrdefault: /* current state does not do anything special for the error token. */ #if 0 /* This is wrong; only states that explicitly want error tokens should shift them. */ yyn = yydefact[yystate]; /* If its default is to accept any token, ok. Otherwise pop it.*/ if (yyn) goto yydefault; #endif yyerrpop: /* pop the current state because it cannot handle the error token */ if (yyssp == yyss) YYABORT; yyvsp--; yystate = *--yyssp; #ifdef YYLSP_NEEDED yylsp--; #endif #if YYDEBUG != 0 if (yydebug) { short *ssp1 = yyss - 1; fprintf (stderr, "Error: state stack now"); while (ssp1 != yyssp) fprintf (stderr, " %d", *++ssp1); fprintf (stderr, "\n"); } #endif yyerrhandle: yyn = yypact[yystate]; if (yyn == YYFLAG) goto yyerrdefault; yyn += YYTERROR; if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR) goto yyerrdefault; yyn = yytable[yyn]; if (yyn < 0) { if (yyn == YYFLAG) goto yyerrpop; yyn = -yyn; goto yyreduce; } else if (yyn == 0) goto yyerrpop; if (yyn == YYFINAL) YYACCEPT; #if YYDEBUG != 0 if (yydebug) fprintf(stderr, "Shifting error token, "); #endif *++yyvsp = yylval; #ifdef YYLSP_NEEDED *++yylsp = yylloc; #endif yystate = yyn; goto yynewstate; } #line 375 "./getdate.y" /* Month and day table. */ static TABLE const MonthDayTable[] = { { "january", tMONTH, 1 }, { "february", tMONTH, 2 }, { "march", tMONTH, 3 }, { "april", tMONTH, 4 }, { "may", tMONTH, 5 }, { "june", tMONTH, 6 }, { "july", tMONTH, 7 }, { "august", tMONTH, 8 }, { "september", tMONTH, 9 }, { "sept", tMONTH, 9 }, { "october", tMONTH, 10 }, { "november", tMONTH, 11 }, { "december", tMONTH, 12 }, { "sunday", tDAY, 0 }, { "monday", tDAY, 1 }, { "tuesday", tDAY, 2 }, { "tues", tDAY, 2 }, { "wednesday", tDAY, 3 }, { "wednes", tDAY, 3 }, { "thursday", tDAY, 4 }, { "thur", tDAY, 4 }, { "thurs", tDAY, 4 }, { "friday", tDAY, 5 }, { "saturday", tDAY, 6 }, { NULL } }; /* Time units table. */ static TABLE const UnitsTable[] = { { "year", tMONTH_UNIT, 12 }, { "month", tMONTH_UNIT, 1 }, { "fortnight", tMINUTE_UNIT, 14 * 24 * 60 }, { "week", tMINUTE_UNIT, 7 * 24 * 60 }, { "day", tMINUTE_UNIT, 1 * 24 * 60 }, { "hour", tMINUTE_UNIT, 60 }, { "minute", tMINUTE_UNIT, 1 }, { "min", tMINUTE_UNIT, 1 }, { "second", tSEC_UNIT, 1 }, { "sec", tSEC_UNIT, 1 }, { NULL } }; /* Assorted relative-time words. */ static TABLE const OtherTable[] = { { "tomorrow", tMINUTE_UNIT, 1 * 24 * 60 }, { "yesterday", tMINUTE_UNIT, -1 * 24 * 60 }, { "today", tMINUTE_UNIT, 0 }, { "now", tMINUTE_UNIT, 0 }, { "last", tUNUMBER, -1 }, { "this", tMINUTE_UNIT, 0 }, { "next", tUNUMBER, 2 }, { "first", tUNUMBER, 1 }, /* { "second", tUNUMBER, 2 }, */ { "third", tUNUMBER, 3 }, { "fourth", tUNUMBER, 4 }, { "fifth", tUNUMBER, 5 }, { "sixth", tUNUMBER, 6 }, { "seventh", tUNUMBER, 7 }, { "eighth", tUNUMBER, 8 }, { "ninth", tUNUMBER, 9 }, { "tenth", tUNUMBER, 10 }, { "eleventh", tUNUMBER, 11 }, { "twelfth", tUNUMBER, 12 }, { "ago", tAGO, 1 }, { NULL } }; /* The timezone table. */ /* Some of these are commented out because a time_t can't store a float. */ static TABLE const TimezoneTable[] = { { "gmt", tZONE, HOUR( 0) }, /* Greenwich Mean */ { "ut", tZONE, HOUR( 0) }, /* Universal (Coordinated) */ { "utc", tZONE, HOUR( 0) }, { "wet", tZONE, HOUR( 0) }, /* Western European */ { "bst", tDAYZONE, HOUR( 0) }, /* British Summer */ { "wat", tZONE, HOUR( 1) }, /* West Africa */ { "at", tZONE, HOUR( 2) }, /* Azores */ #if 0 /* For completeness. BST is also British Summer, and GST is * also Guam Standard. */ { "bst", tZONE, HOUR( 3) }, /* Brazil Standard */ { "gst", tZONE, HOUR( 3) }, /* Greenland Standard */ #endif #if 0 { "nft", tZONE, HOUR(3.5) }, /* Newfoundland */ { "nst", tZONE, HOUR(3.5) }, /* Newfoundland Standard */ { "ndt", tDAYZONE, HOUR(3.5) }, /* Newfoundland Daylight */ #endif { "ast", tZONE, HOUR( 4) }, /* Atlantic Standard */ { "adt", tDAYZONE, HOUR( 4) }, /* Atlantic Daylight */ { "est", tZONE, HOUR( 5) }, /* Eastern Standard */ { "edt", tDAYZONE, HOUR( 5) }, /* Eastern Daylight */ { "cst", tZONE, HOUR( 6) }, /* Central Standard */ { "cdt", tDAYZONE, HOUR( 6) }, /* Central Daylight */ { "mst", tZONE, HOUR( 7) }, /* Mountain Standard */ { "mdt", tDAYZONE, HOUR( 7) }, /* Mountain Daylight */ { "pst", tZONE, HOUR( 8) }, /* Pacific Standard */ { "pdt", tDAYZONE, HOUR( 8) }, /* Pacific Daylight */ { "yst", tZONE, HOUR( 9) }, /* Yukon Standard */ { "ydt", tDAYZONE, HOUR( 9) }, /* Yukon Daylight */ { "hst", tZONE, HOUR(10) }, /* Hawaii Standard */ { "hdt", tDAYZONE, HOUR(10) }, /* Hawaii Daylight */ { "cat", tZONE, HOUR(10) }, /* Central Alaska */ { "ahst", tZONE, HOUR(10) }, /* Alaska-Hawaii Standard */ { "nt", tZONE, HOUR(11) }, /* Nome */ { "idlw", tZONE, HOUR(12) }, /* International Date Line West */ { "cet", tZONE, -HOUR(1) }, /* Central European */ { "met", tZONE, -HOUR(1) }, /* Middle European */ { "mewt", tZONE, -HOUR(1) }, /* Middle European Winter */ { "mest", tDAYZONE, -HOUR(1) }, /* Middle European Summer */ { "swt", tZONE, -HOUR(1) }, /* Swedish Winter */ { "sst", tDAYZONE, -HOUR(1) }, /* Swedish Summer */ { "fwt", tZONE, -HOUR(1) }, /* French Winter */ { "fst", tDAYZONE, -HOUR(1) }, /* French Summer */ { "eet", tZONE, -HOUR(2) }, /* Eastern Europe, USSR Zone 1 */ { "bt", tZONE, -HOUR(3) }, /* Baghdad, USSR Zone 2 */ #if 0 { "it", tZONE, -HOUR(3.5) },/* Iran */ #endif { "zp4", tZONE, -HOUR(4) }, /* USSR Zone 3 */ { "zp5", tZONE, -HOUR(5) }, /* USSR Zone 4 */ #if 0 { "ist", tZONE, -HOUR(5.5) },/* Indian Standard */ #endif { "zp6", tZONE, -HOUR(6) }, /* USSR Zone 5 */ #if 0 /* For completeness. NST is also Newfoundland Stanard, and SST is * also Swedish Summer. */ { "nst", tZONE, -HOUR(6.5) },/* North Sumatra */ { "sst", tZONE, -HOUR(7) }, /* South Sumatra, USSR Zone 6 */ #endif /* 0 */ { "wast", tZONE, -HOUR(7) }, /* West Australian Standard */ { "wadt", tDAYZONE, -HOUR(7) }, /* West Australian Daylight */ #if 0 { "jt", tZONE, -HOUR(7.5) },/* Java (3pm in Cronusland!) */ #endif { "cct", tZONE, -HOUR(8) }, /* China Coast, USSR Zone 7 */ { "jst", tZONE, -HOUR(9) }, /* Japan Standard, USSR Zone 8 */ #if 0 { "cast", tZONE, -HOUR(9.5) },/* Central Australian Standard */ { "cadt", tDAYZONE, -HOUR(9.5) },/* Central Australian Daylight */ #endif { "east", tZONE, -HOUR(10) }, /* Eastern Australian Standard */ { "eadt", tDAYZONE, -HOUR(10) }, /* Eastern Australian Daylight */ { "gst", tZONE, -HOUR(10) }, /* Guam Standard, USSR Zone 9 */ { "nzt", tZONE, -HOUR(12) }, /* New Zealand */ { "nzst", tZONE, -HOUR(12) }, /* New Zealand Standard */ { "nzdt", tDAYZONE, -HOUR(12) }, /* New Zealand Daylight */ { "idle", tZONE, -HOUR(12) }, /* International Date Line East */ { NULL } }; /* Military timezone table. */ static TABLE const MilitaryTable[] = { { "a", tZONE, HOUR( 1) }, { "b", tZONE, HOUR( 2) }, { "c", tZONE, HOUR( 3) }, { "d", tZONE, HOUR( 4) }, { "e", tZONE, HOUR( 5) }, { "f", tZONE, HOUR( 6) }, { "g", tZONE, HOUR( 7) }, { "h", tZONE, HOUR( 8) }, { "i", tZONE, HOUR( 9) }, { "k", tZONE, HOUR( 10) }, { "l", tZONE, HOUR( 11) }, { "m", tZONE, HOUR( 12) }, { "n", tZONE, HOUR(- 1) }, { "o", tZONE, HOUR(- 2) }, { "p", tZONE, HOUR(- 3) }, { "q", tZONE, HOUR(- 4) }, { "r", tZONE, HOUR(- 5) }, { "s", tZONE, HOUR(- 6) }, { "t", tZONE, HOUR(- 7) }, { "u", tZONE, HOUR(- 8) }, { "v", tZONE, HOUR(- 9) }, { "w", tZONE, HOUR(-10) }, { "x", tZONE, HOUR(-11) }, { "y", tZONE, HOUR(-12) }, { "z", tZONE, HOUR( 0) }, { NULL } }; /* ARGSUSED */ static int yyerror(s) char *s; { return 0; } static time_t ToSeconds(Hours, Minutes, Seconds, Meridian) time_t Hours; time_t Minutes; time_t Seconds; MERIDIAN Meridian; { if (Minutes < 0 || Minutes > 59 || Seconds < 0 || Seconds > 59) return -1; switch (Meridian) { case MER24: if (Hours < 0 || Hours > 23) return -1; return (Hours * 60L + Minutes) * 60L + Seconds; case MERam: if (Hours < 1 || Hours > 12) return -1; return (Hours * 60L + Minutes) * 60L + Seconds; case MERpm: if (Hours < 1 || Hours > 12) return -1; return ((Hours + 12) * 60L + Minutes) * 60L + Seconds; default: abort (); } /* NOTREACHED */ } static time_t Convert(Month, Day, Year, Hours, Minutes, Seconds, Meridian, DSTmode) time_t Month; time_t Day; time_t Year; time_t Hours; time_t Minutes; time_t Seconds; MERIDIAN Meridian; DSTMODE DSTmode; { static int DaysInMonth[12] = { 31, 0, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }; time_t tod; time_t Julian; int i; if (Year < 0) Year = -Year; if (Year < 100) Year += 1900; DaysInMonth[1] = Year % 4 == 0 && (Year % 100 != 0 || Year % 400 == 0) ? 29 : 28; if (Year < EPOCH || Year > 1999 || Month < 1 || Month > 12 /* Lint fluff: "conversion from long may lose accuracy" */ || Day < 1 || Day > DaysInMonth[(int)--Month]) return -1; for (Julian = Day - 1, i = 0; i < Month; i++) Julian += DaysInMonth[i]; for (i = EPOCH; i < Year; i++) Julian += 365 + (i % 4 == 0); Julian *= SECSPERDAY; Julian += yyTimezone * 60L; if ((tod = ToSeconds(Hours, Minutes, Seconds, Meridian)) < 0) return -1; Julian += tod; if (DSTmode == DSTon || (DSTmode == DSTmaybe && localtime(&Julian)->tm_isdst)) Julian -= 60 * 60; return Julian; } static time_t DSTcorrect(Start, Future) time_t Start; time_t Future; { time_t StartDay; time_t FutureDay; StartDay = (localtime(&Start)->tm_hour + 1) % 24; FutureDay = (localtime(&Future)->tm_hour + 1) % 24; return (Future - Start) + (StartDay - FutureDay) * 60L * 60L; } static time_t RelativeDate(Start, DayOrdinal, DayNumber) time_t Start; time_t DayOrdinal; time_t DayNumber; { struct tm *tm; time_t now; now = Start; tm = localtime(&now); now += SECSPERDAY * ((DayNumber - tm->tm_wday + 7) % 7); now += 7 * SECSPERDAY * (DayOrdinal <= 0 ? DayOrdinal : DayOrdinal - 1); return DSTcorrect(Start, now); } static time_t RelativeMonth(Start, RelMonth) time_t Start; time_t RelMonth; { struct tm *tm; time_t Month; time_t Year; if (RelMonth == 0) return 0; tm = localtime(&Start); Month = 12 * tm->tm_year + tm->tm_mon + RelMonth; Year = Month / 12; Month = Month % 12 + 1; return DSTcorrect(Start, Convert(Month, (time_t)tm->tm_mday, Year, (time_t)tm->tm_hour, (time_t)tm->tm_min, (time_t)tm->tm_sec, MER24, DSTmaybe)); } static int LookupWord(buff) char *buff; { register char *p; register char *q; register const TABLE *tp; int i; int abbrev; /* Make it lowercase. */ for (p = buff; *p; p++) if (isupper(*p)) *p = tolower(*p); if (strcmp(buff, "am") == 0 || strcmp(buff, "a.m.") == 0) { yylval.Meridian = MERam; return tMERIDIAN; } if (strcmp(buff, "pm") == 0 || strcmp(buff, "p.m.") == 0) { yylval.Meridian = MERpm; return tMERIDIAN; } /* See if we have an abbreviation for a month. */ if (strlen(buff) == 3) abbrev = 1; else if (strlen(buff) == 4 && buff[3] == '.') { abbrev = 1; buff[3] = '\0'; } else abbrev = 0; for (tp = MonthDayTable; tp->name; tp++) { if (abbrev) { if (strncmp(buff, tp->name, 3) == 0) { yylval.Number = tp->value; return tp->type; } } else if (strcmp(buff, tp->name) == 0) { yylval.Number = tp->value; return tp->type; } } for (tp = TimezoneTable; tp->name; tp++) if (strcmp(buff, tp->name) == 0) { yylval.Number = tp->value; return tp->type; } if (strcmp(buff, "dst") == 0) return tDST; for (tp = UnitsTable; tp->name; tp++) if (strcmp(buff, tp->name) == 0) { yylval.Number = tp->value; return tp->type; } /* Strip off any plural and try the units table again. */ i = strlen(buff) - 1; if (buff[i] == 's') { buff[i] = '\0'; for (tp = UnitsTable; tp->name; tp++) if (strcmp(buff, tp->name) == 0) { yylval.Number = tp->value; return tp->type; } buff[i] = 's'; /* Put back for "this" in OtherTable. */ } for (tp = OtherTable; tp->name; tp++) if (strcmp(buff, tp->name) == 0) { yylval.Number = tp->value; return tp->type; } /* Military timezones. */ if (buff[1] == '\0' && isalpha(*buff)) { for (tp = MilitaryTable; tp->name; tp++) if (strcmp(buff, tp->name) == 0) { yylval.Number = tp->value; return tp->type; } } /* Drop out any periods and try the timezone table again. */ for (i = 0, p = q = buff; *q; q++) if (*q != '.') *p++ = *q; else i++; *p = '\0'; if (i) for (tp = TimezoneTable; tp->name; tp++) if (strcmp(buff, tp->name) == 0) { yylval.Number = tp->value; return tp->type; } return tID; } static int yylex() { register char c; register char *p; char buff[20]; int Count; int sign; for ( ; ; ) { while (isspace(*yyInput)) yyInput++; if (isdigit(c = *yyInput) || c == '-' || c == '+') { if (c == '-' || c == '+') { sign = c == '-' ? -1 : 1; if (!isdigit(*++yyInput)) /* skip the '-' sign */ continue; } else sign = 0; for (yylval.Number = 0; isdigit(c = *yyInput++); ) yylval.Number = 10 * yylval.Number + c - '0'; yyInput--; if (sign < 0) yylval.Number = -yylval.Number; return sign ? tSNUMBER : tUNUMBER; } if (isalpha(c)) { for (p = buff; isalpha(c = *yyInput++) || c == '.'; ) if (p < &buff[sizeof buff - 1]) *p++ = c; *p = '\0'; yyInput--; return LookupWord(buff); } if (c != '(') return *yyInput++; Count = 0; do { c = *yyInput++; if (c == '\0') return c; if (c == '(') Count++; else if (c == ')') Count--; } while (Count > 0); } } #define TM_YEAR_ORIGIN 1900 /* Yield A - B, measured in seconds. */ static long difftm (a, b) struct tm *a, *b; { int ay = a->tm_year + (TM_YEAR_ORIGIN - 1); int by = b->tm_year + (TM_YEAR_ORIGIN - 1); int days = ( /* difference in day of year */ a->tm_yday - b->tm_yday /* + intervening leap days */ + ((ay >> 2) - (by >> 2)) - (ay/100 - by/100) + ((ay/100 >> 2) - (by/100 >> 2)) /* + difference in years * 365 */ + (long)(ay-by) * 365 ); return (60*(60*(24*days + (a->tm_hour - b->tm_hour)) + (a->tm_min - b->tm_min)) + (a->tm_sec - b->tm_sec)); } time_t get_date(p, now) char *p; struct timeb *now; { struct tm *tm, gmt; struct timeb ftz; time_t Start; time_t tod; yyInput = p; if (now == NULL) { now = &ftz; (void)time(&ftz.time); if (! (tm = gmtime (&ftz.time))) return -1; gmt = *tm; /* Make a copy, in case localtime modifies *tm. */ if (! (tm = localtime (&ftz.time))) return -1; ftz.timezone = difftm (&gmt, tm) / 60; if(tm->tm_isdst) ftz.timezone += 60; } tm = localtime(&now->time); yyYear = tm->tm_year; yyMonth = tm->tm_mon + 1; yyDay = tm->tm_mday; yyTimezone = now->timezone; yyDSTmode = DSTmaybe; yyHour = 0; yyMinutes = 0; yySeconds = 0; yyMeridian = MER24; yyRelSeconds = 0; yyRelMonth = 0; yyHaveDate = 0; yyHaveDay = 0; yyHaveRel = 0; yyHaveTime = 0; yyHaveZone = 0; if (yyparse() || yyHaveTime > 1 || yyHaveZone > 1 || yyHaveDate > 1 || yyHaveDay > 1) return -1; if (yyHaveDate || yyHaveTime || yyHaveDay) { Start = Convert(yyMonth, yyDay, yyYear, yyHour, yyMinutes, yySeconds, yyMeridian, yyDSTmode); if (Start < 0) return -1; } else { Start = now->time; if (!yyHaveRel) Start -= ((tm->tm_hour * 60L + tm->tm_min) * 60L) + tm->tm_sec; } Start += yyRelSeconds; Start += RelativeMonth(Start, yyRelMonth); if (yyHaveDay && !yyHaveDate) { tod = RelativeDate(Start, yyDayOrdinal, yyDayNumber); Start += tod; } /* Have to do *something* with a legitimate -1 so it's distinguishable * from the error return value. (Alternately could set errno on error.) */ return Start == -1 ? 0 : Start; } #if defined(TEST) /* ARGSUSED */ int main(ac, av) int ac; char *av[]; { char buff[128]; time_t d; (void)printf("Enter date, or blank line to exit.\n\t> "); (void)fflush(stdout); while (gets(buff) && buff[0]) { d = get_date(buff, (struct timeb *)NULL); if (d == -1) (void)printf("Bad format - couldn't convert.\n"); else (void)printf("%s", ctime(&d)); (void)printf("\t> "); (void)fflush(stdout); } exit(0); /* NOTREACHED */ } #endif /* defined(TEST) */ sh-utils-1.10/lib/posixtm.c100666 74504 1 56561 5566761164 15221 0ustar meyeringdaemon /* A Bison parser, made from ./posixtm.y with Bison version GNU Bison version 1.22 */ #define YYBISON 1 /* Identify Bison output. */ #define DIGIT 258 #line 19 "./posixtm.y" #ifdef HAVE_CONFIG_H #if defined (CONFIG_BROKETS) /* We use instead of "config.h" so that a compilation using -I. -I$srcdir will use ./config.h rather than $srcdir/config.h (which it would do because it found this file in $srcdir). */ #include #else #include "config.h" #endif #endif /* The following block of alloca-related preprocessor directives is here solely to allow compilation by non GNU-C compilers of the C parser produced from this file by old versions of bison. Newer versions of bison include a block similar to this one in bison.simple. */ #ifdef __GNUC__ #define alloca __builtin_alloca #else #ifdef HAVE_ALLOCA_H #include #else #ifdef _AIX #pragma alloca #else void *alloca (); #endif #endif #endif #include #include #ifdef TM_IN_SYS_TIME #include #else #include #endif /* Some old versions of bison generate parsers that use bcopy. That loses on systems that don't provide the function, so we have to redefine it here. */ #if !defined (HAVE_BCOPY) && defined (HAVE_MEMCPY) && !defined (bcopy) #define bcopy(from, to, len) memcpy ((to), (from), (len)) #endif #define YYDEBUG 1 /* Lexical analyzer's current scan position in the input string. */ static char *curpos; /* The return value. */ static struct tm t; time_t mktime (); #define zzparse posixtime_zzparse static int zzlex (); static int zzerror (); #ifndef YYLTYPE typedef struct zzltype { int timestamp; int first_line; int first_column; int last_line; int last_column; char *text; } zzltype; #define YYLTYPE zzltype #endif #ifndef YYSTYPE #define YYSTYPE int #endif #include #ifndef __cplusplus #ifndef __STDC__ #define const #endif #endif #define YYFINAL 15 #define YYFLAG -32768 #define YYNTBASE 5 #define YYTRANSLATE(x) ((unsigned)(x) <= 258 ? zztranslate[x] : 9) static const char zztranslate[] = { 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 4, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 2, 3 }; #if YYDEBUG != 0 static const short zzprhs[] = { 0, 0, 7, 9, 12, 13, 14, 17 }; static const short zzrhs[] = { 8, 8, 8, 8, 6, 7, 0, 8, 0, 8, 8, 0, 0, 0, 4, 8, 0, 3, 3, 0 }; #endif #if YYDEBUG != 0 static const short zzrline[] = { 0, 85, 114, 121, 128, 139, 142, 151 }; static const char * const zztname[] = { "$","error","$illegal.","DIGIT","'.'", "date","year","seconds","digitpair","" }; #endif static const short zzr1[] = { 0, 5, 6, 6, 6, 7, 7, 8 }; static const short zzr2[] = { 0, 6, 1, 2, 0, 0, 2, 2 }; static const short zzdefact[] = { 0, 0, 0, 7, 0, 0, 4, 5, 2, 0, 1, 3, 6, 0, 0, 0 }; static const short zzdefgoto[] = { 13, 7, 10, 2 }; static const short zzpact[] = { 2, 5, 2,-32768, 2, 2, 2, -3, 2, 2,-32768, -32768,-32768, 9, 10,-32768 }; static const short zzpgoto[] = {-32768, -32768,-32768, -2 }; #define YYLAST 10 static const short zztable[] = { 4, 9, 5, 6, 8, 1, 11, 12, 3, 14, 15 }; static const short zzcheck[] = { 2, 4, 4, 5, 6, 3, 8, 9, 3, 0, 0 }; /* -*-C-*- Note some compilers choke on comments on `#line' lines. */ #line 3 "/usr/local/lib/bison.simple" /* Skeleton output parser for bison, Copyright (C) 1984, 1989, 1990 Bob Corbett and Richard Stallman 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 1, 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, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #ifndef alloca #ifdef __GNUC__ #define alloca __builtin_alloca #else /* not GNU C. */ #if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi) #include #else /* not sparc */ #if defined (MSDOS) && !defined (__TURBOC__) #include #else /* not MSDOS, or __TURBOC__ */ #if defined(_AIX) #include #pragma alloca #else /* not MSDOS, __TURBOC__, or _AIX */ #ifdef __hpux #ifdef __cplusplus extern "C" { void *alloca (unsigned int); }; #else /* not __cplusplus */ void *alloca (); #endif /* not __cplusplus */ #endif /* __hpux */ #endif /* not _AIX */ #endif /* not MSDOS, or __TURBOC__ */ #endif /* not sparc. */ #endif /* not GNU C. */ #endif /* alloca not defined. */ /* This is the parser code that is written into each bison parser when the %semantic_parser declaration is not specified in the grammar. It was written by Richard Stallman by simplifying the hairy parser used when %semantic_parser is specified. */ /* Note: there must be only one dollar sign in this file. It is replaced by the list of actions, each action as one case of the switch. */ #define zzerrok (zzerrstatus = 0) #define zzclearin (zzchar = YYEMPTY) #define YYEMPTY -2 #define YYEOF 0 #define YYACCEPT return(0) #define YYABORT return(1) #define YYERROR goto zzerrlab1 /* Like YYERROR except do call zzerror. This remains here temporarily to ease the transition to the new meaning of YYERROR, for GCC. Once GCC version 2 has supplanted version 1, this can go. */ #define YYFAIL goto zzerrlab #define YYRECOVERING() (!!zzerrstatus) #define YYBACKUP(token, value) \ do \ if (zzchar == YYEMPTY && zzlen == 1) \ { zzchar = (token), zzlval = (value); \ zzchar1 = YYTRANSLATE (zzchar); \ YYPOPSTACK; \ goto zzbackup; \ } \ else \ { zzerror ("syntax error: cannot back up"); YYERROR; } \ while (0) #define YYTERROR 1 #define YYERRCODE 256 #ifndef YYPURE #define YYLEX zzlex() #endif #ifdef YYPURE #ifdef YYLSP_NEEDED #define YYLEX zzlex(&zzlval, &zzlloc) #else #define YYLEX zzlex(&zzlval) #endif #endif /* If nonreentrant, generate the variables here */ #ifndef YYPURE int zzchar; /* the lookahead symbol */ YYSTYPE zzlval; /* the semantic value of the */ /* lookahead symbol */ #ifdef YYLSP_NEEDED YYLTYPE zzlloc; /* location data for the lookahead */ /* symbol */ #endif int zznerrs; /* number of parse errors so far */ #endif /* not YYPURE */ #if YYDEBUG != 0 int zzdebug; /* nonzero means print parse trace */ /* Since this is uninitialized, it does not stop multiple parsers from coexisting. */ #endif /* YYINITDEPTH indicates the initial size of the parser's stacks */ #ifndef YYINITDEPTH #define YYINITDEPTH 200 #endif /* YYMAXDEPTH is the maximum size the stacks can grow to (effective only if the built-in stack extension method is used). */ #if YYMAXDEPTH == 0 #undef YYMAXDEPTH #endif #ifndef YYMAXDEPTH #define YYMAXDEPTH 10000 #endif /* Prevent warning if -Wstrict-prototypes. */ #ifdef __GNUC__ int zzparse (void); #endif #if __GNUC__ > 1 /* GNU C and GNU C++ define this. */ #define __zz_bcopy(FROM,TO,COUNT) __builtin_memcpy(TO,FROM,COUNT) #else /* not GNU C or C++ */ #ifndef __cplusplus /* This is the most reliable way to avoid incompatibilities in available built-in functions on various systems. */ static void __zz_bcopy (from, to, count) char *from; char *to; int count; { register char *f = from; register char *t = to; register int i = count; while (i-- > 0) *t++ = *f++; } #else /* __cplusplus */ /* This is the most reliable way to avoid incompatibilities in available built-in functions on various systems. */ static void __zz_bcopy (char *from, char *to, int count) { register char *f = from; register char *t = to; register int i = count; while (i-- > 0) *t++ = *f++; } #endif #endif #line 184 "/usr/local/lib/bison.simple" int zzparse() { register int zzstate; register int zzn; register short *zzssp; register YYSTYPE *zzvsp; int zzerrstatus; /* number of tokens to shift before error messages enabled */ int zzchar1 = 0; /* lookahead token as an internal (translated) token number */ short zzssa[YYINITDEPTH]; /* the state stack */ YYSTYPE zzvsa[YYINITDEPTH]; /* the semantic value stack */ short *zzss = zzssa; /* refer to the stacks thru separate pointers */ YYSTYPE *zzvs = zzvsa; /* to allow zzoverflow to reallocate them elsewhere */ #ifdef YYLSP_NEEDED YYLTYPE zzlsa[YYINITDEPTH]; /* the location stack */ YYLTYPE *zzls = zzlsa; YYLTYPE *zzlsp; #define YYPOPSTACK (zzvsp--, zzssp--, zzlsp--) #else #define YYPOPSTACK (zzvsp--, zzssp--) #endif int zzstacksize = YYINITDEPTH; #ifdef YYPURE int zzchar; YYSTYPE zzlval; int zznerrs; #ifdef YYLSP_NEEDED YYLTYPE zzlloc; #endif #endif YYSTYPE zzval; /* the variable used to return */ /* semantic values from the action */ /* routines */ int zzlen; #if YYDEBUG != 0 if (zzdebug) fprintf(stderr, "Starting parse\n"); #endif zzstate = 0; zzerrstatus = 0; zznerrs = 0; zzchar = YYEMPTY; /* Cause a token to be read. */ /* Initialize stack pointers. Waste one element of value and location stack so that they stay on the same level as the state stack. The wasted elements are never initialized. */ zzssp = zzss - 1; zzvsp = zzvs; #ifdef YYLSP_NEEDED zzlsp = zzls; #endif /* Push a new state, which is found in zzstate . */ /* In all cases, when you get here, the value and location stacks have just been pushed. so pushing a state here evens the stacks. */ zznewstate: *++zzssp = zzstate; if (zzssp >= zzss + zzstacksize - 1) { /* Give user a chance to reallocate the stack */ /* Use copies of these so that the &'s don't force the real ones into memory. */ YYSTYPE *zzvs1 = zzvs; short *zzss1 = zzss; #ifdef YYLSP_NEEDED YYLTYPE *zzls1 = zzls; #endif /* Get the current used size of the three stacks, in elements. */ int size = zzssp - zzss + 1; #ifdef zzoverflow /* Each stack pointer address is followed by the size of the data in use in that stack, in bytes. */ #ifdef YYLSP_NEEDED /* This used to be a conditional around just the two extra args, but that might be undefined if zzoverflow is a macro. */ zzoverflow("parser stack overflow", &zzss1, size * sizeof (*zzssp), &zzvs1, size * sizeof (*zzvsp), &zzls1, size * sizeof (*zzlsp), &zzstacksize); #else zzoverflow("parser stack overflow", &zzss1, size * sizeof (*zzssp), &zzvs1, size * sizeof (*zzvsp), &zzstacksize); #endif zzss = zzss1; zzvs = zzvs1; #ifdef YYLSP_NEEDED zzls = zzls1; #endif #else /* no zzoverflow */ /* Extend the stack our own way. */ if (zzstacksize >= YYMAXDEPTH) { zzerror("parser stack overflow"); return 2; } zzstacksize *= 2; if (zzstacksize > YYMAXDEPTH) zzstacksize = YYMAXDEPTH; zzss = (short *) alloca (zzstacksize * sizeof (*zzssp)); __zz_bcopy ((char *)zzss1, (char *)zzss, size * sizeof (*zzssp)); zzvs = (YYSTYPE *) alloca (zzstacksize * sizeof (*zzvsp)); __zz_bcopy ((char *)zzvs1, (char *)zzvs, size * sizeof (*zzvsp)); #ifdef YYLSP_NEEDED zzls = (YYLTYPE *) alloca (zzstacksize * sizeof (*zzlsp)); __zz_bcopy ((char *)zzls1, (char *)zzls, size * sizeof (*zzlsp)); #endif #endif /* no zzoverflow */ zzssp = zzss + size - 1; zzvsp = zzvs + size - 1; #ifdef YYLSP_NEEDED zzlsp = zzls + size - 1; #endif #if YYDEBUG != 0 if (zzdebug) fprintf(stderr, "Stack size increased to %d\n", zzstacksize); #endif if (zzssp >= zzss + zzstacksize - 1) YYABORT; } #if YYDEBUG != 0 if (zzdebug) fprintf(stderr, "Entering state %d\n", zzstate); #endif goto zzbackup; zzbackup: /* Do appropriate processing given the current state. */ /* Read a lookahead token if we need one and don't already have one. */ /* zzresume: */ /* First try to decide what to do without reference to lookahead token. */ zzn = zzpact[zzstate]; if (zzn == YYFLAG) goto zzdefault; /* Not known => get a lookahead token if don't already have one. */ /* zzchar is either YYEMPTY or YYEOF or a valid token in external form. */ if (zzchar == YYEMPTY) { #if YYDEBUG != 0 if (zzdebug) fprintf(stderr, "Reading a token: "); #endif zzchar = YYLEX; } /* Convert token to internal form (in zzchar1) for indexing tables with */ if (zzchar <= 0) /* This means end of input. */ { zzchar1 = 0; zzchar = YYEOF; /* Don't call YYLEX any more */ #if YYDEBUG != 0 if (zzdebug) fprintf(stderr, "Now at end of input.\n"); #endif } else { zzchar1 = YYTRANSLATE(zzchar); #if YYDEBUG != 0 if (zzdebug) { fprintf (stderr, "Next token is %d (%s", zzchar, zztname[zzchar1]); /* Give the individual parser a way to print the precise meaning of a token, for further debugging info. */ #ifdef YYPRINT YYPRINT (stderr, zzchar, zzlval); #endif fprintf (stderr, ")\n"); } #endif } zzn += zzchar1; if (zzn < 0 || zzn > YYLAST || zzcheck[zzn] != zzchar1) goto zzdefault; zzn = zztable[zzn]; /* zzn is what to do for this token type in this state. Negative => reduce, -zzn is rule number. Positive => shift, zzn is new state. New state is final state => don't bother to shift, just return success. 0, or most negative number => error. */ if (zzn < 0) { if (zzn == YYFLAG) goto zzerrlab; zzn = -zzn; goto zzreduce; } else if (zzn == 0) goto zzerrlab; if (zzn == YYFINAL) YYACCEPT; /* Shift the lookahead token. */ #if YYDEBUG != 0 if (zzdebug) fprintf(stderr, "Shifting token %d (%s), ", zzchar, zztname[zzchar1]); #endif /* Discard the token being shifted unless it is eof. */ if (zzchar != YYEOF) zzchar = YYEMPTY; *++zzvsp = zzlval; #ifdef YYLSP_NEEDED *++zzlsp = zzlloc; #endif /* count tokens shifted since error; after three, turn off error status. */ if (zzerrstatus) zzerrstatus--; zzstate = zzn; goto zznewstate; /* Do the default action for the current state. */ zzdefault: zzn = zzdefact[zzstate]; if (zzn == 0) goto zzerrlab; /* Do a reduction. zzn is the number of a rule to reduce with. */ zzreduce: zzlen = zzr2[zzn]; if (zzlen > 0) zzval = zzvsp[1-zzlen]; /* implement default value of the action */ #if YYDEBUG != 0 if (zzdebug) { int i; fprintf (stderr, "Reducing via rule %d (line %d), ", zzn, zzrline[zzn]); /* Print the symbols being reduced, and their result. */ for (i = zzprhs[zzn]; zzrhs[i] > 0; i++) fprintf (stderr, "%s ", zztname[zzrhs[i]]); fprintf (stderr, " -> %s\n", zztname[zzr1[zzn]]); } #endif switch (zzn) { case 1: #line 91 "./posixtm.y" { if (zzvsp[-5] >= 1 && zzvsp[-5] <= 12) t.tm_mon = zzvsp[-5] - 1; else { YYABORT; } if (zzvsp[-4] >= 1 && zzvsp[-4] <= 31) t.tm_mday = zzvsp[-4]; else { YYABORT; } if (zzvsp[-3] >= 0 && zzvsp[-3] <= 23) t.tm_hour = zzvsp[-3]; else { YYABORT; } if (zzvsp[-2] >= 0 && zzvsp[-2] <= 59) t.tm_min = zzvsp[-2]; else { YYABORT; } ; break;} case 2: #line 114 "./posixtm.y" { t.tm_year = zzvsp[0]; /* Deduce the century based on the year. See POSIX.2 section 4.63.3. */ if (zzvsp[0] <= 68) t.tm_year += 100; ; break;} case 3: #line 121 "./posixtm.y" { t.tm_year = zzvsp[-1] * 100 + zzvsp[0]; if (t.tm_year < 1900) { YYABORT; } else t.tm_year -= 1900; ; break;} case 4: #line 128 "./posixtm.y" { time_t now; struct tm *tmp; /* Use current year. */ time (&now); tmp = localtime (&now); t.tm_year = tmp->tm_year; ; break;} case 5: #line 139 "./posixtm.y" { t.tm_sec = 0; ; break;} case 6: #line 142 "./posixtm.y" { if (zzvsp[0] >= 0 && zzvsp[0] <= 61) t.tm_sec = zzvsp[0]; else { YYABORT; } ; break;} case 7: #line 151 "./posixtm.y" { zzval = zzvsp[-1] * 10 + zzvsp[0]; ; break;} } /* the action file gets copied in in place of this dollarsign */ #line 465 "/usr/local/lib/bison.simple" zzvsp -= zzlen; zzssp -= zzlen; #ifdef YYLSP_NEEDED zzlsp -= zzlen; #endif #if YYDEBUG != 0 if (zzdebug) { short *ssp1 = zzss - 1; fprintf (stderr, "state stack now"); while (ssp1 != zzssp) fprintf (stderr, " %d", *++ssp1); fprintf (stderr, "\n"); } #endif *++zzvsp = zzval; #ifdef YYLSP_NEEDED zzlsp++; if (zzlen == 0) { zzlsp->first_line = zzlloc.first_line; zzlsp->first_column = zzlloc.first_column; zzlsp->last_line = (zzlsp-1)->last_line; zzlsp->last_column = (zzlsp-1)->last_column; zzlsp->text = 0; } else { zzlsp->last_line = (zzlsp+zzlen-1)->last_line; zzlsp->last_column = (zzlsp+zzlen-1)->last_column; } #endif /* Now "shift" the result of the reduction. Determine what state that goes to, based on the state we popped back to and the rule number reduced by. */ zzn = zzr1[zzn]; zzstate = zzpgoto[zzn - YYNTBASE] + *zzssp; if (zzstate >= 0 && zzstate <= YYLAST && zzcheck[zzstate] == *zzssp) zzstate = zztable[zzstate]; else zzstate = zzdefgoto[zzn - YYNTBASE]; goto zznewstate; zzerrlab: /* here on detecting error */ if (! zzerrstatus) /* If not already recovering from an error, report this error. */ { ++zznerrs; #ifdef YYERROR_VERBOSE zzn = zzpact[zzstate]; if (zzn > YYFLAG && zzn < YYLAST) { int size = 0; char *msg; int x, count; count = 0; /* Start X at -zzn if nec to avoid negative indexes in zzcheck. */ for (x = (zzn < 0 ? -zzn : 0); x < (sizeof(zztname) / sizeof(char *)); x++) if (zzcheck[x + zzn] == x) size += strlen(zztname[x]) + 15, count++; msg = (char *) malloc(size + 15); if (msg != 0) { strcpy(msg, "parse error"); if (count < 5) { count = 0; for (x = (zzn < 0 ? -zzn : 0); x < (sizeof(zztname) / sizeof(char *)); x++) if (zzcheck[x + zzn] == x) { strcat(msg, count == 0 ? ", expecting `" : " or `"); strcat(msg, zztname[x]); strcat(msg, "'"); count++; } } zzerror(msg); free(msg); } else zzerror ("parse error; also virtual memory exceeded"); } else #endif /* YYERROR_VERBOSE */ zzerror("parse error"); } goto zzerrlab1; zzerrlab1: /* here on error raised explicitly by an action */ if (zzerrstatus == 3) { /* if just tried and failed to reuse lookahead token after an error, discard it. */ /* return failure if at end of input */ if (zzchar == YYEOF) YYABORT; #if YYDEBUG != 0 if (zzdebug) fprintf(stderr, "Discarding token %d (%s).\n", zzchar, zztname[zzchar1]); #endif zzchar = YYEMPTY; } /* Else will try to reuse lookahead token after shifting the error token. */ zzerrstatus = 3; /* Each real token shifted decrements this */ goto zzerrhandle; zzerrdefault: /* current state does not do anything special for the error token. */ #if 0 /* This is wrong; only states that explicitly want error tokens should shift them. */ zzn = zzdefact[zzstate]; /* If its default is to accept any token, ok. Otherwise pop it.*/ if (zzn) goto zzdefault; #endif zzerrpop: /* pop the current state because it cannot handle the error token */ if (zzssp == zzss) YYABORT; zzvsp--; zzstate = *--zzssp; #ifdef YYLSP_NEEDED zzlsp--; #endif #if YYDEBUG != 0 if (zzdebug) { short *ssp1 = zzss - 1; fprintf (stderr, "Error: state stack now"); while (ssp1 != zzssp) fprintf (stderr, " %d", *++ssp1); fprintf (stderr, "\n"); } #endif zzerrhandle: zzn = zzpact[zzstate]; if (zzn == YYFLAG) goto zzerrdefault; zzn += YYTERROR; if (zzn < 0 || zzn > YYLAST || zzcheck[zzn] != YYTERROR) goto zzerrdefault; zzn = zztable[zzn]; if (zzn < 0) { if (zzn == YYFLAG) goto zzerrpop; zzn = -zzn; goto zzreduce; } else if (zzn == 0) goto zzerrpop; if (zzn == YYFINAL) YYACCEPT; #if YYDEBUG != 0 if (zzdebug) fprintf(stderr, "Shifting error token, "); #endif *++zzvsp = zzlval; #ifdef YYLSP_NEEDED *++zzlsp = zzlloc; #endif zzstate = zzn; goto zznewstate; } #line 155 "./posixtm.y" static int zzlex () { char ch = *curpos++; if (ch >= '0' && ch <= '9') { zzlval = ch - '0'; return DIGIT; } else if (ch == '.' || ch == 0) return ch; else return '?'; /* Cause an error. */ } static int zzerror () { return 0; } /* Parse a POSIX-style date and return it, or (time_t)-1 for an error. */ time_t posixtime (s) char *s; { curpos = s; /* Let mktime decide whether it is daylight savings time. */ t.tm_isdst = -1; if (zzparse ()) return (time_t)-1; else return mktime (&t); } /* Parse a POSIX-style date and return it, or NULL for an error. */ struct tm * posixtm (s) char *s; { if (posixtime (s) == -1) return NULL; return &t; } sh-utils-1.10/lib/regex.c100666 74504 13 515075 5562460332 14373 0ustar meyeringuser/* Extended regular expression matching and search library, version 0.12. (Implements POSIX draft P10003.2/D11.2, except for internationalization features.) Copyright (C) 1993, 1994 Free Software Foundation, Inc. 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 2, 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, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ /* AIX requires this to be the first thing in the file. */ #if defined (_AIX) && !defined (REGEX_MALLOC) #pragma alloca #endif #define _GNU_SOURCE #ifdef HAVE_CONFIG_H #if defined (emacs) || defined (CONFIG_BROKETS) /* We use instead of "config.h" so that a compilation using -I. -I$srcdir will use ./config.h rather than $srcdir/config.h (which it would do because it found this file in $srcdir). */ #include #else #include "config.h" #endif #endif /* We need this for `regex.h', and perhaps for the Emacs include files. */ #include /* The `emacs' switch turns on certain matching commands that make sense only in Emacs. */ #ifdef emacs #include "lisp.h" #include "buffer.h" #include "syntax.h" /* Emacs uses `NULL' as a predicate. */ #undef NULL #else /* not emacs */ #ifdef STDC_HEADERS #include #else char *malloc (); char *realloc (); #endif /* We used to test for `BSTRING' here, but only GCC and Emacs define `BSTRING', as far as I know, and neither of them use this code. */ #ifndef INHIBIT_STRING_HEADER #if HAVE_STRING_H || STDC_HEADERS #include #ifndef bcmp #define bcmp(s1, s2, n) memcmp ((s1), (s2), (n)) #endif #ifndef bcopy #define bcopy(s, d, n) memcpy ((d), (s), (n)) #endif #ifndef bzero #define bzero(s, n) memset ((s), 0, (n)) #endif #else #include #endif #endif /* Define the syntax stuff for \<, \>, etc. */ /* This must be nonzero for the wordchar and notwordchar pattern commands in re_match_2. */ #ifndef Sword #define Sword 1 #endif #ifdef SYNTAX_TABLE extern char *re_syntax_table; #else /* not SYNTAX_TABLE */ /* How many characters in the character set. */ #define CHAR_SET_SIZE 256 static char re_syntax_table[CHAR_SET_SIZE]; static void init_syntax_once () { register int c; static int done = 0; if (done) return; bzero (re_syntax_table, sizeof re_syntax_table); for (c = 'a'; c <= 'z'; c++) re_syntax_table[c] = Sword; for (c = 'A'; c <= 'Z'; c++) re_syntax_table[c] = Sword; for (c = '0'; c <= '9'; c++) re_syntax_table[c] = Sword; re_syntax_table['_'] = Sword; done = 1; } #endif /* not SYNTAX_TABLE */ #define SYNTAX(c) re_syntax_table[c] #endif /* not emacs */ /* Get the interface, including the syntax bits. */ #include "regex.h" /* isalpha etc. are used for the character classes. */ #include /* Jim Meyering writes: "... Some ctype macros are valid only for character codes that isascii says are ASCII (SGI's IRIX-4.0.5 is one such system --when using /bin/cc or gcc but without giving an ansi option). So, all ctype uses should be through macros like ISPRINT... If STDC_HEADERS is defined, then autoconf has verified that the ctype macros don't need to be guarded with references to isascii. ... Defining isascii to 1 should let any compiler worth its salt eliminate the && through constant folding." */ #if defined (STDC_HEADERS) || (!defined (isascii) && !defined (HAVE_ISASCII)) #define ISASCII(c) 1 #else #define ISASCII(c) isascii(c) #endif #ifdef isblank #define ISBLANK(c) (ISASCII (c) && isblank (c)) #else #define ISBLANK(c) ((c) == ' ' || (c) == '\t') #endif #ifdef isgraph #define ISGRAPH(c) (ISASCII (c) && isgraph (c)) #else #define ISGRAPH(c) (ISASCII (c) && isprint (c) && !isspace (c)) #endif #define ISPRINT(c) (ISASCII (c) && isprint (c)) #define ISDIGIT(c) (ISASCII (c) && isdigit (c)) #define ISALNUM(c) (ISASCII (c) && isalnum (c)) #define ISALPHA(c) (ISASCII (c) && isalpha (c)) #define ISCNTRL(c) (ISASCII (c) && iscntrl (c)) #define ISLOWER(c) (ISASCII (c) && islower (c)) #define ISPUNCT(c) (ISASCII (c) && ispunct (c)) #define ISSPACE(c) (ISASCII (c) && isspace (c)) #define ISUPPER(c) (ISASCII (c) && isupper (c)) #define ISXDIGIT(c) (ISASCII (c) && isxdigit (c)) #ifndef NULL #define NULL 0 #endif /* We remove any previous definition of `SIGN_EXTEND_CHAR', since ours (we hope) works properly with all combinations of machines, compilers, `char' and `unsigned char' argument types. (Per Bothner suggested the basic approach.) */ #undef SIGN_EXTEND_CHAR #if __STDC__ #define SIGN_EXTEND_CHAR(c) ((signed char) (c)) #else /* not __STDC__ */ /* As in Harbison and Steele. */ #define SIGN_EXTEND_CHAR(c) ((((unsigned char) (c)) ^ 128) - 128) #endif /* Should we use malloc or alloca? If REGEX_MALLOC is not defined, we use `alloca' instead of `malloc'. This is because using malloc in re_search* or re_match* could cause memory leaks when C-g is used in Emacs; also, malloc is slower and causes storage fragmentation. On the other hand, malloc is more portable, and easier to debug. Because we sometimes use alloca, some routines have to be macros, not functions -- `alloca'-allocated space disappears at the end of the function it is called in. */ #ifdef REGEX_MALLOC #define REGEX_ALLOCATE malloc #define REGEX_REALLOCATE(source, osize, nsize) realloc (source, nsize) #else /* not REGEX_MALLOC */ /* Emacs already defines alloca, sometimes. */ #ifndef alloca /* Make alloca work the best possible way. */ #ifdef __GNUC__ #define alloca __builtin_alloca #else /* not __GNUC__ */ #if HAVE_ALLOCA_H #include #else /* not __GNUC__ or HAVE_ALLOCA_H */ #ifndef _AIX /* Already did AIX, up at the top. */ char *alloca (); #endif /* not _AIX */ #endif /* not HAVE_ALLOCA_H */ #endif /* not __GNUC__ */ #endif /* not alloca */ #define REGEX_ALLOCATE alloca /* Assumes a `char *destination' variable. */ #define REGEX_REALLOCATE(source, osize, nsize) \ (destination = (char *) alloca (nsize), \ bcopy (source, destination, osize), \ destination) #endif /* not REGEX_MALLOC */ /* True if `size1' is non-NULL and PTR is pointing anywhere inside `string1' or just past its end. This works if PTR is NULL, which is a good thing. */ #define FIRST_STRING_P(ptr) \ (size1 && string1 <= (ptr) && (ptr) <= string1 + size1) /* (Re)Allocate N items of type T using malloc, or fail. */ #define TALLOC(n, t) ((t *) malloc ((n) * sizeof (t))) #define RETALLOC(addr, n, t) ((addr) = (t *) realloc (addr, (n) * sizeof (t))) #define RETALLOC_IF(addr, n, t) \ if (addr) RETALLOC((addr), (n), t); else (addr) = TALLOC ((n), t) #define REGEX_TALLOC(n, t) ((t *) REGEX_ALLOCATE ((n) * sizeof (t))) #define BYTEWIDTH 8 /* In bits. */ #define STREQ(s1, s2) ((strcmp (s1, s2) == 0)) #undef MAX #undef MIN #define MAX(a, b) ((a) > (b) ? (a) : (b)) #define MIN(a, b) ((a) < (b) ? (a) : (b)) typedef char boolean; #define false 0 #define true 1 static int re_match_2_internal (); /* These are the command codes that appear in compiled regular expressions. Some opcodes are followed by argument bytes. A command code can specify any interpretation whatsoever for its arguments. Zero bytes may appear in the compiled regular expression. The value of `exactn' is needed in search.c (search_buffer) in Emacs. So regex.h defines a symbol `RE_EXACTN_VALUE' to be 1; the value of `exactn' we use here must also be 1. */ typedef enum { no_op = 0, /* Followed by one byte giving n, then by n literal bytes. */ exactn = 1, /* Matches any (more or less) character. */ anychar, /* Matches any one char belonging to specified set. First following byte is number of bitmap bytes. Then come bytes for a bitmap saying which chars are in. Bits in each byte are ordered low-bit-first. A character is in the set if its bit is 1. A character too large to have a bit in the map is automatically not in the set. */ charset, /* Same parameters as charset, but match any character that is not one of those specified. */ charset_not, /* Start remembering the text that is matched, for storing in a register. Followed by one byte with the register number, in the range 0 to one less than the pattern buffer's re_nsub field. Then followed by one byte with the number of groups inner to this one. (This last has to be part of the start_memory only because we need it in the on_failure_jump of re_match_2.) */ start_memory, /* Stop remembering the text that is matched and store it in a memory register. Followed by one byte with the register number, in the range 0 to one less than `re_nsub' in the pattern buffer, and one byte with the number of inner groups, just like `start_memory'. (We need the number of inner groups here because we don't have any easy way of finding the corresponding start_memory when we're at a stop_memory.) */ stop_memory, /* Match a duplicate of something remembered. Followed by one byte containing the register number. */ duplicate, /* Fail unless at beginning of line. */ begline, /* Fail unless at end of line. */ endline, /* Succeeds if at beginning of buffer (if emacs) or at beginning of string to be matched (if not). */ begbuf, /* Analogously, for end of buffer/string. */ endbuf, /* Followed by two byte relative address to which to jump. */ jump, /* Same as jump, but marks the end of an alternative. */ jump_past_alt, /* Followed by two-byte relative address of place to resume at in case of failure. */ on_failure_jump, /* Like on_failure_jump, but pushes a placeholder instead of the current string position when executed. */ on_failure_keep_string_jump, /* Throw away latest failure point and then jump to following two-byte relative address. */ pop_failure_jump, /* Change to pop_failure_jump if know won't have to backtrack to match; otherwise change to jump. This is used to jump back to the beginning of a repeat. If what follows this jump clearly won't match what the repeat does, such that we can be sure that there is no use backtracking out of repetitions already matched, then we change it to a pop_failure_jump. Followed by two-byte address. */ maybe_pop_jump, /* Jump to following two-byte address, and push a dummy failure point. This failure point will be thrown away if an attempt is made to use it for a failure. A `+' construct makes this before the first repeat. Also used as an intermediary kind of jump when compiling an alternative. */ dummy_failure_jump, /* Push a dummy failure point and continue. Used at the end of alternatives. */ push_dummy_failure, /* Followed by two-byte relative address and two-byte number n. After matching N times, jump to the address upon failure. */ succeed_n, /* Followed by two-byte relative address, and two-byte number n. Jump to the address N times, then fail. */ jump_n, /* Set the following two-byte relative address to the subsequent two-byte number. The address *includes* the two bytes of number. */ set_number_at, wordchar, /* Matches any word-constituent character. */ notwordchar, /* Matches any char that is not a word-constituent. */ wordbeg, /* Succeeds if at word beginning. */ wordend, /* Succeeds if at word end. */ wordbound, /* Succeeds if at a word boundary. */ notwordbound /* Succeeds if not at a word boundary. */ #ifdef emacs ,before_dot, /* Succeeds if before point. */ at_dot, /* Succeeds if at point. */ after_dot, /* Succeeds if after point. */ /* Matches any character whose syntax is specified. Followed by a byte which contains a syntax code, e.g., Sword. */ syntaxspec, /* Matches any character whose syntax is not that specified. */ notsyntaxspec #endif /* emacs */ } re_opcode_t; /* Common operations on the compiled pattern. */ /* Store NUMBER in two contiguous bytes starting at DESTINATION. */ #define STORE_NUMBER(destination, number) \ do { \ (destination)[0] = (number) & 0377; \ (destination)[1] = (number) >> 8; \ } while (0) /* Same as STORE_NUMBER, except increment DESTINATION to the byte after where the number is stored. Therefore, DESTINATION must be an lvalue. */ #define STORE_NUMBER_AND_INCR(destination, number) \ do { \ STORE_NUMBER (destination, number); \ (destination) += 2; \ } while (0) /* Put into DESTINATION a number stored in two contiguous bytes starting at SOURCE. */ #define EXTRACT_NUMBER(destination, source) \ do { \ (destination) = *(source) & 0377; \ (destination) += SIGN_EXTEND_CHAR (*((source) + 1)) << 8; \ } while (0) #ifdef DEBUG static void extract_number (dest, source) int *dest; unsigned char *source; { int temp = SIGN_EXTEND_CHAR (*(source + 1)); *dest = *source & 0377; *dest += temp << 8; } #ifndef EXTRACT_MACROS /* To debug the macros. */ #undef EXTRACT_NUMBER #define EXTRACT_NUMBER(dest, src) extract_number (&dest, src) #endif /* not EXTRACT_MACROS */ #endif /* DEBUG */ /* Same as EXTRACT_NUMBER, except increment SOURCE to after the number. SOURCE must be an lvalue. */ #define EXTRACT_NUMBER_AND_INCR(destination, source) \ do { \ EXTRACT_NUMBER (destination, source); \ (source) += 2; \ } while (0) #ifdef DEBUG static void extract_number_and_incr (destination, source) int *destination; unsigned char **source; { extract_number (destination, *source); *source += 2; } #ifndef EXTRACT_MACROS #undef EXTRACT_NUMBER_AND_INCR #define EXTRACT_NUMBER_AND_INCR(dest, src) \ extract_number_and_incr (&dest, &src) #endif /* not EXTRACT_MACROS */ #endif /* DEBUG */ /* If DEBUG is defined, Regex prints many voluminous messages about what it is doing (if the variable `debug' is nonzero). If linked with the main program in `iregex.c', you can enter patterns and strings interactively. And if linked with the main program in `main.c' and the other test files, you can run the already-written tests. */ #ifdef DEBUG /* We use standard I/O for debugging. */ #include /* It is useful to test things that ``must'' be true when debugging. */ #include static int debug = 0; #define DEBUG_STATEMENT(e) e #define DEBUG_PRINT1(x) if (debug) printf (x) #define DEBUG_PRINT2(x1, x2) if (debug) printf (x1, x2) #define DEBUG_PRINT3(x1, x2, x3) if (debug) printf (x1, x2, x3) #define DEBUG_PRINT4(x1, x2, x3, x4) if (debug) printf (x1, x2, x3, x4) #define DEBUG_PRINT_COMPILED_PATTERN(p, s, e) \ if (debug) print_partial_compiled_pattern (s, e) #define DEBUG_PRINT_DOUBLE_STRING(w, s1, sz1, s2, sz2) \ if (debug) print_double_string (w, s1, sz1, s2, sz2) extern void printchar (); /* Print the fastmap in human-readable form. */ void print_fastmap (fastmap) char *fastmap; { unsigned was_a_range = 0; unsigned i = 0; while (i < (1 << BYTEWIDTH)) { if (fastmap[i++]) { was_a_range = 0; printchar (i - 1); while (i < (1 << BYTEWIDTH) && fastmap[i]) { was_a_range = 1; i++; } if (was_a_range) { printf ("-"); printchar (i - 1); } } } putchar ('\n'); } /* Print a compiled pattern string in human-readable form, starting at the START pointer into it and ending just before the pointer END. */ void print_partial_compiled_pattern (start, end) unsigned char *start; unsigned char *end; { int mcnt, mcnt2; unsigned char *p = start; unsigned char *pend = end; if (start == NULL) { printf ("(null)\n"); return; } /* Loop over pattern commands. */ while (p < pend) { printf ("%d:\t", p - start); switch ((re_opcode_t) *p++) { case no_op: printf ("/no_op"); break; case exactn: mcnt = *p++; printf ("/exactn/%d", mcnt); do { putchar ('/'); printchar (*p++); } while (--mcnt); break; case start_memory: mcnt = *p++; printf ("/start_memory/%d/%d", mcnt, *p++); break; case stop_memory: mcnt = *p++; printf ("/stop_memory/%d/%d", mcnt, *p++); break; case duplicate: printf ("/duplicate/%d", *p++); break; case anychar: printf ("/anychar"); break; case charset: case charset_not: { register int c, last = -100; register int in_range = 0; printf ("/charset [%s", (re_opcode_t) *(p - 1) == charset_not ? "^" : ""); assert (p + *p < pend); for (c = 0; c < 256; c++) if (c / 8 < *p && (p[1 + (c/8)] & (1 << (c % 8)))) { /* Are we starting a range? */ if (last + 1 == c && ! in_range) { putchar ('-'); in_range = 1; } /* Have we broken a range? */ else if (last + 1 != c && in_range) { printchar (last); in_range = 0; } if (! in_range) printchar (c); last = c; } if (in_range) printchar (last); putchar (']'); p += 1 + *p; } break; case begline: printf ("/begline"); break; case endline: printf ("/endline"); break; case on_failure_jump: extract_number_and_incr (&mcnt, &p); printf ("/on_failure_jump to %d", p + mcnt - start); break; case on_failure_keep_string_jump: extract_number_and_incr (&mcnt, &p); printf ("/on_failure_keep_string_jump to %d", p + mcnt - start); break; case dummy_failure_jump: extract_number_and_incr (&mcnt, &p); printf ("/dummy_failure_jump to %d", p + mcnt - start); break; case push_dummy_failure: printf ("/push_dummy_failure"); break; case maybe_pop_jump: extract_number_and_incr (&mcnt, &p); printf ("/maybe_pop_jump to %d", p + mcnt - start); break; case pop_failure_jump: extract_number_and_incr (&mcnt, &p); printf ("/pop_failure_jump to %d", p + mcnt - start); break; case jump_past_alt: extract_number_and_incr (&mcnt, &p); printf ("/jump_past_alt to %d", p + mcnt - start); break; case jump: extract_number_and_incr (&mcnt, &p); printf ("/jump to %d", p + mcnt - start); break; case succeed_n: extract_number_and_incr (&mcnt, &p); extract_number_and_incr (&mcnt2, &p); printf ("/succeed_n to %d, %d times", p + mcnt - start, mcnt2); break; case jump_n: extract_number_and_incr (&mcnt, &p); extract_number_and_incr (&mcnt2, &p); printf ("/jump_n to %d, %d times", p + mcnt - start, mcnt2); break; case set_number_at: extract_number_and_incr (&mcnt, &p); extract_number_and_incr (&mcnt2, &p); printf ("/set_number_at location %d to %d", p + mcnt - start, mcnt2); break; case wordbound: printf ("/wordbound"); break; case notwordbound: printf ("/notwordbound"); break; case wordbeg: printf ("/wordbeg"); break; case wordend: printf ("/wordend"); #ifdef emacs case before_dot: printf ("/before_dot"); break; case at_dot: printf ("/at_dot"); break; case after_dot: printf ("/after_dot"); break; case syntaxspec: printf ("/syntaxspec"); mcnt = *p++; printf ("/%d", mcnt); break; case notsyntaxspec: printf ("/notsyntaxspec"); mcnt = *p++; printf ("/%d", mcnt); break; #endif /* emacs */ case wordchar: printf ("/wordchar"); break; case notwordchar: printf ("/notwordchar"); break; case begbuf: printf ("/begbuf"); break; case endbuf: printf ("/endbuf"); break; default: printf ("?%d", *(p-1)); } putchar ('\n'); } printf ("%d:\tend of pattern.\n", p - start); } void print_compiled_pattern (bufp) struct re_pattern_buffer *bufp; { unsigned char *buffer = bufp->buffer; print_partial_compiled_pattern (buffer, buffer + bufp->used); printf ("%d bytes used/%d bytes allocated.\n", bufp->used, bufp->allocated); if (bufp->fastmap_accurate && bufp->fastmap) { printf ("fastmap: "); print_fastmap (bufp->fastmap); } printf ("re_nsub: %d\t", bufp->re_nsub); printf ("regs_alloc: %d\t", bufp->regs_allocated); printf ("can_be_null: %d\t", bufp->can_be_null); printf ("newline_anchor: %d\n", bufp->newline_anchor); printf ("no_sub: %d\t", bufp->no_sub); printf ("not_bol: %d\t", bufp->not_bol); printf ("not_eol: %d\t", bufp->not_eol); printf ("syntax: %d\n", bufp->syntax); /* Perhaps we should print the translate table? */ } void print_double_string (where, string1, size1, string2, size2) const char *where; const char *string1; const char *string2; int size1; int size2; { unsigned this_char; if (where == NULL) printf ("(null)"); else { if (FIRST_STRING_P (where)) { for (this_char = where - string1; this_char < size1; this_char++) printchar (string1[this_char]); where = string2; } for (this_char = where - string2; this_char < size2; this_char++) printchar (string2[this_char]); } } #else /* not DEBUG */ #undef assert #define assert(e) #define DEBUG_STATEMENT(e) #define DEBUG_PRINT1(x) #define DEBUG_PRINT2(x1, x2) #define DEBUG_PRINT3(x1, x2, x3) #define DEBUG_PRINT4(x1, x2, x3, x4) #define DEBUG_PRINT_COMPILED_PATTERN(p, s, e) #define DEBUG_PRINT_DOUBLE_STRING(w, s1, sz1, s2, sz2) #endif /* not DEBUG */ /* Set by `re_set_syntax' to the current regexp syntax to recognize. Can also be assigned to arbitrarily: each pattern buffer stores its own syntax, so it can be changed between regex compilations. */ reg_syntax_t re_syntax_options = RE_SYNTAX_EMACS; /* Specify the precise syntax of regexps for compilation. This provides for compatibility for various utilities which historically have different, incompatible syntaxes. The argument SYNTAX is a bit mask comprised of the various bits defined in regex.h. We return the old syntax. */ reg_syntax_t re_set_syntax (syntax) reg_syntax_t syntax; { reg_syntax_t ret = re_syntax_options; re_syntax_options = syntax; return ret; } /* This table gives an error message for each of the error codes listed in regex.h. Obviously the order here has to be same as there. */ static const char *re_error_msg[] = { NULL, /* REG_NOERROR */ "No match", /* REG_NOMATCH */ "Invalid regular expression", /* REG_BADPAT */ "Invalid collation character", /* REG_ECOLLATE */ "Invalid character class name", /* REG_ECTYPE */ "Trailing backslash", /* REG_EESCAPE */ "Invalid back reference", /* REG_ESUBREG */ "Unmatched [ or [^", /* REG_EBRACK */ "Unmatched ( or \\(", /* REG_EPAREN */ "Unmatched \\{", /* REG_EBRACE */ "Invalid content of \\{\\}", /* REG_BADBR */ "Invalid range end", /* REG_ERANGE */ "Memory exhausted", /* REG_ESPACE */ "Invalid preceding regular expression", /* REG_BADRPT */ "Premature end of regular expression", /* REG_EEND */ "Regular expression too big", /* REG_ESIZE */ "Unmatched ) or \\)", /* REG_ERPAREN */ }; /* Avoiding alloca during matching, to placate r_alloc. */ /* Define MATCH_MAY_ALLOCATE unless we need to make sure that the searching and matching functions should not call alloca. On some systems, alloca is implemented in terms of malloc, and if we're using the relocating allocator routines, then malloc could cause a relocation, which might (if the strings being searched are in the ralloc heap) shift the data out from underneath the regexp routines. Here's another reason to avoid allocation: Emacs insists on processing input from X in a signal handler; processing X input may call malloc; if input arrives while a matching routine is calling malloc, then we're scrod. But Emacs can't just block input while calling matching routines; then we don't notice interrupts when they come in. So, Emacs blocks input around all regexp calls except the matching calls, which it leaves unprotected, in the faith that they will not malloc. */ /* Normally, this is fine. */ #define MATCH_MAY_ALLOCATE /* But under some circumstances, it's not. */ #if defined (emacs) || (defined (REL_ALLOC) && defined (C_ALLOCA)) #undef MATCH_MAY_ALLOCATE #endif /* Failure stack declarations and macros; both re_compile_fastmap and re_match_2 use a failure stack. These have to be macros because of REGEX_ALLOCATE. */ /* Number of failure points for which to initially allocate space when matching. If this number is exceeded, we allocate more space, so it is not a hard limit. */ #ifndef INIT_FAILURE_ALLOC #define INIT_FAILURE_ALLOC 5 #endif /* Roughly the maximum number of failure points on the stack. Would be exactly that if always used MAX_FAILURE_SPACE each time we failed. This is a variable only so users of regex can assign to it; we never change it ourselves. */ int re_max_failures = 2000; typedef unsigned char *fail_stack_elt_t; typedef struct { fail_stack_elt_t *stack; unsigned size; unsigned avail; /* Offset of next open position. */ } fail_stack_type; #define FAIL_STACK_EMPTY() (fail_stack.avail == 0) #define FAIL_STACK_PTR_EMPTY() (fail_stack_ptr->avail == 0) #define FAIL_STACK_FULL() (fail_stack.avail == fail_stack.size) #define FAIL_STACK_TOP() (fail_stack.stack[fail_stack.avail]) /* Initialize `fail_stack'. Do `return -2' if the alloc fails. */ #ifdef MATCH_MAY_ALLOCATE #define INIT_FAIL_STACK() \ do { \ fail_stack.stack = (fail_stack_elt_t *) \ REGEX_ALLOCATE (INIT_FAILURE_ALLOC * sizeof (fail_stack_elt_t)); \ \ if (fail_stack.stack == NULL) \ return -2; \ \ fail_stack.size = INIT_FAILURE_ALLOC; \ fail_stack.avail = 0; \ } while (0) #else #define INIT_FAIL_STACK() \ do { \ fail_stack.avail = 0; \ } while (0) #endif /* Double the size of FAIL_STACK, up to approximately `re_max_failures' items. Return 1 if succeeds, and 0 if either ran out of memory allocating space for it or it was already too large. REGEX_REALLOCATE requires `destination' be declared. */ #define DOUBLE_FAIL_STACK(fail_stack) \ ((fail_stack).size > re_max_failures * MAX_FAILURE_ITEMS \ ? 0 \ : ((fail_stack).stack = (fail_stack_elt_t *) \ REGEX_REALLOCATE ((fail_stack).stack, \ (fail_stack).size * sizeof (fail_stack_elt_t), \ ((fail_stack).size << 1) * sizeof (fail_stack_elt_t)), \ \ (fail_stack).stack == NULL \ ? 0 \ : ((fail_stack).size <<= 1, \ 1))) /* Push PATTERN_OP on FAIL_STACK. Return 1 if was able to do so and 0 if ran out of memory allocating space to do so. */ #define PUSH_PATTERN_OP(pattern_op, fail_stack) \ ((FAIL_STACK_FULL () \ && !DOUBLE_FAIL_STACK (fail_stack)) \ ? 0 \ : ((fail_stack).stack[(fail_stack).avail++] = pattern_op, \ 1)) /* This pushes an item onto the failure stack. Must be a four-byte value. Assumes the variable `fail_stack'. Probably should only be called from within `PUSH_FAILURE_POINT'. */ #define PUSH_FAILURE_ITEM(item) \ fail_stack.stack[fail_stack.avail++] = (fail_stack_elt_t) item /* The complement operation. Assumes `fail_stack' is nonempty. */ #define POP_FAILURE_ITEM() fail_stack.stack[--fail_stack.avail] /* Used to omit pushing failure point id's when we're not debugging. */ #ifdef DEBUG #define DEBUG_PUSH PUSH_FAILURE_ITEM #define DEBUG_POP(item_addr) *(item_addr) = POP_FAILURE_ITEM () #else #define DEBUG_PUSH(item) #define DEBUG_POP(item_addr) #endif /* Push the information about the state we will need if we ever fail back to it. Requires variables fail_stack, regstart, regend, reg_info, and num_regs be declared. DOUBLE_FAIL_STACK requires `destination' be declared. Does `return FAILURE_CODE' if runs out of memory. */ #define PUSH_FAILURE_POINT(pattern_place, string_place, failure_code) \ do { \ char *destination; \ /* Must be int, so when we don't save any registers, the arithmetic \ of 0 + -1 isn't done as unsigned. */ \ int this_reg; \ \ DEBUG_STATEMENT (failure_id++); \ DEBUG_STATEMENT (nfailure_points_pushed++); \ DEBUG_PRINT2 ("\nPUSH_FAILURE_POINT #%u:\n", failure_id); \ DEBUG_PRINT2 (" Before push, next avail: %d\n", (fail_stack).avail);\ DEBUG_PRINT2 (" size: %d\n", (fail_stack).size);\ \ DEBUG_PRINT2 (" slots needed: %d\n", NUM_FAILURE_ITEMS); \ DEBUG_PRINT2 (" available: %d\n", REMAINING_AVAIL_SLOTS); \ \ /* Ensure we have enough space allocated for what we will push. */ \ while (REMAINING_AVAIL_SLOTS < NUM_FAILURE_ITEMS) \ { \ if (!DOUBLE_FAIL_STACK (fail_stack)) \ return failure_code; \ \ DEBUG_PRINT2 ("\n Doubled stack; size now: %d\n", \ (fail_stack).size); \ DEBUG_PRINT2 (" slots available: %d\n", REMAINING_AVAIL_SLOTS);\ } \ \ /* Push the info, starting with the registers. */ \ DEBUG_PRINT1 ("\n"); \ \ for (this_reg = lowest_active_reg; this_reg <= highest_active_reg; \ this_reg++) \ { \ DEBUG_PRINT2 (" Pushing reg: %d\n", this_reg); \ DEBUG_STATEMENT (num_regs_pushed++); \ \ DEBUG_PRINT2 (" start: 0x%x\n", regstart[this_reg]); \ PUSH_FAILURE_ITEM (regstart[this_reg]); \ \ DEBUG_PRINT2 (" end: 0x%x\n", regend[this_reg]); \ PUSH_FAILURE_ITEM (regend[this_reg]); \ \ DEBUG_PRINT2 (" info: 0x%x\n ", reg_info[this_reg]); \ DEBUG_PRINT2 (" match_null=%d", \ REG_MATCH_NULL_STRING_P (reg_info[this_reg])); \ DEBUG_PRINT2 (" active=%d", IS_ACTIVE (reg_info[this_reg])); \ DEBUG_PRINT2 (" matched_something=%d", \ MATCHED_SOMETHING (reg_info[this_reg])); \ DEBUG_PRINT2 (" ever_matched=%d", \ EVER_MATCHED_SOMETHING (reg_info[this_reg])); \ DEBUG_PRINT1 ("\n"); \ PUSH_FAILURE_ITEM (reg_info[this_reg].word); \ } \ \ DEBUG_PRINT2 (" Pushing low active reg: %d\n", lowest_active_reg);\ PUSH_FAILURE_ITEM (lowest_active_reg); \ \ DEBUG_PRINT2 (" Pushing high active reg: %d\n", highest_active_reg);\ PUSH_FAILURE_ITEM (highest_active_reg); \ \ DEBUG_PRINT2 (" Pushing pattern 0x%x: ", pattern_place); \ DEBUG_PRINT_COMPILED_PATTERN (bufp, pattern_place, pend); \ PUSH_FAILURE_ITEM (pattern_place); \ \ DEBUG_PRINT2 (" Pushing string 0x%x: `", string_place); \ DEBUG_PRINT_DOUBLE_STRING (string_place, string1, size1, string2, \ size2); \ DEBUG_PRINT1 ("'\n"); \ PUSH_FAILURE_ITEM (string_place); \ \ DEBUG_PRINT2 (" Pushing failure id: %u\n", failure_id); \ DEBUG_PUSH (failure_id); \ } while (0) /* This is the number of items that are pushed and popped on the stack for each register. */ #define NUM_REG_ITEMS 3 /* Individual items aside from the registers. */ #ifdef DEBUG #define NUM_NONREG_ITEMS 5 /* Includes failure point id. */ #else #define NUM_NONREG_ITEMS 4 #endif /* We push at most this many items on the stack. */ #define MAX_FAILURE_ITEMS ((num_regs - 1) * NUM_REG_ITEMS + NUM_NONREG_ITEMS) /* We actually push this many items. */ #define NUM_FAILURE_ITEMS \ ((highest_active_reg - lowest_active_reg + 1) * NUM_REG_ITEMS \ + NUM_NONREG_ITEMS) /* How many items can still be added to the stack without overflowing it. */ #define REMAINING_AVAIL_SLOTS ((fail_stack).size - (fail_stack).avail) /* Pops what PUSH_FAIL_STACK pushes. We restore into the parameters, all of which should be lvalues: STR -- the saved data position. PAT -- the saved pattern position. LOW_REG, HIGH_REG -- the highest and lowest active registers. REGSTART, REGEND -- arrays of string positions. REG_INFO -- array of information about each subexpression. Also assumes the variables `fail_stack' and (if debugging), `bufp', `pend', `string1', `size1', `string2', and `size2'. */ #define POP_FAILURE_POINT(str, pat, low_reg, high_reg, regstart, regend, reg_info)\ { \ DEBUG_STATEMENT (fail_stack_elt_t failure_id;) \ int this_reg; \ const unsigned char *string_temp; \ \ assert (!FAIL_STACK_EMPTY ()); \ \ /* Remove failure points and point to how many regs pushed. */ \ DEBUG_PRINT1 ("POP_FAILURE_POINT:\n"); \ DEBUG_PRINT2 (" Before pop, next avail: %d\n", fail_stack.avail); \ DEBUG_PRINT2 (" size: %d\n", fail_stack.size); \ \ assert (fail_stack.avail >= NUM_NONREG_ITEMS); \ \ DEBUG_POP (&failure_id); \ DEBUG_PRINT2 (" Popping failure id: %u\n", failure_id); \ \ /* If the saved string location is NULL, it came from an \ on_failure_keep_string_jump opcode, and we want to throw away the \ saved NULL, thus retaining our current position in the string. */ \ string_temp = POP_FAILURE_ITEM (); \ if (string_temp != NULL) \ str = (const char *) string_temp; \ \ DEBUG_PRINT2 (" Popping string 0x%x: `", str); \ DEBUG_PRINT_DOUBLE_STRING (str, string1, size1, string2, size2); \ DEBUG_PRINT1 ("'\n"); \ \ pat = (unsigned char *) POP_FAILURE_ITEM (); \ DEBUG_PRINT2 (" Popping pattern 0x%x: ", pat); \ DEBUG_PRINT_COMPILED_PATTERN (bufp, pat, pend); \ \ /* Restore register info. */ \ high_reg = (unsigned) POP_FAILURE_ITEM (); \ DEBUG_PRINT2 (" Popping high active reg: %d\n", high_reg); \ \ low_reg = (unsigned) POP_FAILURE_ITEM (); \ DEBUG_PRINT2 (" Popping low active reg: %d\n", low_reg); \ \ for (this_reg = high_reg; this_reg >= low_reg; this_reg--) \ { \ DEBUG_PRINT2 (" Popping reg: %d\n", this_reg); \ \ reg_info[this_reg].word = POP_FAILURE_ITEM (); \ DEBUG_PRINT2 (" info: 0x%x\n", reg_info[this_reg]); \ \ regend[this_reg] = (const char *) POP_FAILURE_ITEM (); \ DEBUG_PRINT2 (" end: 0x%x\n", regend[this_reg]); \ \ regstart[this_reg] = (const char *) POP_FAILURE_ITEM (); \ DEBUG_PRINT2 (" start: 0x%x\n", regstart[this_reg]); \ } \ \ DEBUG_STATEMENT (nfailure_points_popped++); \ } /* POP_FAILURE_POINT */ /* Structure for per-register (a.k.a. per-group) information. This must not be longer than one word, because we push this value onto the failure stack. Other register information, such as the starting and ending positions (which are addresses), and the list of inner groups (which is a bits list) are maintained in separate variables. We are making a (strictly speaking) nonportable assumption here: that the compiler will pack our bit fields into something that fits into the type of `word', i.e., is something that fits into one item on the failure stack. */ typedef union { fail_stack_elt_t word; struct { /* This field is one if this group can match the empty string, zero if not. If not yet determined, `MATCH_NULL_UNSET_VALUE'. */ #define MATCH_NULL_UNSET_VALUE 3 unsigned match_null_string_p : 2; unsigned is_active : 1; unsigned matched_something : 1; unsigned ever_matched_something : 1; } bits; } register_info_type; #define REG_MATCH_NULL_STRING_P(R) ((R).bits.match_null_string_p) #define IS_ACTIVE(R) ((R).bits.is_active) #define MATCHED_SOMETHING(R) ((R).bits.matched_something) #define EVER_MATCHED_SOMETHING(R) ((R).bits.ever_matched_something) /* Call this when have matched a real character; it sets `matched' flags for the subexpressions which we are currently inside. Also records that those subexprs have matched. */ #define SET_REGS_MATCHED() \ do \ { \ unsigned r; \ for (r = lowest_active_reg; r <= highest_active_reg; r++) \ { \ MATCHED_SOMETHING (reg_info[r]) \ = EVER_MATCHED_SOMETHING (reg_info[r]) \ = 1; \ } \ } \ while (0) /* Registers are set to a sentinel when they haven't yet matched. */ #define REG_UNSET_VALUE ((char *) -1) #define REG_UNSET(e) ((e) == REG_UNSET_VALUE) /* How do we implement a missing MATCH_MAY_ALLOCATE? We make the fail stack a global thing, and then grow it to re_max_failures when we compile. */ #ifndef MATCH_MAY_ALLOCATE static fail_stack_type fail_stack; static const char ** regstart, ** regend; static const char ** old_regstart, ** old_regend; static const char **best_regstart, **best_regend; static register_info_type *reg_info; static const char **reg_dummy; static register_info_type *reg_info_dummy; #endif /* Subroutine declarations and macros for regex_compile. */ static void store_op1 (), store_op2 (); static void insert_op1 (), insert_op2 (); static boolean at_begline_loc_p (), at_endline_loc_p (); static boolean group_in_compile_stack (); static reg_errcode_t compile_range (); /* Fetch the next character in the uncompiled pattern---translating it if necessary. Also cast from a signed character in the constant string passed to us by the user to an unsigned char that we can use as an array index (in, e.g., `translate'). */ #define PATFETCH(c) \ do {if (p == pend) return REG_EEND; \ c = (unsigned char) *p++; \ if (translate) c = translate[c]; \ } while (0) /* Fetch the next character in the uncompiled pattern, with no translation. */ #define PATFETCH_RAW(c) \ do {if (p == pend) return REG_EEND; \ c = (unsigned char) *p++; \ } while (0) /* Go backwards one character in the pattern. */ #define PATUNFETCH p-- /* If `translate' is non-null, return translate[D], else just D. We cast the subscript to translate because some data is declared as `char *', to avoid warnings when a string constant is passed. But when we use a character as a subscript we must make it unsigned. */ #define TRANSLATE(d) (translate ? translate[(unsigned char) (d)] : (d)) /* Macros for outputting the compiled pattern into `buffer'. */ /* If the buffer isn't allocated when it comes in, use this. */ #define INIT_BUF_SIZE 32 /* Make sure we have at least N more bytes of space in buffer. */ #define GET_BUFFER_SPACE(n) \ while (b - bufp->buffer + (n) > bufp->allocated) \ EXTEND_BUFFER () /* Make sure we have one more byte of buffer space and then add C to it. */ #define BUF_PUSH(c) \ do { \ GET_BUFFER_SPACE (1); \ *b++ = (unsigned char) (c); \ } while (0) /* Ensure we have two more bytes of buffer space and then append C1 and C2. */ #define BUF_PUSH_2(c1, c2) \ do { \ GET_BUFFER_SPACE (2); \ *b++ = (unsigned char) (c1); \ *b++ = (unsigned char) (c2); \ } while (0) /* As with BUF_PUSH_2, except for three bytes. */ #define BUF_PUSH_3(c1, c2, c3) \ do { \ GET_BUFFER_SPACE (3); \ *b++ = (unsigned char) (c1); \ *b++ = (unsigned char) (c2); \ *b++ = (unsigned char) (c3); \ } while (0) /* Store a jump with opcode OP at LOC to location TO. We store a relative address offset by the three bytes the jump itself occupies. */ #define STORE_JUMP(op, loc, to) \ store_op1 (op, loc, (to) - (loc) - 3) /* Likewise, for a two-argument jump. */ #define STORE_JUMP2(op, loc, to, arg) \ store_op2 (op, loc, (to) - (loc) - 3, arg) /* Like `STORE_JUMP', but for inserting. Assume `b' is the buffer end. */ #define INSERT_JUMP(op, loc, to) \ insert_op1 (op, loc, (to) - (loc) - 3, b) /* Like `STORE_JUMP2', but for inserting. Assume `b' is the buffer end. */ #define INSERT_JUMP2(op, loc, to, arg) \ insert_op2 (op, loc, (to) - (loc) - 3, arg, b) /* This is not an arbitrary limit: the arguments which represent offsets into the pattern are two bytes long. So if 2^16 bytes turns out to be too small, many things would have to change. */ #define MAX_BUF_SIZE (1L << 16) /* Extend the buffer by twice its current size via realloc and reset the pointers that pointed into the old block to point to the correct places in the new one. If extending the buffer results in it being larger than MAX_BUF_SIZE, then flag memory exhausted. */ #define EXTEND_BUFFER() \ do { \ unsigned char *old_buffer = bufp->buffer; \ if (bufp->allocated == MAX_BUF_SIZE) \ return REG_ESIZE; \ bufp->allocated <<= 1; \ if (bufp->allocated > MAX_BUF_SIZE) \ bufp->allocated = MAX_BUF_SIZE; \ bufp->buffer = (unsigned char *) realloc (bufp->buffer, bufp->allocated);\ if (bufp->buffer == NULL) \ return REG_ESPACE; \ /* If the buffer moved, move all the pointers into it. */ \ if (old_buffer != bufp->buffer) \ { \ b = (b - old_buffer) + bufp->buffer; \ begalt = (begalt - old_buffer) + bufp->buffer; \ if (fixup_alt_jump) \ fixup_alt_jump = (fixup_alt_jump - old_buffer) + bufp->buffer;\ if (laststart) \ laststart = (laststart - old_buffer) + bufp->buffer; \ if (pending_exact) \ pending_exact = (pending_exact - old_buffer) + bufp->buffer; \ } \ } while (0) /* Since we have one byte reserved for the register number argument to {start,stop}_memory, the maximum number of groups we can report things about is what fits in that byte. */ #define MAX_REGNUM 255 /* But patterns can have more than `MAX_REGNUM' registers. We just ignore the excess. */ typedef unsigned regnum_t; /* Macros for the compile stack. */ /* Since offsets can go either forwards or backwards, this type needs to be able to hold values from -(MAX_BUF_SIZE - 1) to MAX_BUF_SIZE - 1. */ typedef int pattern_offset_t; typedef struct { pattern_offset_t begalt_offset; pattern_offset_t fixup_alt_jump; pattern_offset_t inner_group_offset; pattern_offset_t laststart_offset; regnum_t regnum; } compile_stack_elt_t; typedef struct { compile_stack_elt_t *stack; unsigned size; unsigned avail; /* Offset of next open position. */ } compile_stack_type; #define INIT_COMPILE_STACK_SIZE 32 #define COMPILE_STACK_EMPTY (compile_stack.avail == 0) #define COMPILE_STACK_FULL (compile_stack.avail == compile_stack.size) /* The next available element. */ #define COMPILE_STACK_TOP (compile_stack.stack[compile_stack.avail]) /* Set the bit for character C in a list. */ #define SET_LIST_BIT(c) \ (b[((unsigned char) (c)) / BYTEWIDTH] \ |= 1 << (((unsigned char) c) % BYTEWIDTH)) /* Get the next unsigned number in the uncompiled pattern. */ #define GET_UNSIGNED_NUMBER(num) \ { if (p != pend) \ { \ PATFETCH (c); \ while (ISDIGIT (c)) \ { \ if (num < 0) \ num = 0; \ num = num * 10 + c - '0'; \ if (p == pend) \ break; \ PATFETCH (c); \ } \ } \ } #define CHAR_CLASS_MAX_LENGTH 6 /* Namely, `xdigit'. */ #define IS_CHAR_CLASS(string) \ (STREQ (string, "alpha") || STREQ (string, "upper") \ || STREQ (string, "lower") || STREQ (string, "digit") \ || STREQ (string, "alnum") || STREQ (string, "xdigit") \ || STREQ (string, "space") || STREQ (string, "print") \ || STREQ (string, "punct") || STREQ (string, "graph") \ || STREQ (string, "cntrl") || STREQ (string, "blank")) /* `regex_compile' compiles PATTERN (of length SIZE) according to SYNTAX. Returns one of error codes defined in `regex.h', or zero for success. Assumes the `allocated' (and perhaps `buffer') and `translate' fields are set in BUFP on entry. If it succeeds, results are put in BUFP (if it returns an error, the contents of BUFP are undefined): `buffer' is the compiled pattern; `syntax' is set to SYNTAX; `used' is set to the length of the compiled pattern; `fastmap_accurate' is zero; `re_nsub' is the number of subexpressions in PATTERN; `not_bol' and `not_eol' are zero; The `fastmap' and `newline_anchor' fields are neither examined nor set. */ static reg_errcode_t regex_compile (pattern, size, syntax, bufp) const char *pattern; int size; reg_syntax_t syntax; struct re_pattern_buffer *bufp; { /* We fetch characters from PATTERN here. Even though PATTERN is `char *' (i.e., signed), we declare these variables as unsigned, so they can be reliably used as array indices. */ register unsigned char c, c1; /* A random temporary spot in PATTERN. */ const char *p1; /* Points to the end of the buffer, where we should append. */ register unsigned char *b; /* Keeps track of unclosed groups. */ compile_stack_type compile_stack; /* Points to the current (ending) position in the pattern. */ const char *p = pattern; const char *pend = pattern + size; /* How to translate the characters in the pattern. */ char *translate = bufp->translate; /* Address of the count-byte of the most recently inserted `exactn' command. This makes it possible to tell if a new exact-match character can be added to that command or if the character requires a new `exactn' command. */ unsigned char *pending_exact = 0; /* Address of start of the most recently finished expression. This tells, e.g., postfix * where to find the start of its operand. Reset at the beginning of groups and alternatives. */ unsigned char *laststart = 0; /* Address of beginning of regexp, or inside of last group. */ unsigned char *begalt; /* Place in the uncompiled pattern (i.e., the {) to which to go back if the interval is invalid. */ const char *beg_interval; /* Address of the place where a forward jump should go to the end of the containing expression. Each alternative of an `or' -- except the last -- ends with a forward jump of this sort. */ unsigned char *fixup_alt_jump = 0; /* Counts open-groups as they are encountered. Remembered for the matching close-group on the compile stack, so the same register number is put in the stop_memory as the start_memory. */ regnum_t regnum = 0; #ifdef DEBUG DEBUG_PRINT1 ("\nCompiling pattern: "); if (debug) { unsigned debug_count; for (debug_count = 0; debug_count < size; debug_count++) printchar (pattern[debug_count]); putchar ('\n'); } #endif /* DEBUG */ /* Initialize the compile stack. */ compile_stack.stack = TALLOC (INIT_COMPILE_STACK_SIZE, compile_stack_elt_t); if (compile_stack.stack == NULL) return REG_ESPACE; compile_stack.size = INIT_COMPILE_STACK_SIZE; compile_stack.avail = 0; /* Initialize the pattern buffer. */ bufp->syntax = syntax; bufp->fastmap_accurate = 0; bufp->not_bol = bufp->not_eol = 0; /* Set `used' to zero, so that if we return an error, the pattern printer (for debugging) will think there's no pattern. We reset it at the end. */ bufp->used = 0; /* Always count groups, whether or not bufp->no_sub is set. */ bufp->re_nsub = 0; #if !defined (emacs) && !defined (SYNTAX_TABLE) /* Initialize the syntax table. */ init_syntax_once (); #endif if (bufp->allocated == 0) { if (bufp->buffer) { /* If zero allocated, but buffer is non-null, try to realloc enough space. This loses if buffer's address is bogus, but that is the user's responsibility. */ RETALLOC (bufp->buffer, INIT_BUF_SIZE, unsigned char); } else { /* Caller did not allocate a buffer. Do it for them. */ bufp->buffer = TALLOC (INIT_BUF_SIZE, unsigned char); } if (!bufp->buffer) return REG_ESPACE; bufp->allocated = INIT_BUF_SIZE; } begalt = b = bufp->buffer; /* Loop through the uncompiled pattern until we're at the end. */ while (p != pend) { PATFETCH (c); switch (c) { case '^': { if ( /* If at start of pattern, it's an operator. */ p == pattern + 1 /* If context independent, it's an operator. */ || syntax & RE_CONTEXT_INDEP_ANCHORS /* Otherwise, depends on what's come before. */ || at_begline_loc_p (pattern, p, syntax)) BUF_PUSH (begline); else goto normal_char; } break; case '$': { if ( /* If at end of pattern, it's an operator. */ p == pend /* If context independent, it's an operator. */ || syntax & RE_CONTEXT_INDEP_ANCHORS /* Otherwise, depends on what's next. */ || at_endline_loc_p (p, pend, syntax)) BUF_PUSH (endline); else goto normal_char; } break; case '+': case '?': if ((syntax & RE_BK_PLUS_QM) || (syntax & RE_LIMITED_OPS)) goto normal_char; handle_plus: case '*': /* If there is no previous pattern... */ if (!laststart) { if (syntax & RE_CONTEXT_INVALID_OPS) return REG_BADRPT; else if (!(syntax & RE_CONTEXT_INDEP_OPS)) goto normal_char; } { /* Are we optimizing this jump? */ boolean keep_string_p = false; /* 1 means zero (many) matches is allowed. */ char zero_times_ok = 0, many_times_ok = 0; /* If there is a sequence of repetition chars, collapse it down to just one (the right one). We can't combine interval operators with these because of, e.g., `a{2}*', which should only match an even number of `a's. */ for (;;) { zero_times_ok |= c != '+'; many_times_ok |= c != '?'; if (p == pend) break; PATFETCH (c); if (c == '*' || (!(syntax & RE_BK_PLUS_QM) && (c == '+' || c == '?'))) ; else if (syntax & RE_BK_PLUS_QM && c == '\\') { if (p == pend) return REG_EESCAPE; PATFETCH (c1); if (!(c1 == '+' || c1 == '?')) { PATUNFETCH; PATUNFETCH; break; } c = c1; } else { PATUNFETCH; break; } /* If we get here, we found another repeat character. */ } /* Star, etc. applied to an empty pattern is equivalent to an empty pattern. */ if (!laststart) break; /* Now we know whether or not zero matches is allowed and also whether or not two or more matches is allowed. */ if (many_times_ok) { /* More than one repetition is allowed, so put in at the end a backward relative jump from `b' to before the next jump we're going to put in below (which jumps from laststart to after this jump). But if we are at the `*' in the exact sequence `.*\n', insert an unconditional jump backwards to the ., instead of the beginning of the loop. This way we only push a failure point once, instead of every time through the loop. */ assert (p - 1 > pattern); /* Allocate the space for the jump. */ GET_BUFFER_SPACE (3); /* We know we are not at the first character of the pattern, because laststart was nonzero. And we've already incremented `p', by the way, to be the character after the `*'. Do we have to do something analogous here for null bytes, because of RE_DOT_NOT_NULL? */ if (TRANSLATE (*(p - 2)) == TRANSLATE ('.') && zero_times_ok && p < pend && TRANSLATE (*p) == TRANSLATE ('\n') && !(syntax & RE_DOT_NEWLINE)) { /* We have .*\n. */ STORE_JUMP (jump, b, laststart); keep_string_p = true; } else /* Anything else. */ STORE_JUMP (maybe_pop_jump, b, laststart - 3); /* We've added more stuff to the buffer. */ b += 3; } /* On failure, jump from laststart to b + 3, which will be the end of the buffer after this jump is inserted. */ GET_BUFFER_SPACE (3); INSERT_JUMP (keep_string_p ? on_failure_keep_string_jump : on_failure_jump, laststart, b + 3); pending_exact = 0; b += 3; if (!zero_times_ok) { /* At least one repetition is required, so insert a `dummy_failure_jump' before the initial `on_failure_jump' instruction of the loop. This effects a skip over that instruction the first time we hit that loop. */ GET_BUFFER_SPACE (3); INSERT_JUMP (dummy_failure_jump, laststart, laststart + 6); b += 3; } } break; case '.': laststart = b; BUF_PUSH (anychar); break; case '[': { boolean had_char_class = false; if (p == pend) return REG_EBRACK; /* Ensure that we have enough space to push a charset: the opcode, the length count, and the bitset; 34 bytes in all. */ GET_BUFFER_SPACE (34); laststart = b; /* We test `*p == '^' twice, instead of using an if statement, so we only need one BUF_PUSH. */ BUF_PUSH (*p == '^' ? charset_not : charset); if (*p == '^') p++; /* Remember the first position in the bracket expression. */ p1 = p; /* Push the number of bytes in the bitmap. */ BUF_PUSH ((1 << BYTEWIDTH) / BYTEWIDTH); /* Clear the whole map. */ bzero (b, (1 << BYTEWIDTH) / BYTEWIDTH); /* charset_not matches newline according to a syntax bit. */ if ((re_opcode_t) b[-2] == charset_not && (syntax & RE_HAT_LISTS_NOT_NEWLINE)) SET_LIST_BIT ('\n'); /* Read in characters and ranges, setting map bits. */ for (;;) { if (p == pend) return REG_EBRACK; PATFETCH (c); /* \ might escape characters inside [...] and [^...]. */ if ((syntax & RE_BACKSLASH_ESCAPE_IN_LISTS) && c == '\\') { if (p == pend) return REG_EESCAPE; PATFETCH (c1); SET_LIST_BIT (c1); continue; } /* Could be the end of the bracket expression. If it's not (i.e., when the bracket expression is `[]' so far), the ']' character bit gets set way below. */ if (c == ']' && p != p1 + 1) break; /* Look ahead to see if it's a range when the last thing was a character class. */ if (had_char_class && c == '-' && *p != ']') return REG_ERANGE; /* Look ahead to see if it's a range when the last thing was a character: if this is a hyphen not at the beginning or the end of a list, then it's the range operator. */ if (c == '-' && !(p - 2 >= pattern && p[-2] == '[') && !(p - 3 >= pattern && p[-3] == '[' && p[-2] == '^') && *p != ']') { reg_errcode_t ret = compile_range (&p, pend, translate, syntax, b); if (ret != REG_NOERROR) return ret; } else if (p[0] == '-' && p[1] != ']') { /* This handles ranges made up of characters only. */ reg_errcode_t ret; /* Move past the `-'. */ PATFETCH (c1); ret = compile_range (&p, pend, translate, syntax, b); if (ret != REG_NOERROR) return ret; } /* See if we're at the beginning of a possible character class. */ else if (syntax & RE_CHAR_CLASSES && c == '[' && *p == ':') { /* Leave room for the null. */ char str[CHAR_CLASS_MAX_LENGTH + 1]; PATFETCH (c); c1 = 0; /* If pattern is `[[:'. */ if (p == pend) return REG_EBRACK; for (;;) { PATFETCH (c); if (c == ':' || c == ']' || p == pend || c1 == CHAR_CLASS_MAX_LENGTH) break; str[c1++] = c; } str[c1] = '\0'; /* If isn't a word bracketed by `[:' and:`]': undo the ending character, the letters, and leave the leading `:' and `[' (but set bits for them). */ if (c == ':' && *p == ']') { int ch; boolean is_alnum = STREQ (str, "alnum"); boolean is_alpha = STREQ (str, "alpha"); boolean is_blank = STREQ (str, "blank"); boolean is_cntrl = STREQ (str, "cntrl"); boolean is_digit = STREQ (str, "digit"); boolean is_graph = STREQ (str, "graph"); boolean is_lower = STREQ (str, "lower"); boolean is_print = STREQ (str, "print"); boolean is_punct = STREQ (str, "punct"); boolean is_space = STREQ (str, "space"); boolean is_upper = STREQ (str, "upper"); boolean is_xdigit = STREQ (str, "xdigit"); if (!IS_CHAR_CLASS (str)) return REG_ECTYPE; /* Throw away the ] at the end of the character class. */ PATFETCH (c); if (p == pend) return REG_EBRACK; for (ch = 0; ch < 1 << BYTEWIDTH; ch++) { if ( (is_alnum && ISALNUM (ch)) || (is_alpha && ISALPHA (ch)) || (is_blank && ISBLANK (ch)) || (is_cntrl && ISCNTRL (ch)) || (is_digit && ISDIGIT (ch)) || (is_graph && ISGRAPH (ch)) || (is_lower && ISLOWER (ch)) || (is_print && ISPRINT (ch)) || (is_punct && ISPUNCT (ch)) || (is_space && ISSPACE (ch)) || (is_upper && ISUPPER (ch)) || (is_xdigit && ISXDIGIT (ch))) SET_LIST_BIT (ch); } had_char_class = true; } else { c1++; while (c1--) PATUNFETCH; SET_LIST_BIT ('['); SET_LIST_BIT (':'); had_char_class = false; } } else { had_char_class = false; SET_LIST_BIT (c); } } /* Discard any (non)matching list bytes that are all 0 at the end of the map. Decrease the map-length byte too. */ while ((int) b[-1] > 0 && b[b[-1] - 1] == 0) b[-1]--; b += b[-1]; } break; case '(': if (syntax & RE_NO_BK_PARENS) goto handle_open; else goto normal_char; case ')': if (syntax & RE_NO_BK_PARENS) goto handle_close; else goto normal_char; case '\n': if (syntax & RE_NEWLINE_ALT) goto handle_alt; else goto normal_char; case '|': if (syntax & RE_NO_BK_VBAR) goto handle_alt; else goto normal_char; case '{': if (syntax & RE_INTERVALS && syntax & RE_NO_BK_BRACES) goto handle_interval; else goto normal_char; case '\\': if (p == pend) return REG_EESCAPE; /* Do not translate the character after the \, so that we can distinguish, e.g., \B from \b, even if we normally would translate, e.g., B to b. */ PATFETCH_RAW (c); switch (c) { case '(': if (syntax & RE_NO_BK_PARENS) goto normal_backslash; handle_open: bufp->re_nsub++; regnum++; if (COMPILE_STACK_FULL) { RETALLOC (compile_stack.stack, compile_stack.size << 1, compile_stack_elt_t); if (compile_stack.stack == NULL) return REG_ESPACE; compile_stack.size <<= 1; } /* These are the values to restore when we hit end of this group. They are all relative offsets, so that if the whole pattern moves because of realloc, they will still be valid. */ COMPILE_STACK_TOP.begalt_offset = begalt - bufp->buffer; COMPILE_STACK_TOP.fixup_alt_jump = fixup_alt_jump ? fixup_alt_jump - bufp->buffer + 1 : 0; COMPILE_STACK_TOP.laststart_offset = b - bufp->buffer; COMPILE_STACK_TOP.regnum = regnum; /* We will eventually replace the 0 with the number of groups inner to this one. But do not push a start_memory for groups beyond the last one we can represent in the compiled pattern. */ if (regnum <= MAX_REGNUM) { COMPILE_STACK_TOP.inner_group_offset = b - bufp->buffer + 2; BUF_PUSH_3 (start_memory, regnum, 0); } compile_stack.avail++; fixup_alt_jump = 0; laststart = 0; begalt = b; /* If we've reached MAX_REGNUM groups, then this open won't actually generate any code, so we'll have to clear pending_exact explicitly. */ pending_exact = 0; break; case ')': if (syntax & RE_NO_BK_PARENS) goto normal_backslash; if (COMPILE_STACK_EMPTY) if (syntax & RE_UNMATCHED_RIGHT_PAREN_ORD) goto normal_backslash; else return REG_ERPAREN; handle_close: if (fixup_alt_jump) { /* Push a dummy failure point at the end of the alternative for a possible future `pop_failure_jump' to pop. See comments at `push_dummy_failure' in `re_match_2'. */ BUF_PUSH (push_dummy_failure); /* We allocated space for this jump when we assigned to `fixup_alt_jump', in the `handle_alt' case below. */ STORE_JUMP (jump_past_alt, fixup_alt_jump, b - 1); } /* See similar code for backslashed left paren above. */ if (COMPILE_STACK_EMPTY) if (syntax & RE_UNMATCHED_RIGHT_PAREN_ORD) goto normal_char; else return REG_ERPAREN; /* Since we just checked for an empty stack above, this ``can't happen''. */ assert (compile_stack.avail != 0); { /* We don't just want to restore into `regnum', because later groups should continue to be numbered higher, as in `(ab)c(de)' -- the second group is #2. */ regnum_t this_group_regnum; compile_stack.avail--; begalt = bufp->buffer + COMPILE_STACK_TOP.begalt_offset; fixup_alt_jump = COMPILE_STACK_TOP.fixup_alt_jump ? bufp->buffer + COMPILE_STACK_TOP.fixup_alt_jump - 1 : 0; laststart = bufp->buffer + COMPILE_STACK_TOP.laststart_offset; this_group_regnum = COMPILE_STACK_TOP.regnum; /* If we've reached MAX_REGNUM groups, then this open won't actually generate any code, so we'll have to clear pending_exact explicitly. */ pending_exact = 0; /* We're at the end of the group, so now we know how many groups were inside this one. */ if (this_group_regnum <= MAX_REGNUM) { unsigned char *inner_group_loc = bufp->buffer + COMPILE_STACK_TOP.inner_group_offset; *inner_group_loc = regnum - this_group_regnum; BUF_PUSH_3 (stop_memory, this_group_regnum, regnum - this_group_regnum); } } break; case '|': /* `\|'. */ if (syntax & RE_LIMITED_OPS || syntax & RE_NO_BK_VBAR) goto normal_backslash; handle_alt: if (syntax & RE_LIMITED_OPS) goto normal_char; /* Insert before the previous alternative a jump which jumps to this alternative if the former fails. */ GET_BUFFER_SPACE (3); INSERT_JUMP (on_failure_jump, begalt, b + 6); pending_exact = 0; b += 3; /* The alternative before this one has a jump after it which gets executed if it gets matched. Adjust that jump so it will jump to this alternative's analogous jump (put in below, which in turn will jump to the next (if any) alternative's such jump, etc.). The last such jump jumps to the correct final destination. A picture: _____ _____ | | | | | v | v a | b | c If we are at `b', then fixup_alt_jump right now points to a three-byte space after `a'. We'll put in the jump, set fixup_alt_jump to right after `b', and leave behind three bytes which we'll fill in when we get to after `c'. */ if (fixup_alt_jump) STORE_JUMP (jump_past_alt, fixup_alt_jump, b); /* Mark and leave space for a jump after this alternative, to be filled in later either by next alternative or when know we're at the end of a series of alternatives. */ fixup_alt_jump = b; GET_BUFFER_SPACE (3); b += 3; laststart = 0; begalt = b; break; case '{': /* If \{ is a literal. */ if (!(syntax & RE_INTERVALS) /* If we're at `\{' and it's not the open-interval operator. */ || ((syntax & RE_INTERVALS) && (syntax & RE_NO_BK_BRACES)) || (p - 2 == pattern && p == pend)) goto normal_backslash; handle_interval: { /* If got here, then the syntax allows intervals. */ /* At least (most) this many matches must be made. */ int lower_bound = -1, upper_bound = -1; beg_interval = p - 1; if (p == pend) { if (syntax & RE_NO_BK_BRACES) goto unfetch_interval; else return REG_EBRACE; } GET_UNSIGNED_NUMBER (lower_bound); if (c == ',') { GET_UNSIGNED_NUMBER (upper_bound); if (upper_bound < 0) upper_bound = RE_DUP_MAX; } else /* Interval such as `{1}' => match exactly once. */ upper_bound = lower_bound; if (lower_bound < 0 || upper_bound > RE_DUP_MAX || lower_bound > upper_bound) { if (syntax & RE_NO_BK_BRACES) goto unfetch_interval; else return REG_BADBR; } if (!(syntax & RE_NO_BK_BRACES)) { if (c != '\\') return REG_EBRACE; PATFETCH (c); } if (c != '}') { if (syntax & RE_NO_BK_BRACES) goto unfetch_interval; else return REG_BADBR; } /* We just parsed a valid interval. */ /* If it's invalid to have no preceding re. */ if (!laststart) { if (syntax & RE_CONTEXT_INVALID_OPS) return REG_BADRPT; else if (syntax & RE_CONTEXT_INDEP_OPS) laststart = b; else goto unfetch_interval; } /* If the upper bound is zero, don't want to succeed at all; jump from `laststart' to `b + 3', which will be the end of the buffer after we insert the jump. */ if (upper_bound == 0) { GET_BUFFER_SPACE (3); INSERT_JUMP (jump, laststart, b + 3); b += 3; } /* Otherwise, we have a nontrivial interval. When we're all done, the pattern will look like: set_number_at set_number_at succeed_n jump_n (The upper bound and `jump_n' are omitted if `upper_bound' is 1, though.) */ else { /* If the upper bound is > 1, we need to insert more at the end of the loop. */ unsigned nbytes = 10 + (upper_bound > 1) * 10; GET_BUFFER_SPACE (nbytes); /* Initialize lower bound of the `succeed_n', even though it will be set during matching by its attendant `set_number_at' (inserted next), because `re_compile_fastmap' needs to know. Jump to the `jump_n' we might insert below. */ INSERT_JUMP2 (succeed_n, laststart, b + 5 + (upper_bound > 1) * 5, lower_bound); b += 5; /* Code to initialize the lower bound. Insert before the `succeed_n'. The `5' is the last two bytes of this `set_number_at', plus 3 bytes of the following `succeed_n'. */ insert_op2 (set_number_at, laststart, 5, lower_bound, b); b += 5; if (upper_bound > 1) { /* More than one repetition is allowed, so append a backward jump to the `succeed_n' that starts this interval. When we've reached this during matching, we'll have matched the interval once, so jump back only `upper_bound - 1' times. */ STORE_JUMP2 (jump_n, b, laststart + 5, upper_bound - 1); b += 5; /* The location we want to set is the second parameter of the `jump_n'; that is `b-2' as an absolute address. `laststart' will be the `set_number_at' we're about to insert; `laststart+3' the number to set, the source for the relative address. But we are inserting into the middle of the pattern -- so everything is getting moved up by 5. Conclusion: (b - 2) - (laststart + 3) + 5, i.e., b - laststart. We insert this at the beginning of the loop so that if we fail during matching, we'll reinitialize the bounds. */ insert_op2 (set_number_at, laststart, b - laststart, upper_bound - 1, b); b += 5; } } pending_exact = 0; beg_interval = NULL; } break; unfetch_interval: /* If an invalid interval, match the characters as literals. */ assert (beg_interval); p = beg_interval; beg_interval = NULL; /* normal_char and normal_backslash need `c'. */ PATFETCH (c); if (!(syntax & RE_NO_BK_BRACES)) { if (p > pattern && p[-1] == '\\') goto normal_backslash; } goto normal_char; #ifdef emacs /* There is no way to specify the before_dot and after_dot operators. rms says this is ok. --karl */ case '=': BUF_PUSH (at_dot); break; case 's': laststart = b; PATFETCH (c); BUF_PUSH_2 (syntaxspec, syntax_spec_code[c]); break; case 'S': laststart = b; PATFETCH (c); BUF_PUSH_2 (notsyntaxspec, syntax_spec_code[c]); break; #endif /* emacs */ case 'w': laststart = b; BUF_PUSH (wordchar); break; case 'W': laststart = b; BUF_PUSH (notwordchar); break; case '<': BUF_PUSH (wordbeg); break; case '>': BUF_PUSH (wordend); break; case 'b': BUF_PUSH (wordbound); break; case 'B': BUF_PUSH (notwordbound); break; case '`': BUF_PUSH (begbuf); break; case '\'': BUF_PUSH (endbuf); break; case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': if (syntax & RE_NO_BK_REFS) goto normal_char; c1 = c - '0'; if (c1 > regnum) return REG_ESUBREG; /* Can't back reference to a subexpression if inside of it. */ if (group_in_compile_stack (compile_stack, c1)) goto normal_char; laststart = b; BUF_PUSH_2 (duplicate, c1); break; case '+': case '?': if (syntax & RE_BK_PLUS_QM) goto handle_plus; else goto normal_backslash; default: normal_backslash: /* You might think it would be useful for \ to mean not to translate; but if we don't translate it it will never match anything. */ c = TRANSLATE (c); goto normal_char; } break; default: /* Expects the character in `c'. */ normal_char: /* If no exactn currently being built. */ if (!pending_exact /* If last exactn not at current position. */ || pending_exact + *pending_exact + 1 != b /* We have only one byte following the exactn for the count. */ || *pending_exact == (1 << BYTEWIDTH) - 1 /* If followed by a repetition operator. */ || *p == '*' || *p == '^' || ((syntax & RE_BK_PLUS_QM) ? *p == '\\' && (p[1] == '+' || p[1] == '?') : (*p == '+' || *p == '?')) || ((syntax & RE_INTERVALS) && ((syntax & RE_NO_BK_BRACES) ? *p == '{' : (p[0] == '\\' && p[1] == '{')))) { /* Start building a new exactn. */ laststart = b; BUF_PUSH_2 (exactn, 0); pending_exact = b - 1; } BUF_PUSH (c); (*pending_exact)++; break; } /* switch (c) */ } /* while p != pend */ /* Through the pattern now. */ if (fixup_alt_jump) STORE_JUMP (jump_past_alt, fixup_alt_jump, b); if (!COMPILE_STACK_EMPTY) return REG_EPAREN; free (compile_stack.stack); /* We have succeeded; set the length of the buffer. */ bufp->used = b - bufp->buffer; #ifdef DEBUG if (debug) { DEBUG_PRINT1 ("\nCompiled pattern: \n"); print_compiled_pattern (bufp); } #endif /* DEBUG */ #ifndef MATCH_MAY_ALLOCATE /* Initialize the failure stack to the largest possible stack. This isn't necessary unless we're trying to avoid calling alloca in the search and match routines. */ { int num_regs = bufp->re_nsub + 1; /* Since DOUBLE_FAIL_STACK refuses to double only if the current size is strictly greater than re_max_failures, the largest possible stack is 2 * re_max_failures failure points. */ if (fail_stack.size < (2 * re_max_failures * MAX_FAILURE_ITEMS)) { fail_stack.size = (2 * re_max_failures * MAX_FAILURE_ITEMS); #ifdef emacs if (! fail_stack.stack) fail_stack.stack = (fail_stack_elt_t *) xmalloc (fail_stack.size * sizeof (fail_stack_elt_t)); else fail_stack.stack = (fail_stack_elt_t *) xrealloc (fail_stack.stack, (fail_stack.size * sizeof (fail_stack_elt_t))); #else /* not emacs */ if (! fail_stack.stack) fail_stack.stack = (fail_stack_elt_t *) malloc (fail_stack.size * sizeof (fail_stack_elt_t)); else fail_stack.stack = (fail_stack_elt_t *) realloc (fail_stack.stack, (fail_stack.size * sizeof (fail_stack_elt_t))); #endif /* not emacs */ } /* Initialize some other variables the matcher uses. */ RETALLOC_IF (regstart, num_regs, const char *); RETALLOC_IF (regend, num_regs, const char *); RETALLOC_IF (old_regstart, num_regs, const char *); RETALLOC_IF (old_regend, num_regs, const char *); RETALLOC_IF (best_regstart, num_regs, const char *); RETALLOC_IF (best_regend, num_regs, const char *); RETALLOC_IF (reg_info, num_regs, register_info_type); RETALLOC_IF (reg_dummy, num_regs, const char *); RETALLOC_IF (reg_info_dummy, num_regs, register_info_type); } #endif return REG_NOERROR; } /* regex_compile */ /* Subroutines for `regex_compile'. */ /* Store OP at LOC followed by two-byte integer parameter ARG. */ static void store_op1 (op, loc, arg) re_opcode_t op; unsigned char *loc; int arg; { *loc = (unsigned char) op; STORE_NUMBER (loc + 1, arg); } /* Like `store_op1', but for two two-byte parameters ARG1 and ARG2. */ static void store_op2 (op, loc, arg1, arg2) re_opcode_t op; unsigned char *loc; int arg1, arg2; { *loc = (unsigned char) op; STORE_NUMBER (loc + 1, arg1); STORE_NUMBER (loc + 3, arg2); } /* Copy the bytes from LOC to END to open up three bytes of space at LOC for OP followed by two-byte integer parameter ARG. */ static void insert_op1 (op, loc, arg, end) re_opcode_t op; unsigned char *loc; int arg; unsigned char *end; { register unsigned char *pfrom = end; register unsigned char *pto = end + 3; while (pfrom != loc) *--pto = *--pfrom; store_op1 (op, loc, arg); } /* Like `insert_op1', but for two two-byte parameters ARG1 and ARG2. */ static void insert_op2 (op, loc, arg1, arg2, end) re_opcode_t op; unsigned char *loc; int arg1, arg2; unsigned char *end; { register unsigned char *pfrom = end; register unsigned char *pto = end + 5; while (pfrom != loc) *--pto = *--pfrom; store_op2 (op, loc, arg1, arg2); } /* P points to just after a ^ in PATTERN. Return true if that ^ comes after an alternative or a begin-subexpression. We assume there is at least one character before the ^. */ static boolean at_begline_loc_p (pattern, p, syntax) const char *pattern, *p; reg_syntax_t syntax; { const char *prev = p - 2; boolean prev_prev_backslash = prev > pattern && prev[-1] == '\\'; return /* After a subexpression? */ (*prev == '(' && (syntax & RE_NO_BK_PARENS || prev_prev_backslash)) /* After an alternative? */ || (*prev == '|' && (syntax & RE_NO_BK_VBAR || prev_prev_backslash)); } /* The dual of at_begline_loc_p. This one is for $. We assume there is at least one character after the $, i.e., `P < PEND'. */ static boolean at_endline_loc_p (p, pend, syntax) const char *p, *pend; int syntax; { const char *next = p; boolean next_backslash = *next == '\\'; const char *next_next = p + 1 < pend ? p + 1 : NULL; return /* Before a subexpression? */ (syntax & RE_NO_BK_PARENS ? *next == ')' : next_backslash && next_next && *next_next == ')') /* Before an alternative? */ || (syntax & RE_NO_BK_VBAR ? *next == '|' : next_backslash && next_next && *next_next == '|'); } /* Returns true if REGNUM is in one of COMPILE_STACK's elements and false if it's not. */ static boolean group_in_compile_stack (compile_stack, regnum) compile_stack_type compile_stack; regnum_t regnum; { int this_element; for (this_element = compile_stack.avail - 1; this_element >= 0; this_element--) if (compile_stack.stack[this_element].regnum == regnum) return true; return false; } /* Read the ending character of a range (in a bracket expression) from the uncompiled pattern *P_PTR (which ends at PEND). We assume the starting character is in `P[-2]'. (`P[-1]' is the character `-'.) Then we set the translation of all bits between the starting and ending characters (inclusive) in the compiled pattern B. Return an error code. We use these short variable names so we can use the same macros as `regex_compile' itself. */ static reg_errcode_t compile_range (p_ptr, pend, translate, syntax, b) const char **p_ptr, *pend; char *translate; reg_syntax_t syntax; unsigned char *b; { unsigned this_char; const char *p = *p_ptr; int range_start, range_end; if (p == pend) return REG_ERANGE; /* Even though the pattern is a signed `char *', we need to fetch with unsigned char *'s; if the high bit of the pattern character is set, the range endpoints will be negative if we fetch using a signed char *. We also want to fetch the endpoints without translating them; the appropriate translation is done in the bit-setting loop below. */ range_start = ((unsigned char *) p)[-2]; range_end = ((unsigned char *) p)[0]; /* Have to increment the pointer into the pattern string, so the caller isn't still at the ending character. */ (*p_ptr)++; /* If the start is after the end, the range is empty. */ if (range_start > range_end) return syntax & RE_NO_EMPTY_RANGES ? REG_ERANGE : REG_NOERROR; /* Here we see why `this_char' has to be larger than an `unsigned char' -- the range is inclusive, so if `range_end' == 0xff (assuming 8-bit characters), we would otherwise go into an infinite loop, since all characters <= 0xff. */ for (this_char = range_start; this_char <= range_end; this_char++) { SET_LIST_BIT (TRANSLATE (this_char)); } return REG_NOERROR; } /* re_compile_fastmap computes a ``fastmap'' for the compiled pattern in BUFP. A fastmap records which of the (1 << BYTEWIDTH) possible characters can start a string that matches the pattern. This fastmap is used by re_search to skip quickly over impossible starting points. The caller must supply the address of a (1 << BYTEWIDTH)-byte data area as BUFP->fastmap. We set the `fastmap', `fastmap_accurate', and `can_be_null' fields in the pattern buffer. Returns 0 if we succeed, -2 if an internal error. */ int re_compile_fastmap (bufp) struct re_pattern_buffer *bufp; { int j, k; #ifdef MATCH_MAY_ALLOCATE fail_stack_type fail_stack; #endif #ifndef REGEX_MALLOC char *destination; #endif /* We don't push any register information onto the failure stack. */ unsigned num_regs = 0; register char *fastmap = bufp->fastmap; unsigned char *pattern = bufp->buffer; unsigned long size = bufp->used; unsigned char *p = pattern; register unsigned char *pend = pattern + size; /* Assume that each path through the pattern can be null until proven otherwise. We set this false at the bottom of switch statement, to which we get only if a particular path doesn't match the empty string. */ boolean path_can_be_null = true; /* We aren't doing a `succeed_n' to begin with. */ boolean succeed_n_p = false; assert (fastmap != NULL && p != NULL); INIT_FAIL_STACK (); bzero (fastmap, 1 << BYTEWIDTH); /* Assume nothing's valid. */ bufp->fastmap_accurate = 1; /* It will be when we're done. */ bufp->can_be_null = 0; while (p != pend || !FAIL_STACK_EMPTY ()) { if (p == pend) { bufp->can_be_null |= path_can_be_null; /* Reset for next path. */ path_can_be_null = true; p = fail_stack.stack[--fail_stack.avail]; } /* We should never be about to go beyond the end of the pattern. */ assert (p < pend); #ifdef SWITCH_ENUM_BUG switch ((int) ((re_opcode_t) *p++)) #else switch ((re_opcode_t) *p++) #endif { /* I guess the idea here is to simply not bother with a fastmap if a backreference is used, since it's too hard to figure out the fastmap for the corresponding group. Setting `can_be_null' stops `re_search_2' from using the fastmap, so that is all we do. */ case duplicate: bufp->can_be_null = 1; return 0; /* Following are the cases which match a character. These end with `break'. */ case exactn: fastmap[p[1]] = 1; break; case charset: for (j = *p++ * BYTEWIDTH - 1; j >= 0; j--) if (p[j / BYTEWIDTH] & (1 << (j % BYTEWIDTH))) fastmap[j] = 1; break; case charset_not: /* Chars beyond end of map must be allowed. */ for (j = *p * BYTEWIDTH; j < (1 << BYTEWIDTH); j++) fastmap[j] = 1; for (j = *p++ * BYTEWIDTH - 1; j >= 0; j--) if (!(p[j / BYTEWIDTH] & (1 << (j % BYTEWIDTH)))) fastmap[j] = 1; break; case wordchar: for (j = 0; j < (1 << BYTEWIDTH); j++) if (SYNTAX (j) == Sword) fastmap[j] = 1; break; case notwordchar: for (j = 0; j < (1 << BYTEWIDTH); j++) if (SYNTAX (j) != Sword) fastmap[j] = 1; break; case anychar: /* `.' matches anything ... */ for (j = 0; j < (1 << BYTEWIDTH); j++) fastmap[j] = 1; /* ... except perhaps newline. */ if (!(bufp->syntax & RE_DOT_NEWLINE)) fastmap['\n'] = 0; /* Return if we have already set `can_be_null'; if we have, then the fastmap is irrelevant. Something's wrong here. */ else if (bufp->can_be_null) return 0; /* Otherwise, have to check alternative paths. */ break; #ifdef emacs case syntaxspec: k = *p++; for (j = 0; j < (1 << BYTEWIDTH); j++) if (SYNTAX (j) == (enum syntaxcode) k) fastmap[j] = 1; break; case notsyntaxspec: k = *p++; for (j = 0; j < (1 << BYTEWIDTH); j++) if (SYNTAX (j) != (enum syntaxcode) k) fastmap[j] = 1; break; /* All cases after this match the empty string. These end with `continue'. */ case before_dot: case at_dot: case after_dot: continue; #endif /* not emacs */ case no_op: case begline: case endline: case begbuf: case endbuf: case wordbound: case notwordbound: case wordbeg: case wordend: case push_dummy_failure: continue; case jump_n: case pop_failure_jump: case maybe_pop_jump: case jump: case jump_past_alt: case dummy_failure_jump: EXTRACT_NUMBER_AND_INCR (j, p); p += j; if (j > 0) continue; /* Jump backward implies we just went through the body of a loop and matched nothing. Opcode jumped to should be `on_failure_jump' or `succeed_n'. Just treat it like an ordinary jump. For a * loop, it has pushed its failure point already; if so, discard that as redundant. */ if ((re_opcode_t) *p != on_failure_jump && (re_opcode_t) *p != succeed_n) continue; p++; EXTRACT_NUMBER_AND_INCR (j, p); p += j; /* If what's on the stack is where we are now, pop it. */ if (!FAIL_STACK_EMPTY () && fail_stack.stack[fail_stack.avail - 1] == p) fail_stack.avail--; continue; case on_failure_jump: case on_failure_keep_string_jump: handle_on_failure_jump: EXTRACT_NUMBER_AND_INCR (j, p); /* For some patterns, e.g., `(a?)?', `p+j' here points to the end of the pattern. We don't want to push such a point, since when we restore it above, entering the switch will increment `p' past the end of the pattern. We don't need to push such a point since we obviously won't find any more fastmap entries beyond `pend'. Such a pattern can match the null string, though. */ if (p + j < pend) { if (!PUSH_PATTERN_OP (p + j, fail_stack)) return -2; } else bufp->can_be_null = 1; if (succeed_n_p) { EXTRACT_NUMBER_AND_INCR (k, p); /* Skip the n. */ succeed_n_p = false; } continue; case succeed_n: /* Get to the number of times to succeed. */ p += 2; /* Increment p past the n for when k != 0. */ EXTRACT_NUMBER_AND_INCR (k, p); if (k == 0) { p -= 4; succeed_n_p = true; /* Spaghetti code alert. */ goto handle_on_failure_jump; } continue; case set_number_at: p += 4; continue; case start_memory: case stop_memory: p += 2; continue; default: abort (); /* We have listed all the cases. */ } /* switch *p++ */ /* Getting here means we have found the possible starting characters for one path of the pattern -- and that the empty string does not match. We need not follow this path further. Instead, look at the next alternative (remembered on the stack), or quit if no more. The test at the top of the loop does these things. */ path_can_be_null = false; p = pend; } /* while p */ /* Set `can_be_null' for the last path (also the first path, if the pattern is empty). */ bufp->can_be_null |= path_can_be_null; return 0; } /* re_compile_fastmap */ /* Set REGS to hold NUM_REGS registers, storing them in STARTS and ENDS. Subsequent matches using PATTERN_BUFFER and REGS will use this memory for recording register information. STARTS and ENDS must be allocated using the malloc library routine, and must each be at least NUM_REGS * sizeof (regoff_t) bytes long. If NUM_REGS == 0, then subsequent matches should allocate their own register data. Unless this function is called, the first search or match using PATTERN_BUFFER will allocate its own register data, without freeing the old data. */ void re_set_registers (bufp, regs, num_regs, starts, ends) struct re_pattern_buffer *bufp; struct re_registers *regs; unsigned num_regs; regoff_t *starts, *ends; { if (num_regs) { bufp->regs_allocated = REGS_REALLOCATE; regs->num_regs = num_regs; regs->start = starts; regs->end = ends; } else { bufp->regs_allocated = REGS_UNALLOCATED; regs->num_regs = 0; regs->start = regs->end = (regoff_t *) 0; } } /* Searching routines. */ /* Like re_search_2, below, but only one string is specified, and doesn't let you say where to stop matching. */ int re_search (bufp, string, size, startpos, range, regs) struct re_pattern_buffer *bufp; const char *string; int size, startpos, range; struct re_registers *regs; { return re_search_2 (bufp, NULL, 0, string, size, startpos, range, regs, size); } /* Using the compiled pattern in BUFP->buffer, first tries to match the virtual concatenation of STRING1 and STRING2, starting first at index STARTPOS, then at STARTPOS + 1, and so on. STRING1 and STRING2 have length SIZE1 and SIZE2, respectively. RANGE is how far to scan while trying to match. RANGE = 0 means try only at STARTPOS; in general, the last start tried is STARTPOS + RANGE. In REGS, return the indices of the virtual concatenation of STRING1 and STRING2 that matched the entire BUFP->buffer and its contained subexpressions. Do not consider matching one past the index STOP in the virtual concatenation of STRING1 and STRING2. We return either the position in the strings at which the match was found, -1 if no match, or -2 if error (such as failure stack overflow). */ int re_search_2 (bufp, string1, size1, string2, size2, startpos, range, regs, stop) struct re_pattern_buffer *bufp; const char *string1, *string2; int size1, size2; int startpos; int range; struct re_registers *regs; int stop; { int val; register char *fastmap = bufp->fastmap; register char *translate = bufp->translate; int total_size = size1 + size2; int endpos = startpos + range; /* Check for out-of-range STARTPOS. */ if (startpos < 0 || startpos > total_size) return -1; /* Fix up RANGE if it might eventually take us outside the virtual concatenation of STRING1 and STRING2. */ if (endpos < -1) range = -1 - startpos; else if (endpos > total_size) range = total_size - startpos; /* If the search isn't to be a backwards one, don't waste time in a search for a pattern that must be anchored. */ if (bufp->used > 0 && (re_opcode_t) bufp->buffer[0] == begbuf && range > 0) { if (startpos > 0) return -1; else range = 1; } /* Update the fastmap now if not correct already. */ if (fastmap && !bufp->fastmap_accurate) if (re_compile_fastmap (bufp) == -2) return -2; /* Loop through the string, looking for a place to start matching. */ for (;;) { /* If a fastmap is supplied, skip quickly over characters that cannot be the start of a match. If the pattern can match the null string, however, we don't need to skip characters; we want the first null string. */ if (fastmap && startpos < total_size && !bufp->can_be_null) { if (range > 0) /* Searching forwards. */ { register const char *d; register int lim = 0; int irange = range; if (startpos < size1 && startpos + range >= size1) lim = range - (size1 - startpos); d = (startpos >= size1 ? string2 - size1 : string1) + startpos; /* Written out as an if-else to avoid testing `translate' inside the loop. */ if (translate) while (range > lim && !fastmap[(unsigned char) translate[(unsigned char) *d++]]) range--; else while (range > lim && !fastmap[(unsigned char) *d++]) range--; startpos += irange - range; } else /* Searching backwards. */ { register char c = (size1 == 0 || startpos >= size1 ? string2[startpos - size1] : string1[startpos]); if (!fastmap[(unsigned char) TRANSLATE (c)]) goto advance; } } /* If can't match the null string, and that's all we have left, fail. */ if (range >= 0 && startpos == total_size && fastmap && !bufp->can_be_null) return -1; val = re_match_2_internal (bufp, string1, size1, string2, size2, startpos, regs, stop); #ifndef REGEX_MALLOC #ifdef C_ALLOCA alloca (0); #endif #endif if (val >= 0) return startpos; if (val == -2) return -2; advance: if (!range) break; else if (range > 0) { range--; startpos++; } else { range++; startpos--; } } return -1; } /* re_search_2 */ /* Declarations and macros for re_match_2. */ static int bcmp_translate (); static boolean alt_match_null_string_p (), common_op_match_null_string_p (), group_match_null_string_p (); /* This converts PTR, a pointer into one of the search strings `string1' and `string2' into an offset from the beginning of that string. */ #define POINTER_TO_OFFSET(ptr) \ (FIRST_STRING_P (ptr) \ ? ((regoff_t) ((ptr) - string1)) \ : ((regoff_t) ((ptr) - string2 + size1))) /* Macros for dealing with the split strings in re_match_2. */ #define MATCHING_IN_FIRST_STRING (dend == end_match_1) /* Call before fetching a character with *d. This switches over to string2 if necessary. */ #define PREFETCH() \ while (d == dend) \ { \ /* End of string2 => fail. */ \ if (dend == end_match_2) \ goto fail; \ /* End of string1 => advance to string2. */ \ d = string2; \ dend = end_match_2; \ } /* Test if at very beginning or at very end of the virtual concatenation of `string1' and `string2'. If only one string, it's `string2'. */ #define AT_STRINGS_BEG(d) ((d) == (size1 ? string1 : string2) || !size2) #define AT_STRINGS_END(d) ((d) == end2) /* Test if D points to a character which is word-constituent. We have two special cases to check for: if past the end of string1, look at the first character in string2; and if before the beginning of string2, look at the last character in string1. */ #define WORDCHAR_P(d) \ (SYNTAX ((d) == end1 ? *string2 \ : (d) == string2 - 1 ? *(end1 - 1) : *(d)) \ == Sword) /* Test if the character before D and the one at D differ with respect to being word-constituent. */ #define AT_WORD_BOUNDARY(d) \ (AT_STRINGS_BEG (d) || AT_STRINGS_END (d) \ || WORDCHAR_P (d - 1) != WORDCHAR_P (d)) /* Free everything we malloc. */ #ifdef MATCH_MAY_ALLOCATE #ifdef REGEX_MALLOC #define FREE_VAR(var) if (var) free (var); var = NULL #define FREE_VARIABLES() \ do { \ FREE_VAR (fail_stack.stack); \ FREE_VAR (regstart); \ FREE_VAR (regend); \ FREE_VAR (old_regstart); \ FREE_VAR (old_regend); \ FREE_VAR (best_regstart); \ FREE_VAR (best_regend); \ FREE_VAR (reg_info); \ FREE_VAR (reg_dummy); \ FREE_VAR (reg_info_dummy); \ } while (0) #else /* not REGEX_MALLOC */ /* This used to do alloca (0), but now we do that in the caller. */ #define FREE_VARIABLES() /* Nothing */ #endif /* not REGEX_MALLOC */ #else #define FREE_VARIABLES() /* Do nothing! */ #endif /* not MATCH_MAY_ALLOCATE */ /* These values must meet several constraints. They must not be valid register values; since we have a limit of 255 registers (because we use only one byte in the pattern for the register number), we can use numbers larger than 255. They must differ by 1, because of NUM_FAILURE_ITEMS above. And the value for the lowest register must be larger than the value for the highest register, so we do not try to actually save any registers when none are active. */ #define NO_HIGHEST_ACTIVE_REG (1 << BYTEWIDTH) #define NO_LOWEST_ACTIVE_REG (NO_HIGHEST_ACTIVE_REG + 1) /* Matching routines. */ #ifndef emacs /* Emacs never uses this. */ /* re_match is like re_match_2 except it takes only a single string. */ int re_match (bufp, string, size, pos, regs) struct re_pattern_buffer *bufp; const char *string; int size, pos; struct re_registers *regs; { int result = re_match_2_internal (bufp, NULL, 0, string, size, pos, regs, size); alloca (0); return result; } #endif /* not emacs */ /* re_match_2 matches the compiled pattern in BUFP against the the (virtual) concatenation of STRING1 and STRING2 (of length SIZE1 and SIZE2, respectively). We start matching at POS, and stop matching at STOP. If REGS is non-null and the `no_sub' field of BUFP is nonzero, we store offsets for the substring each group matched in REGS. See the documentation for exactly how many groups we fill. We return -1 if no match, -2 if an internal error (such as the failure stack overflowing). Otherwise, we return the length of the matched substring. */ int re_match_2 (bufp, string1, size1, string2, size2, pos, regs, stop) struct re_pattern_buffer *bufp; const char *string1, *string2; int size1, size2; int pos; struct re_registers *regs; int stop; { int result = re_match_2_internal (bufp, string1, size1, string2, size2, pos, regs, stop); alloca (0); return result; } /* This is a separate function so that we can force an alloca cleanup afterwards. */ static int re_match_2_internal (bufp, string1, size1, string2, size2, pos, regs, stop) struct re_pattern_buffer *bufp; const char *string1, *string2; int size1, size2; int pos; struct re_registers *regs; int stop; { /* General temporaries. */ int mcnt; unsigned char *p1; /* Just past the end of the corresponding string. */ const char *end1, *end2; /* Pointers into string1 and string2, just past the last characters in each to consider matching. */ const char *end_match_1, *end_match_2; /* Where we are in the data, and the end of the current string. */ const char *d, *dend; /* Where we are in the pattern, and the end of the pattern. */ unsigned char *p = bufp->buffer; register unsigned char *pend = p + bufp->used; /* Mark the opcode just after a start_memory, so we can test for an empty subpattern when we get to the stop_memory. */ unsigned char *just_past_start_mem = 0; /* We use this to map every character in the string. */ char *translate = bufp->translate; /* Failure point stack. Each place that can handle a failure further down the line pushes a failure point on this stack. It consists of restart, regend, and reg_info for all registers corresponding to the subexpressions we're currently inside, plus the number of such registers, and, finally, two char *'s. The first char * is where to resume scanning the pattern; the second one is where to resume scanning the strings. If the latter is zero, the failure point is a ``dummy''; if a failure happens and the failure point is a dummy, it gets discarded and the next next one is tried. */ #ifdef MATCH_MAY_ALLOCATE /* otherwise, this is global. */ fail_stack_type fail_stack; #endif #ifdef DEBUG static unsigned failure_id = 0; unsigned nfailure_points_pushed = 0, nfailure_points_popped = 0; #endif /* We fill all the registers internally, independent of what we return, for use in backreferences. The number here includes an element for register zero. */ unsigned num_regs = bufp->re_nsub + 1; /* The currently active registers. */ unsigned lowest_active_reg = NO_LOWEST_ACTIVE_REG; unsigned highest_active_reg = NO_HIGHEST_ACTIVE_REG; /* Information on the contents of registers. These are pointers into the input strings; they record just what was matched (on this attempt) by a subexpression part of the pattern, that is, the regnum-th regstart pointer points to where in the pattern we began matching and the regnum-th regend points to right after where we stopped matching the regnum-th subexpression. (The zeroth register keeps track of what the whole pattern matches.) */ #ifdef MATCH_MAY_ALLOCATE /* otherwise, these are global. */ const char **regstart, **regend; #endif /* If a group that's operated upon by a repetition operator fails to match anything, then the register for its start will need to be restored because it will have been set to wherever in the string we are when we last see its open-group operator. Similarly for a register's end. */ #ifdef MATCH_MAY_ALLOCATE /* otherwise, these are global. */ const char **old_regstart, **old_regend; #endif /* The is_active field of reg_info helps us keep track of which (possibly nested) subexpressions we are currently in. The matched_something field of reg_info[reg_num] helps us tell whether or not we have matched any of the pattern so far this time through the reg_num-th subexpression. These two fields get reset each time through any loop their register is in. */ #ifdef MATCH_MAY_ALLOCATE /* otherwise, this is global. */ register_info_type *reg_info; #endif /* The following record the register info as found in the above variables when we find a match better than any we've seen before. This happens as we backtrack through the failure points, which in turn happens only if we have not yet matched the entire string. */ unsigned best_regs_set = false; #ifdef MATCH_MAY_ALLOCATE /* otherwise, these are global. */ const char **best_regstart, **best_regend; #endif /* Logically, this is `best_regend[0]'. But we don't want to have to allocate space for that if we're not allocating space for anything else (see below). Also, we never need info about register 0 for any of the other register vectors, and it seems rather a kludge to treat `best_regend' differently than the rest. So we keep track of the end of the best match so far in a separate variable. We initialize this to NULL so that when we backtrack the first time and need to test it, it's not garbage. */ const char *match_end = NULL; /* Used when we pop values we don't care about. */ #ifdef MATCH_MAY_ALLOCATE /* otherwise, these are global. */ const char **reg_dummy; register_info_type *reg_info_dummy; #endif #ifdef DEBUG /* Counts the total number of registers pushed. */ unsigned num_regs_pushed = 0; #endif DEBUG_PRINT1 ("\n\nEntering re_match_2.\n"); INIT_FAIL_STACK (); #ifdef MATCH_MAY_ALLOCATE /* Do not bother to initialize all the register variables if there are no groups in the pattern, as it takes a fair amount of time. If there are groups, we include space for register 0 (the whole pattern), even though we never use it, since it simplifies the array indexing. We should fix this. */ if (bufp->re_nsub) { regstart = REGEX_TALLOC (num_regs, const char *); regend = REGEX_TALLOC (num_regs, const char *); old_regstart = REGEX_TALLOC (num_regs, const char *); old_regend = REGEX_TALLOC (num_regs, const char *); best_regstart = REGEX_TALLOC (num_regs, const char *); best_regend = REGEX_TALLOC (num_regs, const char *); reg_info = REGEX_TALLOC (num_regs, register_info_type); reg_dummy = REGEX_TALLOC (num_regs, const char *); reg_info_dummy = REGEX_TALLOC (num_regs, register_info_type); if (!(regstart && regend && old_regstart && old_regend && reg_info && best_regstart && best_regend && reg_dummy && reg_info_dummy)) { FREE_VARIABLES (); return -2; } } #if defined (REGEX_MALLOC) else { /* We must initialize all our variables to NULL, so that `FREE_VARIABLES' doesn't try to free them. */ regstart = regend = old_regstart = old_regend = best_regstart = best_regend = reg_dummy = NULL; reg_info = reg_info_dummy = (register_info_type *) NULL; } #endif /* REGEX_MALLOC */ #endif /* MATCH_MAY_ALLOCATE */ /* The starting position is bogus. */ if (pos < 0 || pos > size1 + size2) { FREE_VARIABLES (); return -1; } /* Initialize subexpression text positions to -1 to mark ones that no start_memory/stop_memory has been seen for. Also initialize the register information struct. */ for (mcnt = 1; mcnt < num_regs; mcnt++) { regstart[mcnt] = regend[mcnt] = old_regstart[mcnt] = old_regend[mcnt] = REG_UNSET_VALUE; REG_MATCH_NULL_STRING_P (reg_info[mcnt]) = MATCH_NULL_UNSET_VALUE; IS_ACTIVE (reg_info[mcnt]) = 0; MATCHED_SOMETHING (reg_info[mcnt]) = 0; EVER_MATCHED_SOMETHING (reg_info[mcnt]) = 0; } /* We move `string1' into `string2' if the latter's empty -- but not if `string1' is null. */ if (size2 == 0 && string1 != NULL) { string2 = string1; size2 = size1; string1 = 0; size1 = 0; } end1 = string1 + size1; end2 = string2 + size2; /* Compute where to stop matching, within the two strings. */ if (stop <= size1) { end_match_1 = string1 + stop; end_match_2 = string2; } else { end_match_1 = end1; end_match_2 = string2 + stop - size1; } /* `p' scans through the pattern as `d' scans through the data. `dend' is the end of the input string that `d' points within. `d' is advanced into the following input string whenever necessary, but this happens before fetching; therefore, at the beginning of the loop, `d' can be pointing at the end of a string, but it cannot equal `string2'. */ if (size1 > 0 && pos <= size1) { d = string1 + pos; dend = end_match_1; } else { d = string2 + pos - size1; dend = end_match_2; } DEBUG_PRINT1 ("The compiled pattern is: "); DEBUG_PRINT_COMPILED_PATTERN (bufp, p, pend); DEBUG_PRINT1 ("The string to match is: `"); DEBUG_PRINT_DOUBLE_STRING (d, string1, size1, string2, size2); DEBUG_PRINT1 ("'\n"); /* This loops over pattern commands. It exits by returning from the function if the match is complete, or it drops through if the match fails at this starting point in the input data. */ for (;;) { DEBUG_PRINT2 ("\n0x%x: ", p); if (p == pend) { /* End of pattern means we might have succeeded. */ DEBUG_PRINT1 ("end of pattern ... "); /* If we haven't matched the entire string, and we want the longest match, try backtracking. */ if (d != end_match_2) { DEBUG_PRINT1 ("backtracking.\n"); if (!FAIL_STACK_EMPTY ()) { /* More failure points to try. */ boolean same_str_p = (FIRST_STRING_P (match_end) == MATCHING_IN_FIRST_STRING); /* If exceeds best match so far, save it. */ if (!best_regs_set || (same_str_p && d > match_end) || (!same_str_p && !MATCHING_IN_FIRST_STRING)) { best_regs_set = true; match_end = d; DEBUG_PRINT1 ("\nSAVING match as best so far.\n"); for (mcnt = 1; mcnt < num_regs; mcnt++) { best_regstart[mcnt] = regstart[mcnt]; best_regend[mcnt] = regend[mcnt]; } } goto fail; } /* If no failure points, don't restore garbage. */ else if (best_regs_set) { restore_best_regs: /* Restore best match. It may happen that `dend == end_match_1' while the restored d is in string2. For example, the pattern `x.*y.*z' against the strings `x-' and `y-z-', if the two strings are not consecutive in memory. */ DEBUG_PRINT1 ("Restoring best registers.\n"); d = match_end; dend = ((d >= string1 && d <= end1) ? end_match_1 : end_match_2); for (mcnt = 1; mcnt < num_regs; mcnt++) { regstart[mcnt] = best_regstart[mcnt]; regend[mcnt] = best_regend[mcnt]; } } } /* d != end_match_2 */ DEBUG_PRINT1 ("Accepting match.\n"); /* If caller wants register contents data back, do it. */ if (regs && !bufp->no_sub) { /* Have the register data arrays been allocated? */ if (bufp->regs_allocated == REGS_UNALLOCATED) { /* No. So allocate them with malloc. We need one extra element beyond `num_regs' for the `-1' marker GNU code uses. */ regs->num_regs = MAX (RE_NREGS, num_regs + 1); regs->start = TALLOC (regs->num_regs, regoff_t); regs->end = TALLOC (regs->num_regs, regoff_t); if (regs->start == NULL || regs->end == NULL) return -2; bufp->regs_allocated = REGS_REALLOCATE; } else if (bufp->regs_allocated == REGS_REALLOCATE) { /* Yes. If we need more elements than were already allocated, reallocate them. If we need fewer, just leave it alone. */ if (regs->num_regs < num_regs + 1) { regs->num_regs = num_regs + 1; RETALLOC (regs->start, regs->num_regs, regoff_t); RETALLOC (regs->end, regs->num_regs, regoff_t); if (regs->start == NULL || regs->end == NULL) return -2; } } else { /* These braces fend off a "empty body in an else-statement" warning under GCC when assert expands to nothing. */ assert (bufp->regs_allocated == REGS_FIXED); } /* Convert the pointer data in `regstart' and `regend' to indices. Register zero has to be set differently, since we haven't kept track of any info for it. */ if (regs->num_regs > 0) { regs->start[0] = pos; regs->end[0] = (MATCHING_IN_FIRST_STRING ? ((regoff_t) (d - string1)) : ((regoff_t) (d - string2 + size1))); } /* Go through the first `min (num_regs, regs->num_regs)' registers, since that is all we initialized. */ for (mcnt = 1; mcnt < MIN (num_regs, regs->num_regs); mcnt++) { if (REG_UNSET (regstart[mcnt]) || REG_UNSET (regend[mcnt])) regs->start[mcnt] = regs->end[mcnt] = -1; else { regs->start[mcnt] = (regoff_t) POINTER_TO_OFFSET (regstart[mcnt]); regs->end[mcnt] = (regoff_t) POINTER_TO_OFFSET (regend[mcnt]); } } /* If the regs structure we return has more elements than were in the pattern, set the extra elements to -1. If we (re)allocated the registers, this is the case, because we always allocate enough to have at least one -1 at the end. */ for (mcnt = num_regs; mcnt < regs->num_regs; mcnt++) regs->start[mcnt] = regs->end[mcnt] = -1; } /* regs && !bufp->no_sub */ FREE_VARIABLES (); DEBUG_PRINT4 ("%u failure points pushed, %u popped (%u remain).\n", nfailure_points_pushed, nfailure_points_popped, nfailure_points_pushed - nfailure_points_popped); DEBUG_PRINT2 ("%u registers pushed.\n", num_regs_pushed); mcnt = d - pos - (MATCHING_IN_FIRST_STRING ? string1 : string2 - size1); DEBUG_PRINT2 ("Returning %d from re_match_2.\n", mcnt); return mcnt; } /* Otherwise match next pattern command. */ #ifdef SWITCH_ENUM_BUG switch ((int) ((re_opcode_t) *p++)) #else switch ((re_opcode_t) *p++) #endif { /* Ignore these. Used to ignore the n of succeed_n's which currently have n == 0. */ case no_op: DEBUG_PRINT1 ("EXECUTING no_op.\n"); break; /* Match the next n pattern characters exactly. The following byte in the pattern defines n, and the n bytes after that are the characters to match. */ case exactn: mcnt = *p++; DEBUG_PRINT2 ("EXECUTING exactn %d.\n", mcnt); /* This is written out as an if-else so we don't waste time testing `translate' inside the loop. */ if (translate) { do { PREFETCH (); if (translate[(unsigned char) *d++] != (char) *p++) goto fail; } while (--mcnt); } else { do { PREFETCH (); if (*d++ != (char) *p++) goto fail; } while (--mcnt); } SET_REGS_MATCHED (); break; /* Match any character except possibly a newline or a null. */ case anychar: DEBUG_PRINT1 ("EXECUTING anychar.\n"); PREFETCH (); if ((!(bufp->syntax & RE_DOT_NEWLINE) && TRANSLATE (*d) == '\n') || (bufp->syntax & RE_DOT_NOT_NULL && TRANSLATE (*d) == '\000')) goto fail; SET_REGS_MATCHED (); DEBUG_PRINT2 (" Matched `%d'.\n", *d); d++; break; case charset: case charset_not: { register unsigned char c; boolean not = (re_opcode_t) *(p - 1) == charset_not; DEBUG_PRINT2 ("EXECUTING charset%s.\n", not ? "_not" : ""); PREFETCH (); c = TRANSLATE (*d); /* The character to match. */ /* Cast to `unsigned' instead of `unsigned char' in case the bit list is a full 32 bytes long. */ if (c < (unsigned) (*p * BYTEWIDTH) && p[1 + c / BYTEWIDTH] & (1 << (c % BYTEWIDTH))) not = !not; p += 1 + *p; if (!not) goto fail; SET_REGS_MATCHED (); d++; break; } /* The beginning of a group is represented by start_memory. The arguments are the register number in the next byte, and the number of groups inner to this one in the next. The text matched within the group is recorded (in the internal registers data structure) under the register number. */ case start_memory: DEBUG_PRINT3 ("EXECUTING start_memory %d (%d):\n", *p, p[1]); /* Find out if this group can match the empty string. */ p1 = p; /* To send to group_match_null_string_p. */ if (REG_MATCH_NULL_STRING_P (reg_info[*p]) == MATCH_NULL_UNSET_VALUE) REG_MATCH_NULL_STRING_P (reg_info[*p]) = group_match_null_string_p (&p1, pend, reg_info); /* Save the position in the string where we were the last time we were at this open-group operator in case the group is operated upon by a repetition operator, e.g., with `(a*)*b' against `ab'; then we want to ignore where we are now in the string in case this attempt to match fails. */ old_regstart[*p] = REG_MATCH_NULL_STRING_P (reg_info[*p]) ? REG_UNSET (regstart[*p]) ? d : regstart[*p] : regstart[*p]; DEBUG_PRINT2 (" old_regstart: %d\n", POINTER_TO_OFFSET (old_regstart[*p])); regstart[*p] = d; DEBUG_PRINT2 (" regstart: %d\n", POINTER_TO_OFFSET (regstart[*p])); IS_ACTIVE (reg_info[*p]) = 1; MATCHED_SOMETHING (reg_info[*p]) = 0; /* This is the new highest active register. */ highest_active_reg = *p; /* If nothing was active before, this is the new lowest active register. */ if (lowest_active_reg == NO_LOWEST_ACTIVE_REG) lowest_active_reg = *p; /* Move past the register number and inner group count. */ p += 2; just_past_start_mem = p; break; /* The stop_memory opcode represents the end of a group. Its arguments are the same as start_memory's: the register number, and the number of inner groups. */ case stop_memory: DEBUG_PRINT3 ("EXECUTING stop_memory %d (%d):\n", *p, p[1]); /* We need to save the string position the last time we were at this close-group operator in case the group is operated upon by a repetition operator, e.g., with `((a*)*(b*)*)*' against `aba'; then we want to ignore where we are now in the string in case this attempt to match fails. */ old_regend[*p] = REG_MATCH_NULL_STRING_P (reg_info[*p]) ? REG_UNSET (regend[*p]) ? d : regend[*p] : regend[*p]; DEBUG_PRINT2 (" old_regend: %d\n", POINTER_TO_OFFSET (old_regend[*p])); regend[*p] = d; DEBUG_PRINT2 (" regend: %d\n", POINTER_TO_OFFSET (regend[*p])); /* This register isn't active anymore. */ IS_ACTIVE (reg_info[*p]) = 0; /* If this was the only register active, nothing is active anymore. */ if (lowest_active_reg == highest_active_reg) { lowest_active_reg = NO_LOWEST_ACTIVE_REG; highest_active_reg = NO_HIGHEST_ACTIVE_REG; } else { /* We must scan for the new highest active register, since it isn't necessarily one less than now: consider (a(b)c(d(e)f)g). When group 3 ends, after the f), the new highest active register is 1. */ unsigned char r = *p - 1; while (r > 0 && !IS_ACTIVE (reg_info[r])) r--; /* If we end up at register zero, that means that we saved the registers as the result of an `on_failure_jump', not a `start_memory', and we jumped to past the innermost `stop_memory'. For example, in ((.)*) we save registers 1 and 2 as a result of the *, but when we pop back to the second ), we are at the stop_memory 1. Thus, nothing is active. */ if (r == 0) { lowest_active_reg = NO_LOWEST_ACTIVE_REG; highest_active_reg = NO_HIGHEST_ACTIVE_REG; } else highest_active_reg = r; } /* If just failed to match something this time around with a group that's operated on by a repetition operator, try to force exit from the ``loop'', and restore the register information for this group that we had before trying this last match. */ if ((!MATCHED_SOMETHING (reg_info[*p]) || just_past_start_mem == p - 1) && (p + 2) < pend) { boolean is_a_jump_n = false; p1 = p + 2; mcnt = 0; switch ((re_opcode_t) *p1++) { case jump_n: is_a_jump_n = true; case pop_failure_jump: case maybe_pop_jump: case jump: case dummy_failure_jump: EXTRACT_NUMBER_AND_INCR (mcnt, p1); if (is_a_jump_n) p1 += 2; break; default: /* do nothing */ ; } p1 += mcnt; /* If the next operation is a jump backwards in the pattern to an on_failure_jump right before the start_memory corresponding to this stop_memory, exit from the loop by forcing a failure after pushing on the stack the on_failure_jump's jump in the pattern, and d. */ if (mcnt < 0 && (re_opcode_t) *p1 == on_failure_jump && (re_opcode_t) p1[3] == start_memory && p1[4] == *p) { /* If this group ever matched anything, then restore what its registers were before trying this last failed match, e.g., with `(a*)*b' against `ab' for regstart[1], and, e.g., with `((a*)*(b*)*)*' against `aba' for regend[3]. Also restore the registers for inner groups for, e.g., `((a*)(b*))*' against `aba' (register 3 would otherwise get trashed). */ if (EVER_MATCHED_SOMETHING (reg_info[*p])) { unsigned r; EVER_MATCHED_SOMETHING (reg_info[*p]) = 0; /* Restore this and inner groups' (if any) registers. */ for (r = *p; r < *p + *(p + 1); r++) { regstart[r] = old_regstart[r]; /* xx why this test? */ if ((int) old_regend[r] >= (int) regstart[r]) regend[r] = old_regend[r]; } } p1++; EXTRACT_NUMBER_AND_INCR (mcnt, p1); PUSH_FAILURE_POINT (p1 + mcnt, d, -2); goto fail; } } /* Move past the register number and the inner group count. */ p += 2; break; /* \ has been turned into a `duplicate' command which is followed by the numeric value of as the register number. */ case duplicate: { register const char *d2, *dend2; int regno = *p++; /* Get which register to match against. */ DEBUG_PRINT2 ("EXECUTING duplicate %d.\n", regno); /* Can't back reference a group which we've never matched. */ if (REG_UNSET (regstart[regno]) || REG_UNSET (regend[regno])) goto fail; /* Where in input to try to start matching. */ d2 = regstart[regno]; /* Where to stop matching; if both the place to start and the place to stop matching are in the same string, then set to the place to stop, otherwise, for now have to use the end of the first string. */ dend2 = ((FIRST_STRING_P (regstart[regno]) == FIRST_STRING_P (regend[regno])) ? regend[regno] : end_match_1); for (;;) { /* If necessary, advance to next segment in register contents. */ while (d2 == dend2) { if (dend2 == end_match_2) break; if (dend2 == regend[regno]) break; /* End of string1 => advance to string2. */ d2 = string2; dend2 = regend[regno]; } /* At end of register contents => success */ if (d2 == dend2) break; /* If necessary, advance to next segment in data. */ PREFETCH (); /* How many characters left in this segment to match. */ mcnt = dend - d; /* Want how many consecutive characters we can match in one shot, so, if necessary, adjust the count. */ if (mcnt > dend2 - d2) mcnt = dend2 - d2; /* Compare that many; failure if mismatch, else move past them. */ if (translate ? bcmp_translate (d, d2, mcnt, translate) : bcmp (d, d2, mcnt)) goto fail; d += mcnt, d2 += mcnt; } } break; /* begline matches the empty string at the beginning of the string (unless `not_bol' is set in `bufp'), and, if `newline_anchor' is set, after newlines. */ case begline: DEBUG_PRINT1 ("EXECUTING begline.\n"); if (AT_STRINGS_BEG (d)) { if (!bufp->not_bol) break; } else if (d[-1] == '\n' && bufp->newline_anchor) { break; } /* In all other cases, we fail. */ goto fail; /* endline is the dual of begline. */ case endline: DEBUG_PRINT1 ("EXECUTING endline.\n"); if (AT_STRINGS_END (d)) { if (!bufp->not_eol) break; } /* We have to ``prefetch'' the next character. */ else if ((d == end1 ? *string2 : *d) == '\n' && bufp->newline_anchor) { break; } goto fail; /* Match at the very beginning of the data. */ case begbuf: DEBUG_PRINT1 ("EXECUTING begbuf.\n"); if (AT_STRINGS_BEG (d)) break; goto fail; /* Match at the very end of the data. */ case endbuf: DEBUG_PRINT1 ("EXECUTING endbuf.\n"); if (AT_STRINGS_END (d)) break; goto fail; /* on_failure_keep_string_jump is used to optimize `.*\n'. It pushes NULL as the value for the string on the stack. Then `pop_failure_point' will keep the current value for the string, instead of restoring it. To see why, consider matching `foo\nbar' against `.*\n'. The .* matches the foo; then the . fails against the \n. But the next thing we want to do is match the \n against the \n; if we restored the string value, we would be back at the foo. Because this is used only in specific cases, we don't need to check all the things that `on_failure_jump' does, to make sure the right things get saved on the stack. Hence we don't share its code. The only reason to push anything on the stack at all is that otherwise we would have to change `anychar's code to do something besides goto fail in this case; that seems worse than this. */ case on_failure_keep_string_jump: DEBUG_PRINT1 ("EXECUTING on_failure_keep_string_jump"); EXTRACT_NUMBER_AND_INCR (mcnt, p); DEBUG_PRINT3 (" %d (to 0x%x):\n", mcnt, p + mcnt); PUSH_FAILURE_POINT (p + mcnt, NULL, -2); break; /* Uses of on_failure_jump: Each alternative starts with an on_failure_jump that points to the beginning of the next alternative. Each alternative except the last ends with a jump that in effect jumps past the rest of the alternatives. (They really jump to the ending jump of the following alternative, because tensioning these jumps is a hassle.) Repeats start with an on_failure_jump that points past both the repetition text and either the following jump or pop_failure_jump back to this on_failure_jump. */ case on_failure_jump: on_failure: DEBUG_PRINT1 ("EXECUTING on_failure_jump"); EXTRACT_NUMBER_AND_INCR (mcnt, p); DEBUG_PRINT3 (" %d (to 0x%x)", mcnt, p + mcnt); /* If this on_failure_jump comes right before a group (i.e., the original * applied to a group), save the information for that group and all inner ones, so that if we fail back to this point, the group's information will be correct. For example, in \(a*\)*\1, we need the preceding group, and in \(\(a*\)b*\)\2, we need the inner group. */ /* We can't use `p' to check ahead because we push a failure point to `p + mcnt' after we do this. */ p1 = p; /* We need to skip no_op's before we look for the start_memory in case this on_failure_jump is happening as the result of a completed succeed_n, as in \(a\)\{1,3\}b\1 against aba. */ while (p1 < pend && (re_opcode_t) *p1 == no_op) p1++; if (p1 < pend && (re_opcode_t) *p1 == start_memory) { /* We have a new highest active register now. This will get reset at the start_memory we are about to get to, but we will have saved all the registers relevant to this repetition op, as described above. */ highest_active_reg = *(p1 + 1) + *(p1 + 2); if (lowest_active_reg == NO_LOWEST_ACTIVE_REG) lowest_active_reg = *(p1 + 1); } DEBUG_PRINT1 (":\n"); PUSH_FAILURE_POINT (p + mcnt, d, -2); break; /* A smart repeat ends with `maybe_pop_jump'. We change it to either `pop_failure_jump' or `jump'. */ case maybe_pop_jump: EXTRACT_NUMBER_AND_INCR (mcnt, p); DEBUG_PRINT2 ("EXECUTING maybe_pop_jump %d.\n", mcnt); { register unsigned char *p2 = p; /* Compare the beginning of the repeat with what in the pattern follows its end. If we can establish that there is nothing that they would both match, i.e., that we would have to backtrack because of (as in, e.g., `a*a') then we can change to pop_failure_jump, because we'll never have to backtrack. This is not true in the case of alternatives: in `(a|ab)*' we do need to backtrack to the `ab' alternative (e.g., if the string was `ab'). But instead of trying to detect that here, the alternative has put on a dummy failure point which is what we will end up popping. */ /* Skip over open/close-group commands. If what follows this loop is a ...+ construct, look at what begins its body, since we will have to match at least one of that. */ while (1) { if (p2 + 2 < pend && ((re_opcode_t) *p2 == stop_memory || (re_opcode_t) *p2 == start_memory)) p2 += 3; else if (p2 + 6 < pend && (re_opcode_t) *p2 == dummy_failure_jump) p2 += 6; else break; } p1 = p + mcnt; /* p1[0] ... p1[2] are the `on_failure_jump' corresponding to the `maybe_finalize_jump' of this case. Examine what follows. */ /* If we're at the end of the pattern, we can change. */ if (p2 == pend) { /* Consider what happens when matching ":\(.*\)" against ":/". I don't really understand this code yet. */ p[-3] = (unsigned char) pop_failure_jump; DEBUG_PRINT1 (" End of pattern: change to `pop_failure_jump'.\n"); } else if ((re_opcode_t) *p2 == exactn || (bufp->newline_anchor && (re_opcode_t) *p2 == endline)) { register unsigned char c = *p2 == (unsigned char) endline ? '\n' : p2[2]; if ((re_opcode_t) p1[3] == exactn && p1[5] != c) { p[-3] = (unsigned char) pop_failure_jump; DEBUG_PRINT3 (" %c != %c => pop_failure_jump.\n", c, p1[5]); } else if ((re_opcode_t) p1[3] == charset || (re_opcode_t) p1[3] == charset_not) { int not = (re_opcode_t) p1[3] == charset_not; if (c < (unsigned char) (p1[4] * BYTEWIDTH) && p1[5 + c / BYTEWIDTH] & (1 << (c % BYTEWIDTH))) not = !not; /* `not' is equal to 1 if c would match, which means that we can't change to pop_failure_jump. */ if (!not) { p[-3] = (unsigned char) pop_failure_jump; DEBUG_PRINT1 (" No match => pop_failure_jump.\n"); } } } else if ((re_opcode_t) *p2 == charset) { #ifdef DEBUG register unsigned char c = *p2 == (unsigned char) endline ? '\n' : p2[2]; #endif if ((re_opcode_t) p1[3] == exactn && ! (p2[1] * BYTEWIDTH > p1[4] && (p2[1 + p1[4] / BYTEWIDTH] & (1 << (p1[4] % BYTEWIDTH))))) { p[-3] = (unsigned char) pop_failure_jump; DEBUG_PRINT3 (" %c != %c => pop_failure_jump.\n", c, p1[5]); } else if ((re_opcode_t) p1[3] == charset_not) { int idx; /* We win if the charset_not inside the loop lists every character listed in the charset after. */ for (idx = 0; idx < p2[1]; idx++) if (! (p2[2 + idx] == 0 || (idx < p1[4] && ((p2[2 + idx] & ~ p1[5 + idx]) == 0)))) break; if (idx == p2[1]) { p[-3] = (unsigned char) pop_failure_jump; DEBUG_PRINT1 (" No match => pop_failure_jump.\n"); } } else if ((re_opcode_t) p1[3] == charset) { int idx; /* We win if the charset inside the loop has no overlap with the one after the loop. */ for (idx = 0; idx < p2[1] && idx < p1[4]; idx++) if ((p2[2 + idx] & p1[5 + idx]) != 0) break; if (idx == p2[1] || idx == p1[4]) { p[-3] = (unsigned char) pop_failure_jump; DEBUG_PRINT1 (" No match => pop_failure_jump.\n"); } } } } p -= 2; /* Point at relative address again. */ if ((re_opcode_t) p[-1] != pop_failure_jump) { p[-1] = (unsigned char) jump; DEBUG_PRINT1 (" Match => jump.\n"); goto unconditional_jump; } /* Note fall through. */ /* The end of a simple repeat has a pop_failure_jump back to its matching on_failure_jump, where the latter will push a failure point. The pop_failure_jump takes off failure points put on by this pop_failure_jump's matching on_failure_jump; we got through the pattern to here from the matching on_failure_jump, so didn't fail. */ case pop_failure_jump: { /* We need to pass separate storage for the lowest and highest registers, even though we don't care about the actual values. Otherwise, we will restore only one register from the stack, since lowest will == highest in `pop_failure_point'. */ unsigned dummy_low_reg, dummy_high_reg; unsigned char *pdummy; const char *sdummy; DEBUG_PRINT1 ("EXECUTING pop_failure_jump.\n"); POP_FAILURE_POINT (sdummy, pdummy, dummy_low_reg, dummy_high_reg, reg_dummy, reg_dummy, reg_info_dummy); } /* Note fall through. */ /* Unconditionally jump (without popping any failure points). */ case jump: unconditional_jump: EXTRACT_NUMBER_AND_INCR (mcnt, p); /* Get the amount to jump. */ DEBUG_PRINT2 ("EXECUTING jump %d ", mcnt); p += mcnt; /* Do the jump. */ DEBUG_PRINT2 ("(to 0x%x).\n", p); break; /* We need this opcode so we can detect where alternatives end in `group_match_null_string_p' et al. */ case jump_past_alt: DEBUG_PRINT1 ("EXECUTING jump_past_alt.\n"); goto unconditional_jump; /* Normally, the on_failure_jump pushes a failure point, which then gets popped at pop_failure_jump. We will end up at pop_failure_jump, also, and with a pattern of, say, `a+', we are skipping over the on_failure_jump, so we have to push something meaningless for pop_failure_jump to pop. */ case dummy_failure_jump: DEBUG_PRINT1 ("EXECUTING dummy_failure_jump.\n"); /* It doesn't matter what we push for the string here. What the code at `fail' tests is the value for the pattern. */ PUSH_FAILURE_POINT (0, 0, -2); goto unconditional_jump; /* At the end of an alternative, we need to push a dummy failure point in case we are followed by a `pop_failure_jump', because we don't want the failure point for the alternative to be popped. For example, matching `(a|ab)*' against `aab' requires that we match the `ab' alternative. */ case push_dummy_failure: DEBUG_PRINT1 ("EXECUTING push_dummy_failure.\n"); /* See comments just above at `dummy_failure_jump' about the two zeroes. */ PUSH_FAILURE_POINT (0, 0, -2); break; /* Have to succeed matching what follows at least n times. After that, handle like `on_failure_jump'. */ case succeed_n: EXTRACT_NUMBER (mcnt, p + 2); DEBUG_PRINT2 ("EXECUTING succeed_n %d.\n", mcnt); assert (mcnt >= 0); /* Originally, this is how many times we HAVE to succeed. */ if (mcnt > 0) { mcnt--; p += 2; STORE_NUMBER_AND_INCR (p, mcnt); DEBUG_PRINT3 (" Setting 0x%x to %d.\n", p, mcnt); } else if (mcnt == 0) { DEBUG_PRINT2 (" Setting two bytes from 0x%x to no_op.\n", p+2); p[2] = (unsigned char) no_op; p[3] = (unsigned char) no_op; goto on_failure; } break; case jump_n: EXTRACT_NUMBER (mcnt, p + 2); DEBUG_PRINT2 ("EXECUTING jump_n %d.\n", mcnt); /* Originally, this is how many times we CAN jump. */ if (mcnt) { mcnt--; STORE_NUMBER (p + 2, mcnt); goto unconditional_jump; } /* If don't have to jump any more, skip over the rest of command. */ else p += 4; break; case set_number_at: { DEBUG_PRINT1 ("EXECUTING set_number_at.\n"); EXTRACT_NUMBER_AND_INCR (mcnt, p); p1 = p + mcnt; EXTRACT_NUMBER_AND_INCR (mcnt, p); DEBUG_PRINT3 (" Setting 0x%x to %d.\n", p1, mcnt); STORE_NUMBER (p1, mcnt); break; } case wordbound: DEBUG_PRINT1 ("EXECUTING wordbound.\n"); if (AT_WORD_BOUNDARY (d)) break; goto fail; case notwordbound: DEBUG_PRINT1 ("EXECUTING notwordbound.\n"); if (AT_WORD_BOUNDARY (d)) goto fail; break; case wordbeg: DEBUG_PRINT1 ("EXECUTING wordbeg.\n"); if (WORDCHAR_P (d) && (AT_STRINGS_BEG (d) || !WORDCHAR_P (d - 1))) break; goto fail; case wordend: DEBUG_PRINT1 ("EXECUTING wordend.\n"); if (!AT_STRINGS_BEG (d) && WORDCHAR_P (d - 1) && (!WORDCHAR_P (d) || AT_STRINGS_END (d))) break; goto fail; #ifdef emacs case before_dot: DEBUG_PRINT1 ("EXECUTING before_dot.\n"); if (PTR_CHAR_POS ((unsigned char *) d) >= point) goto fail; break; case at_dot: DEBUG_PRINT1 ("EXECUTING at_dot.\n"); if (PTR_CHAR_POS ((unsigned char *) d) != point) goto fail; break; case after_dot: DEBUG_PRINT1 ("EXECUTING after_dot.\n"); if (PTR_CHAR_POS ((unsigned char *) d) <= point) goto fail; break; #if 0 /* not emacs19 */ case at_dot: DEBUG_PRINT1 ("EXECUTING at_dot.\n"); if (PTR_CHAR_POS ((unsigned char *) d) + 1 != point) goto fail; break; #endif /* not emacs19 */ case syntaxspec: DEBUG_PRINT2 ("EXECUTING syntaxspec %d.\n", mcnt); mcnt = *p++; goto matchsyntax; case wordchar: DEBUG_PRINT1 ("EXECUTING Emacs wordchar.\n"); mcnt = (int) Sword; matchsyntax: PREFETCH (); /* Can't use *d++ here; SYNTAX may be an unsafe macro. */ d++; if (SYNTAX (d[-1]) != (enum syntaxcode) mcnt) goto fail; SET_REGS_MATCHED (); break; case notsyntaxspec: DEBUG_PRINT2 ("EXECUTING notsyntaxspec %d.\n", mcnt); mcnt = *p++; goto matchnotsyntax; case notwordchar: DEBUG_PRINT1 ("EXECUTING Emacs notwordchar.\n"); mcnt = (int) Sword; matchnotsyntax: PREFETCH (); /* Can't use *d++ here; SYNTAX may be an unsafe macro. */ d++; if (SYNTAX (d[-1]) == (enum syntaxcode) mcnt) goto fail; SET_REGS_MATCHED (); break; #else /* not emacs */ case wordchar: DEBUG_PRINT1 ("EXECUTING non-Emacs wordchar.\n"); PREFETCH (); if (!WORDCHAR_P (d)) goto fail; SET_REGS_MATCHED (); d++; break; case notwordchar: DEBUG_PRINT1 ("EXECUTING non-Emacs notwordchar.\n"); PREFETCH (); if (WORDCHAR_P (d)) goto fail; SET_REGS_MATCHED (); d++; break; #endif /* not emacs */ default: abort (); } continue; /* Successfully executed one pattern command; keep going. */ /* We goto here if a matching operation fails. */ fail: if (!FAIL_STACK_EMPTY ()) { /* A restart point is known. Restore to that state. */ DEBUG_PRINT1 ("\nFAIL:\n"); POP_FAILURE_POINT (d, p, lowest_active_reg, highest_active_reg, regstart, regend, reg_info); /* If this failure point is a dummy, try the next one. */ if (!p) goto fail; /* If we failed to the end of the pattern, don't examine *p. */ assert (p <= pend); if (p < pend) { boolean is_a_jump_n = false; /* If failed to a backwards jump that's part of a repetition loop, need to pop this failure point and use the next one. */ switch ((re_opcode_t) *p) { case jump_n: is_a_jump_n = true; case maybe_pop_jump: case pop_failure_jump: case jump: p1 = p + 1; EXTRACT_NUMBER_AND_INCR (mcnt, p1); p1 += mcnt; if ((is_a_jump_n && (re_opcode_t) *p1 == succeed_n) || (!is_a_jump_n && (re_opcode_t) *p1 == on_failure_jump)) goto fail; break; default: /* do nothing */ ; } } if (d >= string1 && d <= end1) dend = end_match_1; } else break; /* Matching at this starting point really fails. */ } /* for (;;) */ if (best_regs_set) goto restore_best_regs; FREE_VARIABLES (); return -1; /* Failure to match. */ } /* re_match_2 */ /* Subroutine definitions for re_match_2. */ /* We are passed P pointing to a register number after a start_memory. Return true if the pattern up to the corresponding stop_memory can match the empty string, and false otherwise. If we find the matching stop_memory, sets P to point to one past its number. Otherwise, sets P to an undefined byte less than or equal to END. We don't handle duplicates properly (yet). */ static boolean group_match_null_string_p (p, end, reg_info) unsigned char **p, *end; register_info_type *reg_info; { int mcnt; /* Point to after the args to the start_memory. */ unsigned char *p1 = *p + 2; while (p1 < end) { /* Skip over opcodes that can match nothing, and return true or false, as appropriate, when we get to one that can't, or to the matching stop_memory. */ switch ((re_opcode_t) *p1) { /* Could be either a loop or a series of alternatives. */ case on_failure_jump: p1++; EXTRACT_NUMBER_AND_INCR (mcnt, p1); /* If the next operation is not a jump backwards in the pattern. */ if (mcnt >= 0) { /* Go through the on_failure_jumps of the alternatives, seeing if any of the alternatives cannot match nothing. The last alternative starts with only a jump, whereas the rest start with on_failure_jump and end with a jump, e.g., here is the pattern for `a|b|c': /on_failure_jump/0/6/exactn/1/a/jump_past_alt/0/6 /on_failure_jump/0/6/exactn/1/b/jump_past_alt/0/3 /exactn/1/c So, we have to first go through the first (n-1) alternatives and then deal with the last one separately. */ /* Deal with the first (n-1) alternatives, which start with an on_failure_jump (see above) that jumps to right past a jump_past_alt. */ while ((re_opcode_t) p1[mcnt-3] == jump_past_alt) { /* `mcnt' holds how many bytes long the alternative is, including the ending `jump_past_alt' and its number. */ if (!alt_match_null_string_p (p1, p1 + mcnt - 3, reg_info)) return false; /* Move to right after this alternative, including the jump_past_alt. */ p1 += mcnt; /* Break if it's the beginning of an n-th alternative that doesn't begin with an on_failure_jump. */ if ((re_opcode_t) *p1 != on_failure_jump) break; /* Still have to check that it's not an n-th alternative that starts with an on_failure_jump. */ p1++; EXTRACT_NUMBER_AND_INCR (mcnt, p1); if ((re_opcode_t) p1[mcnt-3] != jump_past_alt) { /* Get to the beginning of the n-th alternative. */ p1 -= 3; break; } } /* Deal with the last alternative: go back and get number of the `jump_past_alt' just before it. `mcnt' contains the length of the alternative. */ EXTRACT_NUMBER (mcnt, p1 - 2); if (!alt_match_null_string_p (p1, p1 + mcnt, reg_info)) return false; p1 += mcnt; /* Get past the n-th alternative. */ } /* if mcnt > 0 */ break; case stop_memory: assert (p1[1] == **p); *p = p1 + 2; return true; default: if (!common_op_match_null_string_p (&p1, end, reg_info)) return false; } } /* while p1 < end */ return false; } /* group_match_null_string_p */ /* Similar to group_match_null_string_p, but doesn't deal with alternatives: It expects P to be the first byte of a single alternative and END one byte past the last. The alternative can contain groups. */ static boolean alt_match_null_string_p (p, end, reg_info) unsigned char *p, *end; register_info_type *reg_info; { int mcnt; unsigned char *p1 = p; while (p1 < end) { /* Skip over opcodes that can match nothing, and break when we get to one that can't. */ switch ((re_opcode_t) *p1) { /* It's a loop. */ case on_failure_jump: p1++; EXTRACT_NUMBER_AND_INCR (mcnt, p1); p1 += mcnt; break; default: if (!common_op_match_null_string_p (&p1, end, reg_info)) return false; } } /* while p1 < end */ return true; } /* alt_match_null_string_p */ /* Deals with the ops common to group_match_null_string_p and alt_match_null_string_p. Sets P to one after the op and its arguments, if any. */ static boolean common_op_match_null_string_p (p, end, reg_info) unsigned char **p, *end; register_info_type *reg_info; { int mcnt; boolean ret; int reg_no; unsigned char *p1 = *p; switch ((re_opcode_t) *p1++) { case no_op: case begline: case endline: case begbuf: case endbuf: case wordbeg: case wordend: case wordbound: case notwordbound: #ifdef emacs case before_dot: case at_dot: case after_dot: #endif break; case start_memory: reg_no = *p1; assert (reg_no > 0 && reg_no <= MAX_REGNUM); ret = group_match_null_string_p (&p1, end, reg_info); /* Have to set this here in case we're checking a group which contains a group and a back reference to it. */ if (REG_MATCH_NULL_STRING_P (reg_info[reg_no]) == MATCH_NULL_UNSET_VALUE) REG_MATCH_NULL_STRING_P (reg_info[reg_no]) = ret; if (!ret) return false; break; /* If this is an optimized succeed_n for zero times, make the jump. */ case jump: EXTRACT_NUMBER_AND_INCR (mcnt, p1); if (mcnt >= 0) p1 += mcnt; else return false; break; case succeed_n: /* Get to the number of times to succeed. */ p1 += 2; EXTRACT_NUMBER_AND_INCR (mcnt, p1); if (mcnt == 0) { p1 -= 4; EXTRACT_NUMBER_AND_INCR (mcnt, p1); p1 += mcnt; } else return false; break; case duplicate: if (!REG_MATCH_NULL_STRING_P (reg_info[*p1])) return false; break; case set_number_at: p1 += 4; default: /* All other opcodes mean we cannot match the empty string. */ return false; } *p = p1; return true; } /* common_op_match_null_string_p */ /* Return zero if TRANSLATE[S1] and TRANSLATE[S2] are identical for LEN bytes; nonzero otherwise. */ static int bcmp_translate (s1, s2, len, translate) unsigned char *s1, *s2; register int len; char *translate; { register unsigned char *p1 = s1, *p2 = s2; while (len) { if (translate[*p1++] != translate[*p2++]) return 1; len--; } return 0; } /* Entry points for GNU code. */ /* re_compile_pattern is the GNU regular expression compiler: it compiles PATTERN (of length SIZE) and puts the result in BUFP. Returns 0 if the pattern was valid, otherwise an error string. Assumes the `allocated' (and perhaps `buffer') and `translate' fields are set in BUFP on entry. We call regex_compile to do the actual compilation. */ const char * re_compile_pattern (pattern, length, bufp) const char *pattern; int length; struct re_pattern_buffer *bufp; { reg_errcode_t ret; /* GNU code is written to assume at least RE_NREGS registers will be set (and at least one extra will be -1). */ bufp->regs_allocated = REGS_UNALLOCATED; /* And GNU code determines whether or not to get register information by passing null for the REGS argument to re_match, etc., not by setting no_sub. */ bufp->no_sub = 0; /* Match anchors at newline. */ bufp->newline_anchor = 1; ret = regex_compile (pattern, length, re_syntax_options, bufp); return re_error_msg[(int) ret]; } /* Entry points compatible with 4.2 BSD regex library. We don't define them if this is an Emacs or POSIX compilation. */ #if !defined (emacs) && !defined (_POSIX_SOURCE) /* BSD has one and only one pattern buffer. */ static struct re_pattern_buffer re_comp_buf; char * re_comp (s) const char *s; { reg_errcode_t ret; if (!s) { if (!re_comp_buf.buffer) return "No previous regular expression"; return 0; } if (!re_comp_buf.buffer) { re_comp_buf.buffer = (unsigned char *) malloc (200); if (re_comp_buf.buffer == NULL) return "Memory exhausted"; re_comp_buf.allocated = 200; re_comp_buf.fastmap = (char *) malloc (1 << BYTEWIDTH); if (re_comp_buf.fastmap == NULL) return "Memory exhausted"; } /* Since `re_exec' always passes NULL for the `regs' argument, we don't need to initialize the pattern buffer fields which affect it. */ /* Match anchors at newlines. */ re_comp_buf.newline_anchor = 1; ret = regex_compile (s, strlen (s), re_syntax_options, &re_comp_buf); /* Yes, we're discarding `const' here. */ return (char *) re_error_msg[(int) ret]; } int re_exec (s) const char *s; { const int len = strlen (s); return 0 <= re_search (&re_comp_buf, s, len, 0, len, (struct re_registers *) 0); } #endif /* not emacs and not _POSIX_SOURCE */ /* POSIX.2 functions. Don't define these for Emacs. */ #ifndef emacs /* regcomp takes a regular expression as a string and compiles it. PREG is a regex_t *. We do not expect any fields to be initialized, since POSIX says we shouldn't. Thus, we set `buffer' to the compiled pattern; `used' to the length of the compiled pattern; `syntax' to RE_SYNTAX_POSIX_EXTENDED if the REG_EXTENDED bit in CFLAGS is set; otherwise, to RE_SYNTAX_POSIX_BASIC; `newline_anchor' to REG_NEWLINE being set in CFLAGS; `fastmap' and `fastmap_accurate' to zero; `re_nsub' to the number of subexpressions in PATTERN. PATTERN is the address of the pattern string. CFLAGS is a series of bits which affect compilation. If REG_EXTENDED is set, we use POSIX extended syntax; otherwise, we use POSIX basic syntax. If REG_NEWLINE is set, then . and [^...] don't match newline. Also, regexec will try a match beginning after every newline. If REG_ICASE is set, then we considers upper- and lowercase versions of letters to be equivalent when matching. If REG_NOSUB is set, then when PREG is passed to regexec, that routine will report only success or failure, and nothing about the registers. It returns 0 if it succeeds, nonzero if it doesn't. (See regex.h for the return codes and their meanings.) */ int regcomp (preg, pattern, cflags) regex_t *preg; const char *pattern; int cflags; { reg_errcode_t ret; unsigned syntax = (cflags & REG_EXTENDED) ? RE_SYNTAX_POSIX_EXTENDED : RE_SYNTAX_POSIX_BASIC; /* regex_compile will allocate the space for the compiled pattern. */ preg->buffer = 0; preg->allocated = 0; preg->used = 0; /* Don't bother to use a fastmap when searching. This simplifies the REG_NEWLINE case: if we used a fastmap, we'd have to put all the characters after newlines into the fastmap. This way, we just try every character. */ preg->fastmap = 0; if (cflags & REG_ICASE) { unsigned i; preg->translate = (char *) malloc (CHAR_SET_SIZE); if (preg->translate == NULL) return (int) REG_ESPACE; /* Map uppercase characters to corresponding lowercase ones. */ for (i = 0; i < CHAR_SET_SIZE; i++) preg->translate[i] = ISUPPER (i) ? tolower (i) : i; } else preg->translate = NULL; /* If REG_NEWLINE is set, newlines are treated differently. */ if (cflags & REG_NEWLINE) { /* REG_NEWLINE implies neither . nor [^...] match newline. */ syntax &= ~RE_DOT_NEWLINE; syntax |= RE_HAT_LISTS_NOT_NEWLINE; /* It also changes the matching behavior. */ preg->newline_anchor = 1; } else preg->newline_anchor = 0; preg->no_sub = !!(cflags & REG_NOSUB); /* POSIX says a null character in the pattern terminates it, so we can use strlen here in compiling the pattern. */ ret = regex_compile (pattern, strlen (pattern), syntax, preg); /* POSIX doesn't distinguish between an unmatched open-group and an unmatched close-group: both are REG_EPAREN. */ if (ret == REG_ERPAREN) ret = REG_EPAREN; return (int) ret; } /* regexec searches for a given pattern, specified by PREG, in the string STRING. If NMATCH is zero or REG_NOSUB was set in the cflags argument to `regcomp', we ignore PMATCH. Otherwise, we assume PMATCH has at least NMATCH elements, and we set them to the offsets of the corresponding matched substrings. EFLAGS specifies `execution flags' which affect matching: if REG_NOTBOL is set, then ^ does not match at the beginning of the string; if REG_NOTEOL is set, then $ does not match at the end. We return 0 if we find a match and REG_NOMATCH if not. */ int regexec (preg, string, nmatch, pmatch, eflags) const regex_t *preg; const char *string; size_t nmatch; regmatch_t pmatch[]; int eflags; { int ret; struct re_registers regs; regex_t private_preg; int len = strlen (string); boolean want_reg_info = !preg->no_sub && nmatch > 0; private_preg = *preg; private_preg.not_bol = !!(eflags & REG_NOTBOL); private_preg.not_eol = !!(eflags & REG_NOTEOL); /* The user has told us exactly how many registers to return information about, via `nmatch'. We have to pass that on to the matching routines. */ private_preg.regs_allocated = REGS_FIXED; if (want_reg_info) { regs.num_regs = nmatch; regs.start = TALLOC (nmatch, regoff_t); regs.end = TALLOC (nmatch, regoff_t); if (regs.start == NULL || regs.end == NULL) return (int) REG_NOMATCH; } /* Perform the searching operation. */ ret = re_search (&private_preg, string, len, /* start: */ 0, /* range: */ len, want_reg_info ? ®s : (struct re_registers *) 0); /* Copy the register information to the POSIX structure. */ if (want_reg_info) { if (ret >= 0) { unsigned r; for (r = 0; r < nmatch; r++) { pmatch[r].rm_so = regs.start[r]; pmatch[r].rm_eo = regs.end[r]; } } /* If we needed the temporary register info, free the space now. */ free (regs.start); free (regs.end); } /* We want zero return to mean success, unlike `re_search'. */ return ret >= 0 ? (int) REG_NOERROR : (int) REG_NOMATCH; } /* Returns a message corresponding to an error code, ERRCODE, returned from either regcomp or regexec. We don't use PREG here. */ size_t regerror (errcode, preg, errbuf, errbuf_size) int errcode; const regex_t *preg; char *errbuf; size_t errbuf_size; { const char *msg; size_t msg_size; if (errcode < 0 || errcode >= (sizeof (re_error_msg) / sizeof (re_error_msg[0]))) /* Only error codes returned by the rest of the code should be passed to this routine. If we are given anything else, or if other regex code generates an invalid error code, then the program has a bug. Dump core so we can fix it. */ abort (); msg = re_error_msg[errcode]; /* POSIX doesn't require that we do anything in this case, but why not be nice. */ if (! msg) msg = "Success"; msg_size = strlen (msg) + 1; /* Includes the null. */ if (errbuf_size != 0) { if (msg_size > errbuf_size) { strncpy (errbuf, msg, errbuf_size - 1); errbuf[errbuf_size - 1] = 0; } else strcpy (errbuf, msg); } return msg_size; } /* Free dynamically allocated space used by PREG. */ void regfree (preg) regex_t *preg; { if (preg->buffer != NULL) free (preg->buffer); preg->buffer = NULL; preg->allocated = 0; preg->used = 0; if (preg->fastmap != NULL) free (preg->fastmap); preg->fastmap = NULL; preg->fastmap_accurate = 0; if (preg->translate != NULL) free (preg->translate); preg->translate = NULL; } #endif /* not emacs */ /* Local variables: make-backup-files: t version-control: t trim-versions-without-asking: nil End: */ sh-utils-1.10/lib/getdate.y100444 21570 1 56205 5563566343 14073 0ustar djmdaemon%{ /* ** Originally written by Steven M. Bellovin while ** at the University of North Carolina at Chapel Hill. Later tweaked by ** a couple of people on Usenet. Completely overhauled by Rich $alz ** and Jim Berets in August, 1990; ** send any email to Rich. ** ** This grammar has 10 shift/reduce conflicts. ** ** This code is in the public domain and has no copyright. */ /* SUPPRESS 287 on yaccpar_sccsid *//* Unused static variable */ /* SUPPRESS 288 on yyerrlab *//* Label unused */ #ifdef HAVE_CONFIG_H #if defined (emacs) || defined (CONFIG_BROKETS) #include #else #include "config.h" #endif #endif /* Since the code of getdate.y is not included in the Emacs executable itself, there is no need to #define static in this file. Even if the code were included in the Emacs executable, it probably wouldn't do any harm to #undef it here; this will only cause problems if we try to write to a static variable, which I don't think this code needs to do. */ #ifdef emacs #undef static #endif #include #include /* The code at the top of get_date which figures out the offset of the current time zone checks various CPP symbols to see if special tricks are need, but defaults to using the gettimeofday system call. Include if that will be used. */ #if defined(vms) #include #include #else #include #ifdef TIME_WITH_SYS_TIME #include #include #else #ifdef HAVE_SYS_TIME_H #include #else #include #endif #endif #ifdef timezone #undef timezone /* needed for sgi */ #endif #if defined(HAVE_SYS_TIMEB_H) #include #else /* ** We use the obsolete `struct timeb' as part of our interface! ** Since the system doesn't have it, we define it here; ** our callers must do likewise. */ struct timeb { time_t time; /* Seconds since the epoch */ unsigned short millitm; /* Field not used */ short timezone; /* Minutes west of GMT */ short dstflag; /* Field not used */ }; #endif /* defined(HAVE_SYS_TIMEB_H) */ #endif /* defined(vms) */ #if defined (STDC_HEADERS) || defined (USG) #include #endif /* Some old versions of bison generate parsers that use bcopy. That loses on systems that don't provide the function, so we have to redefine it here. */ #if !defined (HAVE_BCOPY) && defined (HAVE_MEMCPY) && !defined (bcopy) #define bcopy(from, to, len) memcpy ((to), (from), (len)) #endif extern struct tm *gmtime(); extern struct tm *localtime(); #define yyparse getdate_yyparse #define yylex getdate_yylex #define yyerror getdate_yyerror static int yylex (); static int yyerror (); #define EPOCH 1970 #define HOUR(x) ((time_t)(x) * 60) #define SECSPERDAY (24L * 60L * 60L) /* ** An entry in the lexical lookup table. */ typedef struct _TABLE { char *name; int type; time_t value; } TABLE; /* ** Daylight-savings mode: on, off, or not yet known. */ typedef enum _DSTMODE { DSTon, DSToff, DSTmaybe } DSTMODE; /* ** Meridian: am, pm, or 24-hour style. */ typedef enum _MERIDIAN { MERam, MERpm, MER24 } MERIDIAN; /* ** Global variables. We could get rid of most of these by using a good ** union as the yacc stack. (This routine was originally written before ** yacc had the %union construct.) Maybe someday; right now we only use ** the %union very rarely. */ static char *yyInput; static DSTMODE yyDSTmode; static time_t yyDayOrdinal; static time_t yyDayNumber; static int yyHaveDate; static int yyHaveDay; static int yyHaveRel; static int yyHaveTime; static int yyHaveZone; static time_t yyTimezone; static time_t yyDay; static time_t yyHour; static time_t yyMinutes; static time_t yyMonth; static time_t yySeconds; static time_t yyYear; static MERIDIAN yyMeridian; static time_t yyRelMonth; static time_t yyRelSeconds; %} %union { time_t Number; enum _MERIDIAN Meridian; } %token tAGO tDAY tDAYZONE tID tMERIDIAN tMINUTE_UNIT tMONTH tMONTH_UNIT %token tSEC_UNIT tSNUMBER tUNUMBER tZONE tDST %type tDAY tDAYZONE tMINUTE_UNIT tMONTH tMONTH_UNIT %type tSEC_UNIT tSNUMBER tUNUMBER tZONE %type tMERIDIAN o_merid %% spec : /* NULL */ | spec item ; item : time { yyHaveTime++; } | zone { yyHaveZone++; } | date { yyHaveDate++; } | day { yyHaveDay++; } | rel { yyHaveRel++; } | number ; time : tUNUMBER tMERIDIAN { yyHour = $1; yyMinutes = 0; yySeconds = 0; yyMeridian = $2; } | tUNUMBER ':' tUNUMBER o_merid { yyHour = $1; yyMinutes = $3; yySeconds = 0; yyMeridian = $4; } | tUNUMBER ':' tUNUMBER tSNUMBER { yyHour = $1; yyMinutes = $3; yyMeridian = MER24; yyDSTmode = DSToff; yyTimezone = - ($4 % 100 + ($4 / 100) * 60); } | tUNUMBER ':' tUNUMBER ':' tUNUMBER o_merid { yyHour = $1; yyMinutes = $3; yySeconds = $5; yyMeridian = $6; } | tUNUMBER ':' tUNUMBER ':' tUNUMBER tSNUMBER { yyHour = $1; yyMinutes = $3; yySeconds = $5; yyMeridian = MER24; yyDSTmode = DSToff; yyTimezone = - ($6 % 100 + ($6 / 100) * 60); } ; zone : tZONE { yyTimezone = $1; yyDSTmode = DSToff; } | tDAYZONE { yyTimezone = $1; yyDSTmode = DSTon; } | tZONE tDST { yyTimezone = $1; yyDSTmode = DSTon; } ; day : tDAY { yyDayOrdinal = 1; yyDayNumber = $1; } | tDAY ',' { yyDayOrdinal = 1; yyDayNumber = $1; } | tUNUMBER tDAY { yyDayOrdinal = $1; yyDayNumber = $2; } ; date : tUNUMBER '/' tUNUMBER { yyMonth = $1; yyDay = $3; } | tUNUMBER '/' tUNUMBER '/' tUNUMBER { yyMonth = $1; yyDay = $3; yyYear = $5; } | tUNUMBER tSNUMBER tSNUMBER { /* ISO 8601 format. yyyy-mm-dd. */ yyYear = $1; yyMonth = -$2; yyDay = -$3; } | tUNUMBER tMONTH tSNUMBER { /* e.g. 17-JUN-1992. */ yyDay = $1; yyMonth = $2; yyYear = -$3; } | tMONTH tUNUMBER { yyMonth = $1; yyDay = $2; } | tMONTH tUNUMBER ',' tUNUMBER { yyMonth = $1; yyDay = $2; yyYear = $4; } | tUNUMBER tMONTH { yyMonth = $2; yyDay = $1; } | tUNUMBER tMONTH tUNUMBER { yyMonth = $2; yyDay = $1; yyYear = $3; } ; rel : relunit tAGO { yyRelSeconds = -yyRelSeconds; yyRelMonth = -yyRelMonth; } | relunit ; relunit : tUNUMBER tMINUTE_UNIT { yyRelSeconds += $1 * $2 * 60L; } | tSNUMBER tMINUTE_UNIT { yyRelSeconds += $1 * $2 * 60L; } | tMINUTE_UNIT { yyRelSeconds += $1 * 60L; } | tSNUMBER tSEC_UNIT { yyRelSeconds += $1; } | tUNUMBER tSEC_UNIT { yyRelSeconds += $1; } | tSEC_UNIT { yyRelSeconds++; } | tSNUMBER tMONTH_UNIT { yyRelMonth += $1 * $2; } | tUNUMBER tMONTH_UNIT { yyRelMonth += $1 * $2; } | tMONTH_UNIT { yyRelMonth += $1; } ; number : tUNUMBER { if (yyHaveTime && yyHaveDate && !yyHaveRel) yyYear = $1; else { if($1>10000) { yyHaveDate++; yyDay= ($1)%100; yyMonth= ($1/100)%100; yyYear = $1/10000; } else { yyHaveTime++; if ($1 < 100) { yyHour = $1; yyMinutes = 0; } else { yyHour = $1 / 100; yyMinutes = $1 % 100; } yySeconds = 0; yyMeridian = MER24; } } } ; o_merid : /* NULL */ { $$ = MER24; } | tMERIDIAN { $$ = $1; } ; %% /* Month and day table. */ static TABLE const MonthDayTable[] = { { "january", tMONTH, 1 }, { "february", tMONTH, 2 }, { "march", tMONTH, 3 }, { "april", tMONTH, 4 }, { "may", tMONTH, 5 }, { "june", tMONTH, 6 }, { "july", tMONTH, 7 }, { "august", tMONTH, 8 }, { "september", tMONTH, 9 }, { "sept", tMONTH, 9 }, { "october", tMONTH, 10 }, { "november", tMONTH, 11 }, { "december", tMONTH, 12 }, { "sunday", tDAY, 0 }, { "monday", tDAY, 1 }, { "tuesday", tDAY, 2 }, { "tues", tDAY, 2 }, { "wednesday", tDAY, 3 }, { "wednes", tDAY, 3 }, { "thursday", tDAY, 4 }, { "thur", tDAY, 4 }, { "thurs", tDAY, 4 }, { "friday", tDAY, 5 }, { "saturday", tDAY, 6 }, { NULL } }; /* Time units table. */ static TABLE const UnitsTable[] = { { "year", tMONTH_UNIT, 12 }, { "month", tMONTH_UNIT, 1 }, { "fortnight", tMINUTE_UNIT, 14 * 24 * 60 }, { "week", tMINUTE_UNIT, 7 * 24 * 60 }, { "day", tMINUTE_UNIT, 1 * 24 * 60 }, { "hour", tMINUTE_UNIT, 60 }, { "minute", tMINUTE_UNIT, 1 }, { "min", tMINUTE_UNIT, 1 }, { "second", tSEC_UNIT, 1 }, { "sec", tSEC_UNIT, 1 }, { NULL } }; /* Assorted relative-time words. */ static TABLE const OtherTable[] = { { "tomorrow", tMINUTE_UNIT, 1 * 24 * 60 }, { "yesterday", tMINUTE_UNIT, -1 * 24 * 60 }, { "today", tMINUTE_UNIT, 0 }, { "now", tMINUTE_UNIT, 0 }, { "last", tUNUMBER, -1 }, { "this", tMINUTE_UNIT, 0 }, { "next", tUNUMBER, 2 }, { "first", tUNUMBER, 1 }, /* { "second", tUNUMBER, 2 }, */ { "third", tUNUMBER, 3 }, { "fourth", tUNUMBER, 4 }, { "fifth", tUNUMBER, 5 }, { "sixth", tUNUMBER, 6 }, { "seventh", tUNUMBER, 7 }, { "eighth", tUNUMBER, 8 }, { "ninth", tUNUMBER, 9 }, { "tenth", tUNUMBER, 10 }, { "eleventh", tUNUMBER, 11 }, { "twelfth", tUNUMBER, 12 }, { "ago", tAGO, 1 }, { NULL } }; /* The timezone table. */ /* Some of these are commented out because a time_t can't store a float. */ static TABLE const TimezoneTable[] = { { "gmt", tZONE, HOUR( 0) }, /* Greenwich Mean */ { "ut", tZONE, HOUR( 0) }, /* Universal (Coordinated) */ { "utc", tZONE, HOUR( 0) }, { "wet", tZONE, HOUR( 0) }, /* Western European */ { "bst", tDAYZONE, HOUR( 0) }, /* British Summer */ { "wat", tZONE, HOUR( 1) }, /* West Africa */ { "at", tZONE, HOUR( 2) }, /* Azores */ #if 0 /* For completeness. BST is also British Summer, and GST is * also Guam Standard. */ { "bst", tZONE, HOUR( 3) }, /* Brazil Standard */ { "gst", tZONE, HOUR( 3) }, /* Greenland Standard */ #endif #if 0 { "nft", tZONE, HOUR(3.5) }, /* Newfoundland */ { "nst", tZONE, HOUR(3.5) }, /* Newfoundland Standard */ { "ndt", tDAYZONE, HOUR(3.5) }, /* Newfoundland Daylight */ #endif { "ast", tZONE, HOUR( 4) }, /* Atlantic Standard */ { "adt", tDAYZONE, HOUR( 4) }, /* Atlantic Daylight */ { "est", tZONE, HOUR( 5) }, /* Eastern Standard */ { "edt", tDAYZONE, HOUR( 5) }, /* Eastern Daylight */ { "cst", tZONE, HOUR( 6) }, /* Central Standard */ { "cdt", tDAYZONE, HOUR( 6) }, /* Central Daylight */ { "mst", tZONE, HOUR( 7) }, /* Mountain Standard */ { "mdt", tDAYZONE, HOUR( 7) }, /* Mountain Daylight */ { "pst", tZONE, HOUR( 8) }, /* Pacific Standard */ { "pdt", tDAYZONE, HOUR( 8) }, /* Pacific Daylight */ { "yst", tZONE, HOUR( 9) }, /* Yukon Standard */ { "ydt", tDAYZONE, HOUR( 9) }, /* Yukon Daylight */ { "hst", tZONE, HOUR(10) }, /* Hawaii Standard */ { "hdt", tDAYZONE, HOUR(10) }, /* Hawaii Daylight */ { "cat", tZONE, HOUR(10) }, /* Central Alaska */ { "ahst", tZONE, HOUR(10) }, /* Alaska-Hawaii Standard */ { "nt", tZONE, HOUR(11) }, /* Nome */ { "idlw", tZONE, HOUR(12) }, /* International Date Line West */ { "cet", tZONE, -HOUR(1) }, /* Central European */ { "met", tZONE, -HOUR(1) }, /* Middle European */ { "mewt", tZONE, -HOUR(1) }, /* Middle European Winter */ { "mest", tDAYZONE, -HOUR(1) }, /* Middle European Summer */ { "swt", tZONE, -HOUR(1) }, /* Swedish Winter */ { "sst", tDAYZONE, -HOUR(1) }, /* Swedish Summer */ { "fwt", tZONE, -HOUR(1) }, /* French Winter */ { "fst", tDAYZONE, -HOUR(1) }, /* French Summer */ { "eet", tZONE, -HOUR(2) }, /* Eastern Europe, USSR Zone 1 */ { "bt", tZONE, -HOUR(3) }, /* Baghdad, USSR Zone 2 */ #if 0 { "it", tZONE, -HOUR(3.5) },/* Iran */ #endif { "zp4", tZONE, -HOUR(4) }, /* USSR Zone 3 */ { "zp5", tZONE, -HOUR(5) }, /* USSR Zone 4 */ #if 0 { "ist", tZONE, -HOUR(5.5) },/* Indian Standard */ #endif { "zp6", tZONE, -HOUR(6) }, /* USSR Zone 5 */ #if 0 /* For completeness. NST is also Newfoundland Stanard, and SST is * also Swedish Summer. */ { "nst", tZONE, -HOUR(6.5) },/* North Sumatra */ { "sst", tZONE, -HOUR(7) }, /* South Sumatra, USSR Zone 6 */ #endif /* 0 */ { "wast", tZONE, -HOUR(7) }, /* West Australian Standard */ { "wadt", tDAYZONE, -HOUR(7) }, /* West Australian Daylight */ #if 0 { "jt", tZONE, -HOUR(7.5) },/* Java (3pm in Cronusland!) */ #endif { "cct", tZONE, -HOUR(8) }, /* China Coast, USSR Zone 7 */ { "jst", tZONE, -HOUR(9) }, /* Japan Standard, USSR Zone 8 */ #if 0 { "cast", tZONE, -HOUR(9.5) },/* Central Australian Standard */ { "cadt", tDAYZONE, -HOUR(9.5) },/* Central Australian Daylight */ #endif { "east", tZONE, -HOUR(10) }, /* Eastern Australian Standard */ { "eadt", tDAYZONE, -HOUR(10) }, /* Eastern Australian Daylight */ { "gst", tZONE, -HOUR(10) }, /* Guam Standard, USSR Zone 9 */ { "nzt", tZONE, -HOUR(12) }, /* New Zealand */ { "nzst", tZONE, -HOUR(12) }, /* New Zealand Standard */ { "nzdt", tDAYZONE, -HOUR(12) }, /* New Zealand Daylight */ { "idle", tZONE, -HOUR(12) }, /* International Date Line East */ { NULL } }; /* Military timezone table. */ static TABLE const MilitaryTable[] = { { "a", tZONE, HOUR( 1) }, { "b", tZONE, HOUR( 2) }, { "c", tZONE, HOUR( 3) }, { "d", tZONE, HOUR( 4) }, { "e", tZONE, HOUR( 5) }, { "f", tZONE, HOUR( 6) }, { "g", tZONE, HOUR( 7) }, { "h", tZONE, HOUR( 8) }, { "i", tZONE, HOUR( 9) }, { "k", tZONE, HOUR( 10) }, { "l", tZONE, HOUR( 11) }, { "m", tZONE, HOUR( 12) }, { "n", tZONE, HOUR(- 1) }, { "o", tZONE, HOUR(- 2) }, { "p", tZONE, HOUR(- 3) }, { "q", tZONE, HOUR(- 4) }, { "r", tZONE, HOUR(- 5) }, { "s", tZONE, HOUR(- 6) }, { "t", tZONE, HOUR(- 7) }, { "u", tZONE, HOUR(- 8) }, { "v", tZONE, HOUR(- 9) }, { "w", tZONE, HOUR(-10) }, { "x", tZONE, HOUR(-11) }, { "y", tZONE, HOUR(-12) }, { "z", tZONE, HOUR( 0) }, { NULL } }; /* ARGSUSED */ static int yyerror(s) char *s; { return 0; } static time_t ToSeconds(Hours, Minutes, Seconds, Meridian) time_t Hours; time_t Minutes; time_t Seconds; MERIDIAN Meridian; { if (Minutes < 0 || Minutes > 59 || Seconds < 0 || Seconds > 59) return -1; switch (Meridian) { case MER24: if (Hours < 0 || Hours > 23) return -1; return (Hours * 60L + Minutes) * 60L + Seconds; case MERam: if (Hours < 1 || Hours > 12) return -1; return (Hours * 60L + Minutes) * 60L + Seconds; case MERpm: if (Hours < 1 || Hours > 12) return -1; return ((Hours + 12) * 60L + Minutes) * 60L + Seconds; default: abort (); } /* NOTREACHED */ } static time_t Convert(Month, Day, Year, Hours, Minutes, Seconds, Meridian, DSTmode) time_t Month; time_t Day; time_t Year; time_t Hours; time_t Minutes; time_t Seconds; MERIDIAN Meridian; DSTMODE DSTmode; { static int DaysInMonth[12] = { 31, 0, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }; time_t tod; time_t Julian; int i; if (Year < 0) Year = -Year; if (Year < 100) Year += 1900; DaysInMonth[1] = Year % 4 == 0 && (Year % 100 != 0 || Year % 400 == 0) ? 29 : 28; if (Year < EPOCH || Year > 1999 || Month < 1 || Month > 12 /* Lint fluff: "conversion from long may lose accuracy" */ || Day < 1 || Day > DaysInMonth[(int)--Month]) return -1; for (Julian = Day - 1, i = 0; i < Month; i++) Julian += DaysInMonth[i]; for (i = EPOCH; i < Year; i++) Julian += 365 + (i % 4 == 0); Julian *= SECSPERDAY; Julian += yyTimezone * 60L; if ((tod = ToSeconds(Hours, Minutes, Seconds, Meridian)) < 0) return -1; Julian += tod; if (DSTmode == DSTon || (DSTmode == DSTmaybe && localtime(&Julian)->tm_isdst)) Julian -= 60 * 60; return Julian; } static time_t DSTcorrect(Start, Future) time_t Start; time_t Future; { time_t StartDay; time_t FutureDay; StartDay = (localtime(&Start)->tm_hour + 1) % 24; FutureDay = (localtime(&Future)->tm_hour + 1) % 24; return (Future - Start) + (StartDay - FutureDay) * 60L * 60L; } static time_t RelativeDate(Start, DayOrdinal, DayNumber) time_t Start; time_t DayOrdinal; time_t DayNumber; { struct tm *tm; time_t now; now = Start; tm = localtime(&now); now += SECSPERDAY * ((DayNumber - tm->tm_wday + 7) % 7); now += 7 * SECSPERDAY * (DayOrdinal <= 0 ? DayOrdinal : DayOrdinal - 1); return DSTcorrect(Start, now); } static time_t RelativeMonth(Start, RelMonth) time_t Start; time_t RelMonth; { struct tm *tm; time_t Month; time_t Year; if (RelMonth == 0) return 0; tm = localtime(&Start); Month = 12 * tm->tm_year + tm->tm_mon + RelMonth; Year = Month / 12; Month = Month % 12 + 1; return DSTcorrect(Start, Convert(Month, (time_t)tm->tm_mday, Year, (time_t)tm->tm_hour, (time_t)tm->tm_min, (time_t)tm->tm_sec, MER24, DSTmaybe)); } static int LookupWord(buff) char *buff; { register char *p; register char *q; register const TABLE *tp; int i; int abbrev; /* Make it lowercase. */ for (p = buff; *p; p++) if (isupper(*p)) *p = tolower(*p); if (strcmp(buff, "am") == 0 || strcmp(buff, "a.m.") == 0) { yylval.Meridian = MERam; return tMERIDIAN; } if (strcmp(buff, "pm") == 0 || strcmp(buff, "p.m.") == 0) { yylval.Meridian = MERpm; return tMERIDIAN; } /* See if we have an abbreviation for a month. */ if (strlen(buff) == 3) abbrev = 1; else if (strlen(buff) == 4 && buff[3] == '.') { abbrev = 1; buff[3] = '\0'; } else abbrev = 0; for (tp = MonthDayTable; tp->name; tp++) { if (abbrev) { if (strncmp(buff, tp->name, 3) == 0) { yylval.Number = tp->value; return tp->type; } } else if (strcmp(buff, tp->name) == 0) { yylval.Number = tp->value; return tp->type; } } for (tp = TimezoneTable; tp->name; tp++) if (strcmp(buff, tp->name) == 0) { yylval.Number = tp->value; return tp->type; } if (strcmp(buff, "dst") == 0) return tDST; for (tp = UnitsTable; tp->name; tp++) if (strcmp(buff, tp->name) == 0) { yylval.Number = tp->value; return tp->type; } /* Strip off any plural and try the units table again. */ i = strlen(buff) - 1; if (buff[i] == 's') { buff[i] = '\0'; for (tp = UnitsTable; tp->name; tp++) if (strcmp(buff, tp->name) == 0) { yylval.Number = tp->value; return tp->type; } buff[i] = 's'; /* Put back for "this" in OtherTable. */ } for (tp = OtherTable; tp->name; tp++) if (strcmp(buff, tp->name) == 0) { yylval.Number = tp->value; return tp->type; } /* Military timezones. */ if (buff[1] == '\0' && isalpha(*buff)) { for (tp = MilitaryTable; tp->name; tp++) if (strcmp(buff, tp->name) == 0) { yylval.Number = tp->value; return tp->type; } } /* Drop out any periods and try the timezone table again. */ for (i = 0, p = q = buff; *q; q++) if (*q != '.') *p++ = *q; else i++; *p = '\0'; if (i) for (tp = TimezoneTable; tp->name; tp++) if (strcmp(buff, tp->name) == 0) { yylval.Number = tp->value; return tp->type; } return tID; } static int yylex() { register char c; register char *p; char buff[20]; int Count; int sign; for ( ; ; ) { while (isspace(*yyInput)) yyInput++; if (isdigit(c = *yyInput) || c == '-' || c == '+') { if (c == '-' || c == '+') { sign = c == '-' ? -1 : 1; if (!isdigit(*++yyInput)) /* skip the '-' sign */ continue; } else sign = 0; for (yylval.Number = 0; isdigit(c = *yyInput++); ) yylval.Number = 10 * yylval.Number + c - '0'; yyInput--; if (sign < 0) yylval.Number = -yylval.Number; return sign ? tSNUMBER : tUNUMBER; } if (isalpha(c)) { for (p = buff; isalpha(c = *yyInput++) || c == '.'; ) if (p < &buff[sizeof buff - 1]) *p++ = c; *p = '\0'; yyInput--; return LookupWord(buff); } if (c != '(') return *yyInput++; Count = 0; do { c = *yyInput++; if (c == '\0') return c; if (c == '(') Count++; else if (c == ')') Count--; } while (Count > 0); } } #define TM_YEAR_ORIGIN 1900 /* Yield A - B, measured in seconds. */ static long difftm (a, b) struct tm *a, *b; { int ay = a->tm_year + (TM_YEAR_ORIGIN - 1); int by = b->tm_year + (TM_YEAR_ORIGIN - 1); int days = ( /* difference in day of year */ a->tm_yday - b->tm_yday /* + intervening leap days */ + ((ay >> 2) - (by >> 2)) - (ay/100 - by/100) + ((ay/100 >> 2) - (by/100 >> 2)) /* + difference in years * 365 */ + (long)(ay-by) * 365 ); return (60*(60*(24*days + (a->tm_hour - b->tm_hour)) + (a->tm_min - b->tm_min)) + (a->tm_sec - b->tm_sec)); } time_t get_date(p, now) char *p; struct timeb *now; { struct tm *tm, gmt; struct timeb ftz; time_t Start; time_t tod; yyInput = p; if (now == NULL) { now = &ftz; (void)time(&ftz.time); if (! (tm = gmtime (&ftz.time))) return -1; gmt = *tm; /* Make a copy, in case localtime modifies *tm. */ if (! (tm = localtime (&ftz.time))) return -1; ftz.timezone = difftm (&gmt, tm) / 60; if(tm->tm_isdst) ftz.timezone += 60; } tm = localtime(&now->time); yyYear = tm->tm_year; yyMonth = tm->tm_mon + 1; yyDay = tm->tm_mday; yyTimezone = now->timezone; yyDSTmode = DSTmaybe; yyHour = 0; yyMinutes = 0; yySeconds = 0; yyMeridian = MER24; yyRelSeconds = 0; yyRelMonth = 0; yyHaveDate = 0; yyHaveDay = 0; yyHaveRel = 0; yyHaveTime = 0; yyHaveZone = 0; if (yyparse() || yyHaveTime > 1 || yyHaveZone > 1 || yyHaveDate > 1 || yyHaveDay > 1) return -1; if (yyHaveDate || yyHaveTime || yyHaveDay) { Start = Convert(yyMonth, yyDay, yyYear, yyHour, yyMinutes, yySeconds, yyMeridian, yyDSTmode); if (Start < 0) return -1; } else { Start = now->time; if (!yyHaveRel) Start -= ((tm->tm_hour * 60L + tm->tm_min) * 60L) + tm->tm_sec; } Start += yyRelSeconds; Start += RelativeMonth(Start, yyRelMonth); if (yyHaveDay && !yyHaveDate) { tod = RelativeDate(Start, yyDayOrdinal, yyDayNumber); Start += tod; } /* Have to do *something* with a legitimate -1 so it's distinguishable * from the error return value. (Alternately could set errno on error.) */ return Start == -1 ? 0 : Start; } #if defined(TEST) /* ARGSUSED */ int main(ac, av) int ac; char *av[]; { char buff[128]; time_t d; (void)printf("Enter date, or blank line to exit.\n\t> "); (void)fflush(stdout); while (gets(buff) && buff[0]) { d = get_date(buff, (struct timeb *)NULL); if (d == -1) (void)printf("Bad format - couldn't convert.\n"); else (void)printf("%s", ctime(&d)); (void)printf("\t> "); (void)fflush(stdout); } exit(0); /* NOTREACHED */ } #endif /* defined(TEST) */ sh-utils-1.10/lib/basename.c100666 74504 13 2627 5456545232 14773 0ustar meyeringuser/* basename.c -- return the last element in a path Copyright (C) 1990 Free Software Foundation, Inc. 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 2, 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, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #ifdef HAVE_CONFIG_H #if defined (CONFIG_BROKETS) /* We use instead of "config.h" so that a compilation using -I. -I$srcdir will use ./config.h rather than $srcdir/config.h (which it would do because it found this file in $srcdir). */ #include #else #include "config.h" #endif #endif #if defined(STDC_HEADERS) || defined(HAVE_STRING_H) #include #ifndef rindex #define rindex strrchr #endif #else #include #endif /* Return NAME with any leading path stripped off. */ char * basename (name) char *name; { char *base; base = rindex (name, '/'); return base ? base + 1 : name; } sh-utils-1.10/lib/error.c100444 21570 1 6301 5563566275 13535 0ustar djmdaemon/* error.c -- error handler for noninteractive utilities Copyright (C) 1990, 1991, 1992, 1993 Free Software Foundation, Inc. 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 2, 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, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ /* Written by David MacKenzie. */ #ifdef HAVE_CONFIG_H #if defined (CONFIG_BROKETS) /* We use instead of "config.h" so that a compilation using -I. -I$srcdir will use ./config.h rather than $srcdir/config.h (which it would do because it found this file in $srcdir). */ #include #else #include "config.h" #endif #endif #include #ifdef HAVE_VPRINTF #if __STDC__ #include #define VA_START(args, lastarg) va_start(args, lastarg) #else /* !__STDC__ */ #include #define VA_START(args, lastarg) va_start(args) #endif /* !__STDC__ */ #else /* !HAVE_VPRINTF */ #ifdef HAVE_DOPRNT #define va_alist args #define va_dcl int args; #else /* !HAVE_DOPRNT */ #define va_alist a1, a2, a3, a4, a5, a6, a7, a8 #define va_dcl char *a1, *a2, *a3, *a4, *a5, *a6, *a7, *a8; #endif /* !HAVE_DOPRNT */ #endif /* !HAVE_VPRINTF */ #ifdef STDC_HEADERS #include #include #else /* !STDC_HEADERS */ void exit (); #endif /* !STDC_HEADERS */ extern char *program_name; #ifndef HAVE_STRERROR static char * private_strerror (errnum) int errnum; { extern char *sys_errlist[]; extern int sys_nerr; if (errnum > 0 && errnum <= sys_nerr) return sys_errlist[errnum]; return "Unknown system error"; } #define strerror private_strerror #endif /* !HAVE_STRERROR */ /* Print the program name and error message MESSAGE, which is a printf-style format string with optional args. If ERRNUM is nonzero, print its corresponding system error message. Exit with status STATUS if it is nonzero. */ /* VARARGS */ void #if defined (HAVE_VPRINTF) && __STDC__ error (int status, int errnum, char *message, ...) #else /* !HAVE_VPRINTF or !__STDC__ */ error (status, errnum, message, va_alist) int status; int errnum; char *message; va_dcl #endif /* !HAVE_VPRINTF or !__STDC__ */ { #ifdef HAVE_VPRINTF va_list args; #endif /* HAVE_VPRINTF */ fflush (stdout); fprintf (stderr, "%s: ", program_name); #ifdef HAVE_VPRINTF VA_START (args, message); vfprintf (stderr, message, args); va_end (args); #else /* !HAVE_VPRINTF */ #ifdef HAVE_DOPRNT _doprnt (message, &args, stderr); #else /* !HAVE_DOPRNT */ fprintf (stderr, message, a1, a2, a3, a4, a5, a6, a7, a8); #endif /* !HAVE_DOPRNT */ #endif /* !HAVE_VPRINTF */ if (errnum) fprintf (stderr, ": %s", strerror (errnum)); putc ('\n', stderr); fflush (stderr); if (status) exit (status); } sh-utils-1.10/lib/stripslash.c100666 74504 13 3250 5456545320 15403 0ustar meyeringuser/* stripslash.c -- remove trailing slashes from a string Copyright (C) 1990 Free Software Foundation, Inc. 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 2, 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, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #ifdef HAVE_CONFIG_H #if defined (CONFIG_BROKETS) /* We use instead of "config.h" so that a compilation using -I. -I$srcdir will use ./config.h rather than $srcdir/config.h (which it would do because it found this file in $srcdir). */ #include #else #include "config.h" #endif #endif #if defined(STDC_HEADERS) || defined(HAVE_STRING_H) #include #else #include #endif /* Remove trailing slashes from PATH. This is useful when using filename completion from a shell that adds a "/" after directory names (such as tcsh and bash), because the Unix rename and rmdir system calls return an "Invalid argument" error when given a path that ends in "/" (except for the root directory). */ void strip_trailing_slashes (path) char *path; { int last; last = strlen (path) - 1; while (last > 0 && path[last] == '/') path[last--] = '\0'; } sh-utils-1.10/lib/xmalloc.c100666 74720 14 4055 5470130304 14446 0ustar eggertguest/* xmalloc.c -- malloc with out of memory checking Copyright (C) 1990, 1991, 1993 Free Software Foundation, Inc. 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 2, 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, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #ifdef HAVE_CONFIG_H #if defined (CONFIG_BROKETS) /* We use instead of "config.h" so that a compilation using -I. -I$srcdir will use ./config.h rather than $srcdir/config.h (which it would do because it found this file in $srcdir). */ #include #else #include "config.h" #endif #endif #if __STDC__ #define VOID void #else #define VOID char #endif #include #if STDC_HEADERS #include #else VOID *malloc (); VOID *realloc (); void free (); #endif #if __STDC__ && defined (HAVE_VPRINTF) void error (int, int, char const *, ...); #else void error (); #endif /* Allocate N bytes of memory dynamically, with error checking. */ VOID * xmalloc (n) size_t n; { VOID *p; p = malloc (n); if (p == 0) /* Must exit with 2 for `cmp'. */ error (2, 0, "memory exhausted"); return p; } /* Change the size of an allocated block of memory P to N bytes, with error checking. If P is NULL, run xmalloc. If N is 0, run free and return NULL. */ VOID * xrealloc (p, n) VOID *p; size_t n; { if (p == 0) return xmalloc (n); if (n == 0) { free (p); return 0; } p = realloc (p, n); if (p == 0) /* Must exit with 2 for `cmp'. */ error (2, 0, "memory exhausted"); return p; } sh-utils-1.10/lib/xstrdup.c100666 74504 13 2553 5456545332 14730 0ustar meyeringuser/* xstrdup.c -- copy a string with out of memory checking Copyright (C) 1990 Free Software Foundation, Inc. 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 2, 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, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #ifdef HAVE_CONFIG_H #if defined (CONFIG_BROKETS) /* We use instead of "config.h" so that a compilation using -I. -I$srcdir will use ./config.h rather than $srcdir/config.h (which it would do because it found this file in $srcdir). */ #include #else #include "config.h" #endif #endif #if defined(STDC_HEADERS) || defined(HAVE_STRING_H) #include #else #include #endif char *xmalloc (); /* Return a newly allocated copy of STRING. */ char * xstrdup (string) char *string; { return strcpy (xmalloc (strlen (string) + 1), string); } sh-utils-1.10/lib/full-write.c100644 74504 13 3502 5562505172 15274 0ustar meyeringuser/* full-write.c -- an interface to write that retries after interrupts Copyright (C) 1993, 1994 Free Software Foundation, Inc. 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 2, 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, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. Copied largely from GNU C's cccp.c. */ #ifdef HAVE_CONFIG_H #if defined (CONFIG_BROKETS) /* We use instead of "config.h" so that a compilation using -I. -I$srcdir will use ./config.h rather than $srcdir/config.h (which it would do because it found this file in $srcdir). */ #include #else #include "config.h" #endif #endif #include #ifdef HAVE_UNISTD_H #include #endif #include #ifndef STDC_HEADERS extern int errno; #endif /* Write LEN bytes at PTR to descriptor DESC, retrying if interrupted. Return LEN upon success, write's (negative) error code otherwise. */ int full_write (desc, ptr, len) int desc; char *ptr; int len; { int total_written; total_written = 0; while (len > 0) { int written = write (desc, ptr, len); if (written < 0) { #ifdef EINTR if (errno == EINTR) continue; #endif return written; } total_written += written; ptr += written; len -= written; } return total_written; } sh-utils-1.10/lib/putenv.c100644 74504 13 6052 5465540322 14524 0ustar meyeringuser/* Copyright (C) 1991 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. The GNU C Library 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 Library General Public License for more details. You should have received a copy of the GNU Library General Public License along with the GNU C Library; see the file COPYING.LIB. If not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #ifdef HAVE_CONFIG_H #if defined (CONFIG_BROKETS) /* We use instead of "config.h" so that a compilation using -I. -I$srcdir will use ./config.h rather than $srcdir/config.h (which it would do because it found this file in $srcdir). */ #include #else #include "config.h" #endif #endif #include #include /* This needs to come after some library #include to get __GNU_LIBRARY__ defined. */ #ifdef __GNU_LIBRARY__ /* Don't include stdlib.h for non-GNU C libraries because some of them contain conflicting prototypes for getopt. */ #include #else char *malloc (); #endif /* GNU C library. */ #ifndef STDC_HEADERS extern int errno; #endif #if defined(STDC_HEADERS) || defined(HAVE_STRING_H) #include #ifndef index #define index strchr #endif #ifndef bcopy #define bcopy(s, d, n) memcpy((d), (s), (n)) #endif #else #include #endif #ifdef HAVE_UNISTD_H #include #endif #ifndef NULL #define NULL 0 #endif extern char **environ; /* Put STRING, which is of the form "NAME=VALUE", in the environment. */ int putenv (string) const char *string; { char *name_end = index (string, '='); register size_t size; register char **ep; if (name_end == NULL) { /* Remove the variable from the environment. */ size = strlen (string); for (ep = environ; *ep != NULL; ++ep) if (!strncmp (*ep, string, size) && (*ep)[size] == '=') { while (ep[1] != NULL) { ep[0] = ep[1]; ++ep; } *ep = NULL; return 0; } } size = 0; for (ep = environ; *ep != NULL; ++ep) if (!strncmp (*ep, string, name_end - string) && (*ep)[name_end - string] == '=') break; else ++size; if (*ep == NULL) { static char **last_environ = NULL; char **new_environ = (char **) malloc ((size + 2) * sizeof (char *)); if (new_environ == NULL) return -1; (void) bcopy ((char *) environ, (char *) new_environ, size * sizeof (char *)); new_environ[size] = (char *) string; new_environ[size + 1] = NULL; if (last_environ != NULL) free ((char *) last_environ); last_environ = new_environ; environ = new_environ; } else *ep = (char *) string; return 0; } sh-utils-1.10/lib/getopt.c100444 21570 1 52421 5563566466 13734 0ustar djmdaemon/* Getopt for GNU. NOTE: getopt is now part of the C library, so if you don't know what "Keep this file name-space clean" means, talk to roland@gnu.ai.mit.edu before changing it! Copyright (C) 1987, 88, 89, 90, 91, 92, 93, 94 Free Software Foundation, Inc. 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 2, 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, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ /* This tells Alpha OSF/1 not to define a getopt prototype in . Ditto for AIX 3.2 and . */ #ifndef _NO_PROTO #define _NO_PROTO #endif #ifdef HAVE_CONFIG_H #if defined (emacs) || defined (CONFIG_BROKETS) /* We use instead of "config.h" so that a compilation using -I. -I$srcdir will use ./config.h rather than $srcdir/config.h (which it would do because it found this file in $srcdir). */ #include #else #include "config.h" #endif #endif #ifndef __STDC__ /* This is a separate conditional since some stdc systems reject `defined (const)'. */ #ifndef const #define const #endif #endif #include /* Comment out all this code if we are using the GNU C Library, and are not actually compiling the library itself. This code is part of the GNU C Library, but also included in many other GNU distributions. Compiling and linking in this code is a waste when using the GNU C library (especially if it is a shared library). Rather than having every GNU program understand `configure --with-gnu-libc' and omit the object files, it is simpler to just do this in the source for each such file. */ #if defined (_LIBC) || !defined (__GNU_LIBRARY__) /* This needs to come after some library #include to get __GNU_LIBRARY__ defined. */ #ifdef __GNU_LIBRARY__ /* Don't include stdlib.h for non-GNU C libraries because some of them contain conflicting prototypes for getopt. */ #include #endif /* GNU C library. */ /* This version of `getopt' appears to the caller like standard Unix `getopt' but it behaves differently for the user, since it allows the user to intersperse the options with the other arguments. As `getopt' works, it permutes the elements of ARGV so that, when it is done, all the options precede everything else. Thus all application programs are extended to handle flexible argument order. Setting the environment variable POSIXLY_CORRECT disables permutation. Then the behavior is completely standard. GNU application programs can use a third alternative mode in which they can distinguish the relative order of options and other arguments. */ #include "getopt.h" /* For communication from `getopt' to the caller. When `getopt' finds an option that takes an argument, the argument value is returned here. Also, when `ordering' is RETURN_IN_ORDER, each non-option ARGV-element is returned here. */ char *optarg = NULL; /* Index in ARGV of the next element to be scanned. This is used for communication to and from the caller and for communication between successive calls to `getopt'. On entry to `getopt', zero means this is the first call; initialize. When `getopt' returns EOF, this is the index of the first of the non-option elements that the caller should itself scan. Otherwise, `optind' communicates from one call to the next how much of ARGV has been scanned so far. */ /* XXX 1003.2 says this must be 1 before any call. */ int optind = 0; /* The next char to be scanned in the option-element in which the last option character we returned was found. This allows us to pick up the scan where we left off. If this is zero, or a null string, it means resume the scan by advancing to the next ARGV-element. */ static char *nextchar; /* Callers store zero here to inhibit the error message for unrecognized options. */ int opterr = 1; /* Set to an option character which was unrecognized. This must be initialized on some systems to avoid linking in the system's own getopt implementation. */ int optopt = '?'; /* Describe how to deal with options that follow non-option ARGV-elements. If the caller did not specify anything, the default is REQUIRE_ORDER if the environment variable POSIXLY_CORRECT is defined, PERMUTE otherwise. REQUIRE_ORDER means don't recognize them as options; stop option processing when the first non-option is seen. This is what Unix does. This mode of operation is selected by either setting the environment variable POSIXLY_CORRECT, or using `+' as the first character of the list of option characters. PERMUTE is the default. We permute the contents of ARGV as we scan, so that eventually all the non-options are at the end. This allows options to be given in any order, even with programs that were not written to expect this. RETURN_IN_ORDER is an option available to programs that were written to expect options and other ARGV-elements in any order and that care about the ordering of the two. We describe each non-option ARGV-element as if it were the argument of an option with character code 1. Using `-' as the first character of the list of option characters selects this mode of operation. The special argument `--' forces an end of option-scanning regardless of the value of `ordering'. In the case of RETURN_IN_ORDER, only `--' can cause `getopt' to return EOF with `optind' != ARGC. */ static enum { REQUIRE_ORDER, PERMUTE, RETURN_IN_ORDER } ordering; #ifdef __GNU_LIBRARY__ /* We want to avoid inclusion of string.h with non-GNU libraries because there are many ways it can cause trouble. On some systems, it contains special magic macros that don't work in GCC. */ #include #define my_index strchr #else /* Avoid depending on library functions or files whose names are inconsistent. */ char *getenv (); static char * my_index (str, chr) const char *str; int chr; { while (*str) { if (*str == chr) return (char *) str; str++; } return 0; } /* If using GCC, we can safely declare strlen this way. If not using GCC, it is ok not to declare it. */ #ifdef __GNUC__ /* Note that Motorola Delta 68k R3V7 comes with GCC but not stddef.h. That was relevant to code that was here before. */ #ifndef __STDC__ /* gcc with -traditional declares the built-in strlen to return int, and has done so at least since version 2.4.5. -- rms. */ extern int strlen (const char *); #endif /* not __STDC__ */ #endif /* __GNUC__ */ #endif /* not __GNU_LIBRARY__ */ /* Handle permutation of arguments. */ /* Describe the part of ARGV that contains non-options that have been skipped. `first_nonopt' is the index in ARGV of the first of them; `last_nonopt' is the index after the last of them. */ static int first_nonopt; static int last_nonopt; /* Exchange two adjacent subsequences of ARGV. One subsequence is elements [first_nonopt,last_nonopt) which contains all the non-options that have been skipped so far. The other is elements [last_nonopt,optind), which contains all the options processed since those non-options were skipped. `first_nonopt' and `last_nonopt' are relocated so that they describe the new indices of the non-options in ARGV after they are moved. */ static void exchange (argv) char **argv; { int bottom = first_nonopt; int middle = last_nonopt; int top = optind; char *tem; /* Exchange the shorter segment with the far end of the longer segment. That puts the shorter segment into the right place. It leaves the longer segment in the right place overall, but it consists of two parts that need to be swapped next. */ while (top > middle && middle > bottom) { if (top - middle > middle - bottom) { /* Bottom segment is the short one. */ int len = middle - bottom; register int i; /* Swap it with the top part of the top segment. */ for (i = 0; i < len; i++) { tem = argv[bottom + i]; argv[bottom + i] = argv[top - (middle - bottom) + i]; argv[top - (middle - bottom) + i] = tem; } /* Exclude the moved bottom segment from further swapping. */ top -= len; } else { /* Top segment is the short one. */ int len = top - middle; register int i; /* Swap it with the bottom part of the bottom segment. */ for (i = 0; i < len; i++) { tem = argv[bottom + i]; argv[bottom + i] = argv[middle + i]; argv[middle + i] = tem; } /* Exclude the moved top segment from further swapping. */ bottom += len; } } /* Update records for the slots the non-options now occupy. */ first_nonopt += (optind - last_nonopt); last_nonopt = optind; } /* Initialize the internal data when the first call is made. */ static const char * _getopt_initialize (optstring) const char *optstring; { /* Start processing options with ARGV-element 1 (since ARGV-element 0 is the program name); the sequence of previously skipped non-option ARGV-elements is empty. */ first_nonopt = last_nonopt = optind = 1; nextchar = NULL; /* Determine how to handle the ordering of options and nonoptions. */ if (optstring[0] == '-') { ordering = RETURN_IN_ORDER; ++optstring; } else if (optstring[0] == '+') { ordering = REQUIRE_ORDER; ++optstring; } else if (getenv ("POSIXLY_CORRECT") != NULL) ordering = REQUIRE_ORDER; else ordering = PERMUTE; return optstring; } /* Scan elements of ARGV (whose length is ARGC) for option characters given in OPTSTRING. If an element of ARGV starts with '-', and is not exactly "-" or "--", then it is an option element. The characters of this element (aside from the initial '-') are option characters. If `getopt' is called repeatedly, it returns successively each of the option characters from each of the option elements. If `getopt' finds another option character, it returns that character, updating `optind' and `nextchar' so that the next call to `getopt' can resume the scan with the following option character or ARGV-element. If there are no more option characters, `getopt' returns `EOF'. Then `optind' is the index in ARGV of the first ARGV-element that is not an option. (The ARGV-elements have been permuted so that those that are not options now come last.) OPTSTRING is a string containing the legitimate option characters. If an option character is seen that is not listed in OPTSTRING, return '?' after printing an error message. If you set `opterr' to zero, the error message is suppressed but we still return '?'. If a char in OPTSTRING is followed by a colon, that means it wants an arg, so the following text in the same ARGV-element, or the text of the following ARGV-element, is returned in `optarg'. Two colons mean an option that wants an optional arg; if there is text in the current ARGV-element, it is returned in `optarg', otherwise `optarg' is set to zero. If OPTSTRING starts with `-' or `+', it requests different methods of handling the non-option ARGV-elements. See the comments about RETURN_IN_ORDER and REQUIRE_ORDER, above. Long-named options begin with `--' instead of `-'. Their names may be abbreviated as long as the abbreviation is unique or is an exact match for some defined option. If they have an argument, it follows the option name in the same ARGV-element, separated from the option name by a `=', or else the in next ARGV-element. When `getopt' finds a long-named option, it returns 0 if that option's `flag' field is nonzero, the value of the option's `val' field if the `flag' field is zero. The elements of ARGV aren't really const, because we permute them. But we pretend they're const in the prototype to be compatible with other systems. LONGOPTS is a vector of `struct option' terminated by an element containing a name which is zero. LONGIND returns the index in LONGOPT of the long-named option found. It is only valid when a long-named option has been found by the most recent call. If LONG_ONLY is nonzero, '-' as well as '--' can introduce long-named options. */ int _getopt_internal (argc, argv, optstring, longopts, longind, long_only) int argc; char *const *argv; const char *optstring; const struct option *longopts; int *longind; int long_only; { optarg = NULL; if (optind == 0) optstring = _getopt_initialize (optstring); if (nextchar == NULL || *nextchar == '\0') { /* Advance to the next ARGV-element. */ if (ordering == PERMUTE) { /* If we have just processed some options following some non-options, exchange them so that the options come first. */ if (first_nonopt != last_nonopt && last_nonopt != optind) exchange ((char **) argv); else if (last_nonopt != optind) first_nonopt = optind; /* Skip any additional non-options and extend the range of non-options previously skipped. */ while (optind < argc && (argv[optind][0] != '-' || argv[optind][1] == '\0')) optind++; last_nonopt = optind; } /* The special ARGV-element `--' means premature end of options. Skip it like a null option, then exchange with previous non-options as if it were an option, then skip everything else like a non-option. */ if (optind != argc && !strcmp (argv[optind], "--")) { optind++; if (first_nonopt != last_nonopt && last_nonopt != optind) exchange ((char **) argv); else if (first_nonopt == last_nonopt) first_nonopt = optind; last_nonopt = argc; optind = argc; } /* If we have done all the ARGV-elements, stop the scan and back over any non-options that we skipped and permuted. */ if (optind == argc) { /* Set the next-arg-index to point at the non-options that we previously skipped, so the caller will digest them. */ if (first_nonopt != last_nonopt) optind = first_nonopt; return EOF; } /* If we have come to a non-option and did not permute it, either stop the scan or describe it to the caller and pass it by. */ if ((argv[optind][0] != '-' || argv[optind][1] == '\0')) { if (ordering == REQUIRE_ORDER) return EOF; optarg = argv[optind++]; return 1; } /* We have found another option-ARGV-element. Skip the initial punctuation. */ nextchar = (argv[optind] + 1 + (longopts != NULL && argv[optind][1] == '-')); } /* Decode the current option-ARGV-element. */ /* Check whether the ARGV-element is a long option. If long_only and the ARGV-element has the form "-f", where f is a valid short option, don't consider it an abbreviated form of a long option that starts with f. Otherwise there would be no way to give the -f short option. On the other hand, if there's a long option "fubar" and the ARGV-element is "-fu", do consider that an abbreviation of the long option, just like "--fu", and not "-f" with arg "u". This distinction seems to be the most useful approach. */ if (longopts != NULL && (argv[optind][1] == '-' || (long_only && (argv[optind][2] || !my_index (optstring, argv[optind][1]))))) { char *nameend; const struct option *p; const struct option *pfound = NULL; int exact = 0; int ambig = 0; int indfound; int option_index; for (nameend = nextchar; *nameend && *nameend != '='; nameend++) /* Do nothing. */ ; /* Test all long options for either exact match or abbreviated matches. */ for (p = longopts, option_index = 0; p->name; p++, option_index++) if (!strncmp (p->name, nextchar, nameend - nextchar)) { if (nameend - nextchar == strlen (p->name)) { /* Exact match found. */ pfound = p; indfound = option_index; exact = 1; break; } else if (pfound == NULL) { /* First nonexact match found. */ pfound = p; indfound = option_index; } else /* Second or later nonexact match found. */ ambig = 1; } if (ambig && !exact) { if (opterr) fprintf (stderr, "%s: option `%s' is ambiguous\n", argv[0], argv[optind]); nextchar += strlen (nextchar); optind++; return '?'; } if (pfound != NULL) { option_index = indfound; optind++; if (*nameend) { /* Don't test has_arg with >, because some C compilers don't allow it to be used on enums. */ if (pfound->has_arg) optarg = nameend + 1; else { if (opterr) { if (argv[optind - 1][1] == '-') /* --option */ fprintf (stderr, "%s: option `--%s' doesn't allow an argument\n", argv[0], pfound->name); else /* +option or -option */ fprintf (stderr, "%s: option `%c%s' doesn't allow an argument\n", argv[0], argv[optind - 1][0], pfound->name); } nextchar += strlen (nextchar); return '?'; } } else if (pfound->has_arg == 1) { if (optind < argc) optarg = argv[optind++]; else { if (opterr) fprintf (stderr, "%s: option `%s' requires an argument\n", argv[0], argv[optind - 1]); nextchar += strlen (nextchar); return optstring[0] == ':' ? ':' : '?'; } } nextchar += strlen (nextchar); if (longind != NULL) *longind = option_index; if (pfound->flag) { *(pfound->flag) = pfound->val; return 0; } return pfound->val; } /* Can't find it as a long option. If this is not getopt_long_only, or the option starts with '--' or is not a valid short option, then it's an error. Otherwise interpret it as a short option. */ if (!long_only || argv[optind][1] == '-' || my_index (optstring, *nextchar) == NULL) { if (opterr) { if (argv[optind][1] == '-') /* --option */ fprintf (stderr, "%s: unrecognized option `--%s'\n", argv[0], nextchar); else /* +option or -option */ fprintf (stderr, "%s: unrecognized option `%c%s'\n", argv[0], argv[optind][0], nextchar); } nextchar = (char *) ""; optind++; return '?'; } } /* Look at and handle the next short option-character. */ { char c = *nextchar++; char *temp = my_index (optstring, c); /* Increment `optind' when we start to process its last character. */ if (*nextchar == '\0') ++optind; if (temp == NULL || c == ':') { if (opterr) { /* 1003.2 specifies the format of this message. */ fprintf (stderr, "%s: illegal option -- %c\n", argv[0], c); } optopt = c; return '?'; } if (temp[1] == ':') { if (temp[2] == ':') { /* This is an option that accepts an argument optionally. */ if (*nextchar != '\0') { optarg = nextchar; optind++; } else optarg = NULL; nextchar = NULL; } else { /* This is an option that requires an argument. */ if (*nextchar != '\0') { optarg = nextchar; /* If we end this ARGV-element by taking the rest as an arg, we must advance to the next element now. */ optind++; } else if (optind == argc) { if (opterr) { /* 1003.2 specifies the format of this message. */ fprintf (stderr, "%s: option requires an argument -- %c\n", argv[0], c); } optopt = c; if (optstring[0] == ':') c = ':'; else c = '?'; } else /* We already incremented `optind' once; increment it again when taking next ARGV-elt as argument. */ optarg = argv[optind++]; nextchar = NULL; } } return c; } } int getopt (argc, argv, optstring) int argc; char *const *argv; const char *optstring; { return _getopt_internal (argc, argv, optstring, (const struct option *) 0, (int *) 0, 0); } #endif /* _LIBC or not __GNU_LIBRARY__. */ #ifdef TEST /* Compile with -DTEST to make an executable for use in testing the above definition of `getopt'. */ int main (argc, argv) int argc; char **argv; { int c; int digit_optind = 0; while (1) { int this_option_optind = optind ? optind : 1; c = getopt (argc, argv, "abc:d:0123456789"); if (c == EOF) break; switch (c) { case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': if (digit_optind != 0 && digit_optind != this_option_optind) printf ("digits occur in two different argv-elements.\n"); digit_optind = this_option_optind; printf ("option %c\n", c); break; case 'a': printf ("option a\n"); break; case 'b': printf ("option b\n"); break; case 'c': printf ("option c with value `%s'\n", optarg); break; case '?': break; default: printf ("?? getopt returned character code 0%o ??\n", c); } } if (optind < argc) { printf ("non-option ARGV-elements: "); while (optind < argc) printf ("%s ", argv[optind++]); printf ("\n"); } exit (0); } #endif /* TEST */ sh-utils-1.10/lib/getopt1.c100444 21570 1 10640 5563566500 13777 0ustar djmdaemon/* getopt_long and getopt_long_only entry points for GNU getopt. Copyright (C) 1987, 88, 89, 90, 91, 92, 1993 Free Software Foundation, Inc. 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 2, 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, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ #ifdef HAVE_CONFIG_H #if defined (emacs) || defined (CONFIG_BROKETS) /* We use instead of "config.h" so that a compilation using -I. -I$srcdir will use ./config.h rather than $srcdir/config.h (which it would do because it found this file in $srcdir). */ #include #else #include "config.h" #endif #endif #include "getopt.h" #ifndef __STDC__ /* This is a separate conditional since some stdc systems reject `defined (const)'. */ #ifndef const #define const #endif #endif #include /* Comment out all this code if we are using the GNU C Library, and are not actually compiling the library itself. This code is part of the GNU C Library, but also included in many other GNU distributions. Compiling and linking in this code is a waste when using the GNU C library (especially if it is a shared library). Rather than having every GNU program understand `configure --with-gnu-libc' and omit the object files, it is simpler to just do this in the source for each such file. */ #if defined (_LIBC) || !defined (__GNU_LIBRARY__) /* This needs to come after some library #include to get __GNU_LIBRARY__ defined. */ #ifdef __GNU_LIBRARY__ #include #else char *getenv (); #endif #ifndef NULL #define NULL 0 #endif int getopt_long (argc, argv, options, long_options, opt_index) int argc; char *const *argv; const char *options; const struct option *long_options; int *opt_index; { return _getopt_internal (argc, argv, options, long_options, opt_index, 0); } /* Like getopt_long, but '-' as well as '--' can indicate a long option. If an option that starts with '-' (not '--') doesn't match a long option, but does match a short option, it is parsed as a short option instead. */ int getopt_long_only (argc, argv, options, long_options, opt_index) int argc; char *const *argv; const char *options; const struct option *long_options; int *opt_index; { return _getopt_internal (argc, argv, options, long_options, opt_index, 1); } #endif /* _LIBC or not __GNU_LIBRARY__. */ #ifdef TEST #include int main (argc, argv) int argc; char **argv; { int c; int digit_optind = 0; while (1) { int this_option_optind = optind ? optind : 1; int option_index = 0; static struct option long_options[] = { {"add", 1, 0, 0}, {"append", 0, 0, 0}, {"delete", 1, 0, 0}, {"verbose", 0, 0, 0}, {"create", 0, 0, 0}, {"file", 1, 0, 0}, {0, 0, 0, 0} }; c = getopt_long (argc, argv, "abc:d:0123456789", long_options, &option_index); if (c == EOF) break; switch (c) { case 0: printf ("option %s", long_options[option_index].name); if (optarg) printf (" with arg %s", optarg); printf ("\n"); break; case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': if (digit_optind != 0 && digit_optind != this_option_optind) printf ("digits occur in two different argv-elements.\n"); digit_optind = this_option_optind; printf ("option %c\n", c); break; case 'a': printf ("option a\n"); break; case 'b': printf ("option b\n"); break; case 'c': printf ("option c with value `%s'\n", optarg); break; case 'd': printf ("option d with value `%s'\n", optarg); break; case '?': break; default: printf ("?? getopt returned character code 0%o ??\n", c); } } if (optind < argc) { printf ("non-option ARGV-elements: "); while (optind < argc) printf ("%s ", argv[optind++]); printf ("\n"); } exit (0); } #endif /* TEST */ sh-utils-1.10/lib/getugroups.c100666 74504 13 4162 5456433726 15424 0ustar meyeringuser/* getugroups.c -- return a list of the groups a user is in Copyright (C) 1990, 1991 Free Software Foundation. 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 2, 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, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ /* Written by David MacKenzie. */ #ifdef HAVE_CONFIG_H #if defined (CONFIG_BROKETS) /* We use instead of "config.h" so that a compilation using -I. -I$srcdir will use ./config.h rather than $srcdir/config.h (which it would do because it found this file in $srcdir). */ #include #else #include "config.h" #endif #endif #include #include #ifdef HAVE_UNISTD_H #include #endif /* setgrent, getgrent, and endgrent are not specified by POSIX.1, so header files might not declare them. If you don't have them at all, we can't implement this function. You lose! */ struct group *getgrent (); #if defined(STDC_HEADERS) || defined(HAVE_STRING_H) #include #else #include #endif /* Like `getgroups', but for user USERNAME instead of for the current process. */ int getugroups (maxcount, grouplist, username) int maxcount; GETGROUPS_T *grouplist; char *username; { struct group *grp; register char **cp; register int count = 0; setgrent (); while ((grp = getgrent ()) != 0) for (cp = grp->gr_mem; *cp; ++cp) if (!strcmp (username, *cp)) { if (maxcount != 0) { if (count >= maxcount) { endgrent (); return count; } grouplist[count] = grp->gr_gid; } count++; } endgrent (); return count; } sh-utils-1.10/lib/posixtm.y100666 74504 13 10462 5456545100 14757 0ustar meyeringuser/* Parse dates for touch. Copyright (C) 1989, 1990, 1991 Free Software Foundation Inc. 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 2, 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, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ /* Written by Jim Kingdon and David MacKenzie. */ %{ #ifdef HAVE_CONFIG_H #if defined (CONFIG_BROKETS) /* We use instead of "config.h" so that a compilation using -I. -I$srcdir will use ./config.h rather than $srcdir/config.h (which it would do because it found this file in $srcdir). */ #include #else #include "config.h" #endif #endif /* The following block of alloca-related preprocessor directives is here solely to allow compilation by non GNU-C compilers of the C parser produced from this file by old versions of bison. Newer versions of bison include a block similar to this one in bison.simple. */ #ifdef __GNUC__ #define alloca __builtin_alloca #else #ifdef HAVE_ALLOCA_H #include #else #ifdef _AIX #pragma alloca #else void *alloca (); #endif #endif #endif #include #include #ifdef TM_IN_SYS_TIME #include #else #include #endif /* Some old versions of bison generate parsers that use bcopy. That loses on systems that don't provide the function, so we have to redefine it here. */ #if !defined (HAVE_BCOPY) && defined (HAVE_MEMCPY) && !defined (bcopy) #define bcopy(from, to, len) memcpy ((to), (from), (len)) #endif #define YYDEBUG 1 /* Lexical analyzer's current scan position in the input string. */ static char *curpos; /* The return value. */ static struct tm t; time_t mktime (); #define yyparse posixtime_yyparse static int yylex (); static int yyerror (); %} %token DIGIT %% date : digitpair /* month */ digitpair /* day */ digitpair /* hours */ digitpair /* minutes */ year seconds { if ($1 >= 1 && $1 <= 12) t.tm_mon = $1 - 1; else { YYABORT; } if ($2 >= 1 && $2 <= 31) t.tm_mday = $2; else { YYABORT; } if ($3 >= 0 && $3 <= 23) t.tm_hour = $3; else { YYABORT; } if ($4 >= 0 && $4 <= 59) t.tm_min = $4; else { YYABORT; } } year : digitpair { t.tm_year = $1; /* Deduce the century based on the year. See POSIX.2 section 4.63.3. */ if ($1 <= 68) t.tm_year += 100; } | digitpair digitpair { t.tm_year = $1 * 100 + $2; if (t.tm_year < 1900) { YYABORT; } else t.tm_year -= 1900; } | /* empty */ { time_t now; struct tm *tmp; /* Use current year. */ time (&now); tmp = localtime (&now); t.tm_year = tmp->tm_year; } ; seconds : /* empty */ { t.tm_sec = 0; } | '.' digitpair { if ($2 >= 0 && $2 <= 61) t.tm_sec = $2; else { YYABORT; } } ; digitpair : DIGIT DIGIT { $$ = $1 * 10 + $2; } ; %% static int yylex () { char ch = *curpos++; if (ch >= '0' && ch <= '9') { yylval = ch - '0'; return DIGIT; } else if (ch == '.' || ch == 0) return ch; else return '?'; /* Cause an error. */ } static int yyerror () { return 0; } /* Parse a POSIX-style date and return it, or (time_t)-1 for an error. */ time_t posixtime (s) char *s; { curpos = s; /* Let mktime decide whether it is daylight savings time. */ t.tm_isdst = -1; if (yyparse ()) return (time_t)-1; else return mktime (&t); } /* Parse a POSIX-style date and return it, or NULL for an error. */ struct tm * posixtm (s) char *s; { if (posixtime (s) == -1) return NULL; return &t; } sh-utils-1.10/lib/strftime.c100666 74504 1 27400 5510205176 15322 0ustar meyeringdaemon/* strftime - custom formatting of date and/or time Copyright (C) 1989, 1991, 1992 Free Software Foundation, Inc. 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 2, 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, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ /* Note: this version of strftime lacks locale support, but it is standalone. Performs `%' substitutions similar to those in printf. Except where noted, substituted fields have a fixed size; numeric fields are padded if necessary. Padding is with zeros by default; for fields that display a single number, padding can be changed or inhibited by following the `%' with one of the modifiers described below. Unknown field specifiers are copied as normal characters. All other characters are copied to the output without change. Supports a superset of the ANSI C field specifiers. Literal character fields: % % n newline t tab Numeric modifiers (a nonstandard extension): - do not pad the field _ pad the field with spaces Time fields: %H hour (00..23) %I hour (01..12) %k hour ( 0..23) %l hour ( 1..12) %M minute (00..59) %p locale's AM or PM %r time, 12-hour (hh:mm:ss [AP]M) %R time, 24-hour (hh:mm) %s time in seconds since 00:00:00, Jan 1, 1970 (a nonstandard extension) %S second (00..61) %T time, 24-hour (hh:mm:ss) %X locale's time representation (%H:%M:%S) %Z time zone (EDT), or nothing if no time zone is determinable Date fields: %a locale's abbreviated weekday name (Sun..Sat) %A locale's full weekday name, variable length (Sunday..Saturday) %b locale's abbreviated month name (Jan..Dec) %B locale's full month name, variable length (January..December) %c locale's date and time (Sat Nov 04 12:02:33 EST 1989) %C century (00..99) %d day of month (01..31) %e day of month ( 1..31) %D date (mm/dd/yy) %h same as %b %j day of year (001..366) %m month (01..12) %U week number of year with Sunday as first day of week (00..53) %w day of week (0..6) %W week number of year with Monday as first day of week (00..53) %x locale's date representation (mm/dd/yy) %y last two digits of year (00..99) %Y year (1970...) David MacKenzie */ #ifdef HAVE_CONFIG_H #if defined (CONFIG_BROKETS) /* We use instead of "config.h" so that a compilation using -I. -I$srcdir will use ./config.h rather than $srcdir/config.h (which it would do because it found this file in $srcdir). */ #include #else #include "config.h" #endif #endif #include #include #if defined(TM_IN_SYS_TIME) || (!defined(HAVE_TM_ZONE) && !defined(HAVE_TZNAME)) #include #else #include #endif #ifndef STDC_HEADERS time_t mktime (); #endif #if defined(HAVE_TZNAME) extern char *tzname[2]; #endif /* Types of padding for numbers in date and time. */ enum padding { none, blank, zero }; static char const* const days[] = { "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday" }; static char const * const months[] = { "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December" }; /* Add character C to STRING and increment LENGTH, unless LENGTH would exceed MAX. */ #define add_char(c) \ do \ { \ if (length + 1 <= max) \ string[length++] = (c); \ } \ while (0) /* Add a 2 digit number to STRING, padding if specified. Return the number of characters added, up to MAX. */ static int add_num2 (string, num, max, pad) char *string; int num; int max; enum padding pad; { int top = num / 10; int length = 0; if (top == 0 && pad == blank) add_char (' '); else if (top != 0 || pad == zero) add_char (top + '0'); add_char (num % 10 + '0'); return length; } /* Add a 3 digit number to STRING, padding if specified. Return the number of characters added, up to MAX. */ static int add_num3 (string, num, max, pad) char *string; int num; int max; enum padding pad; { int top = num / 100; int mid = (num - top * 100) / 10; int length = 0; if (top == 0 && pad == blank) add_char (' '); else if (top != 0 || pad == zero) add_char (top + '0'); if (mid == 0 && top == 0 && pad == blank) add_char (' '); else if (mid != 0 || top != 0 || pad == zero) add_char (mid + '0'); add_char (num % 10 + '0'); return length; } /* Like strncpy except return the number of characters copied. */ static int add_str (to, from, max) char *to; const char *from; int max; { int i; for (i = 0; from[i] && i <= max; ++i) to[i] = from[i]; return i; } static int add_num_time_t (string, max, num) char *string; int max; time_t num; { /* This buffer is large enough to hold the character representation (including the trailing NUL) of any unsigned decimal quantity whose binary representation fits in 128 bits. */ char buf[40]; int length; if (sizeof (num) > 16) abort (); sprintf (buf, "%lu", (unsigned long) num); length = add_str (string, buf, max); return length; } /* Return the week in the year of the time in TM, with the weeks starting on Sundays. */ static int sun_week (tm) struct tm *tm; { int dl; /* Set `dl' to the day in the year of the last day of the week previous to the one containing the day specified in TM. If the day specified in TM is in the first week of the year, `dl' will be negative or 0. Otherwise, calculate the number of complete weeks before our week (dl / 7) and add any partial week at the start of the year (dl % 7). */ dl = tm->tm_yday - tm->tm_wday; return dl <= 0 ? 0 : dl / 7 + (dl % 7 != 0); } /* Return the week in the year of the time in TM, with the weeks starting on Mondays. */ static int mon_week (tm) struct tm *tm; { int dl, wday; if (tm->tm_wday == 0) wday = 6; else wday = tm->tm_wday - 1; dl = tm->tm_yday - wday; return dl <= 0 ? 0 : dl / 7 + (dl % 7 != 0); } #if !defined(HAVE_TM_ZONE) && !defined(HAVE_TZNAME) char * zone_name (tp) struct tm *tp; { char *timezone (); struct timeval tv; struct timezone tz; gettimeofday (&tv, &tz); return timezone (tz.tz_minuteswest, tp->tm_isdst); } #endif /* Format the time given in TM according to FORMAT, and put the results in STRING. Return the number of characters (not including terminating null) that were put into STRING, or 0 if the length would have exceeded MAX. */ size_t strftime (string, max, format, tm) char *string; size_t max; const char *format; const struct tm *tm; { enum padding pad; /* Type of padding to apply. */ size_t length = 0; /* Characters put in STRING so far. */ for (; *format && length < max; ++format) { if (*format != '%') add_char (*format); else { ++format; /* Modifiers: */ if (*format == '-') { pad = none; ++format; } else if (*format == '_') { pad = blank; ++format; } else pad = zero; switch (*format) { /* Literal character fields: */ case 0: case '%': add_char ('%'); break; case 'n': add_char ('\n'); break; case 't': add_char ('\t'); break; default: add_char (*format); break; /* Time fields: */ case 'H': case 'k': length += add_num2 (&string[length], tm->tm_hour, max - length, *format == 'H' ? pad : blank); break; case 'I': case 'l': { int hour12; if (tm->tm_hour == 0) hour12 = 12; else if (tm->tm_hour > 12) hour12 = tm->tm_hour - 12; else hour12 = tm->tm_hour; length += add_num2 (&string[length], hour12, max - length, *format == 'I' ? pad : blank); } break; case 'M': length += add_num2 (&string[length], tm->tm_min, max - length, pad); break; case 'p': if (tm->tm_hour < 12) add_char ('A'); else add_char ('P'); add_char ('M'); break; case 'r': length += strftime (&string[length], max - length, "%I:%M:%S %p", tm); break; case 'R': length += strftime (&string[length], max - length, "%H:%M", tm); break; case 's': { struct tm writable_tm; writable_tm = *tm; length += add_num_time_t (&string[length], max - length, mktime (&writable_tm)); } break; case 'S': length += add_num2 (&string[length], tm->tm_sec, max - length, pad); break; case 'T': length += strftime (&string[length], max - length, "%H:%M:%S", tm); break; case 'X': length += strftime (&string[length], max - length, "%H:%M:%S", tm); break; case 'Z': #ifdef HAVE_TM_ZONE length += add_str (&string[length], tm->tm_zone, max - length); #else #ifdef HAVE_TZNAME if (tm->tm_isdst && tzname[1] && *tzname[1]) length += add_str (&string[length], tzname[1], max - length); else length += add_str (&string[length], tzname[0], max - length); #else length += add_str (&string[length], zone_name (tm), max - length); #endif #endif break; /* Date fields: */ case 'a': add_char (days[tm->tm_wday][0]); add_char (days[tm->tm_wday][1]); add_char (days[tm->tm_wday][2]); break; case 'A': length += add_str (&string[length], days[tm->tm_wday], max - length); break; case 'b': case 'h': add_char (months[tm->tm_mon][0]); add_char (months[tm->tm_mon][1]); add_char (months[tm->tm_mon][2]); break; case 'B': length += add_str (&string[length], months[tm->tm_mon], max - length); break; case 'c': length += strftime (&string[length], max - length, "%a %b %d %H:%M:%S %Z %Y", tm); break; case 'C': length += add_num2 (&string[length], (tm->tm_year + 1900) / 100, max - length, pad); break; case 'd': length += add_num2 (&string[length], tm->tm_mday, max - length, pad); break; case 'e': length += add_num2 (&string[length], tm->tm_mday, max - length, blank); break; case 'D': length += strftime (&string[length], max - length, "%m/%d/%y", tm); break; case 'j': length += add_num3 (&string[length], tm->tm_yday + 1, max - length, pad); break; case 'm': length += add_num2 (&string[length], tm->tm_mon + 1, max - length, pad); break; case 'U': length += add_num2 (&string[length], sun_week (tm), max - length, pad); break; case 'w': add_char (tm->tm_wday + '0'); break; case 'W': length += add_num2 (&string[length], mon_week (tm), max - length, pad); break; case 'x': length += strftime (&string[length], max - length, "%m/%d/%y", tm); break; case 'y': length += add_num2 (&string[length], tm->tm_year % 100, max - length, pad); break; case 'Y': add_char ((tm->tm_year + 1900) / 1000 + '0'); length += add_num3 (&string[length], (1900 + tm->tm_year) % 1000, max - length, zero); break; } } } add_char (0); return length - 1; } sh-utils-1.10/lib/gethostname.c100666 74504 13 3371 5456434474 15540 0ustar meyeringuser/* gethostname emulation for SysV and POSIX.1. Copyright (C) 1992 Free Software Foundation, Inc. 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 2, 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, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ /* David MacKenzie */ #ifdef HAVE_CONFIG_H #if defined (CONFIG_BROKETS) /* We use instead of "config.h" so that a compilation using -I. -I$srcdir will use ./config.h rather than $srcdir/config.h (which it would do because it found this file in $srcdir). */ #include #else #include "config.h" #endif #endif #ifdef HAVE_UNAME #include #endif /* Put up to LEN chars of the host name into NAME. Null terminate it if the name is shorter than LEN. Return 0 if ok, -1 if error. */ int gethostname (name, len) char *name; int len; { #ifdef HAVE_UNAME struct utsname uts; if (uname (&uts) == -1) return -1; if (len > sizeof (uts.nodename)) { /* More space than we need is available. */ name[sizeof (uts.nodename)] = '\0'; len = sizeof (uts.nodename); } strncpy (name, uts.nodename, len); #else strcpy (name, ""); /* Hardcode your system name if you want. */ #endif return 0; } sh-utils-1.10/lib/getusershell.c100666 74504 13 11116 5460137054 15731 0ustar meyeringuser/* getusershell.c -- Return names of valid user shells. Copyright (C) 1991 Free Software Foundation, Inc. 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 2, 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, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ /* Written by David MacKenzie */ #ifdef HAVE_CONFIG_H #if defined (CONFIG_BROKETS) /* We use instead of "config.h" so that a compilation using -I. -I$srcdir will use ./config.h rather than $srcdir/config.h (which it would do because it found this file in $srcdir). */ #include #else #include "config.h" #endif #endif #ifndef SHELLS_FILE /* File containing a list of nonrestricted shells, one per line. */ #define SHELLS_FILE "/etc/shells" #endif #include #include #ifdef STDC_HEADERS #include #else char *malloc (); char *realloc (); #endif char *xstrdup (); static int readname (); /* List of shells to use if the shells file is missing. */ static char const* const default_shells[] = { "/bin/sh", "/bin/csh", "/usr/bin/sh", "/usr/bin/csh", NULL }; /* Index of the next shell in `default_shells' to return. 0 means we are not using `default_shells'. */ static int default_index = 0; /* Input stream from the shells file. */ static FILE *shellstream = NULL; /* Line of input from the shells file. */ static char *line = NULL; /* Number of bytes allocated for `line'. */ static int line_size = 0; /* Return an entry from the shells file, ignoring comment lines. If the file doesn't exist, use the list in DEFAULT_SHELLS (above). In any case, the returned string is in memory allocated through malloc. Return NULL if there are no more entries. */ char * getusershell () { if (default_index > 0) { if (default_shells[default_index]) /* Not at the end of the list yet. */ return xstrdup (default_shells[default_index++]); return NULL; } if (shellstream == NULL) { shellstream = fopen (SHELLS_FILE, "r"); if (shellstream == NULL) { /* No shells file. Use the default list. */ default_index = 1; return xstrdup (default_shells[0]); } } while (readname (&line, &line_size, shellstream)) { if (*line != '#') return line; } return NULL; /* End of file. */ } /* Rewind the shells file. */ void setusershell () { default_index = 0; if (shellstream == NULL) shellstream = fopen (SHELLS_FILE, "r"); else fseek (shellstream, 0L, 0); } /* Close the shells file. */ void endusershell () { if (shellstream) { fclose (shellstream); shellstream = NULL; } } /* Allocate N bytes of memory dynamically, with error checking. */ static char * xmalloc (n) unsigned n; { char *p; p = malloc (n); if (p == 0) { fprintf (stderr, "virtual memory exhausted\n"); exit (1); } return p; } /* Reallocate space P to size N, with error checking. */ static char * xrealloc (p, n) char *p; unsigned n; { p = realloc (p, n); if (p == 0) { fprintf (stderr, "virtual memory exhausted\n"); exit (1); } return p; } /* Read a line from STREAM, removing any newline at the end. Place the result in *NAME, which is malloc'd and/or realloc'd as necessary and can start out NULL, and whose size is passed and returned in *SIZE. Return the number of characters placed in *NAME if some nonempty sequence was found, otherwise 0. */ static int readname (name, size, stream) char **name; int *size; FILE *stream; { int c; int name_index = 0; if (*name == NULL) { *size = 10; *name = (char *) xmalloc (*size); } /* Skip blank space. */ while ((c = getc (stream)) != EOF && isspace (c)) /* Do nothing. */ ; while (c != EOF && !isspace (c)) { (*name)[name_index++] = c; while (name_index >= *size) { *size *= 2; *name = (char *) xrealloc (*name, *size); } c = getc (stream); } (*name)[name_index] = '\0'; return name_index; } #ifdef TEST main () { char *s; while (s = getusershell ()) puts (s); exit (0); } #endif sh-utils-1.10/lib/memcmp.c100666 74504 13 21715 5516610247 14511 0ustar meyeringuser/* Copyright (C) 1991, 1993 Free Software Foundation, Inc. Contributed by Torbjorn Granlund (tege@sics.se). The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. The GNU C Library 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 Library General Public License for more details. You should have received a copy of the GNU Library General Public License along with the GNU C Library; see the file COPYING.LIB. If not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #ifdef HAVE_CONFIG_H #include "config.h" #endif #undef __ptr_t #if defined (__cplusplus) || (defined (__STDC__) && __STDC__) #define __ptr_t void * #else /* Not C++ or ANSI C. */ #undef const #define const #define __ptr_t char * #endif /* C++ or ANSI C. */ #if defined (HAVE_STRING_H) || defined (_LIBC) #include #endif #ifdef _LIBC #include #else /* Not in the GNU C library. */ #include /* Type to use for aligned memory operations. This should normally be the biggest type supported by a single load and store. Must be an unsigned type. */ #define op_t unsigned long int #define OPSIZ (sizeof(op_t)) /* Threshold value for when to enter the unrolled loops. */ #define OP_T_THRES 16 /* Type to use for unaligned operations. */ typedef unsigned char byte; #ifndef WORDS_BIGENDIAN #define MERGE(w0, sh_1, w1, sh_2) (((w0) >> (sh_1)) | ((w1) << (sh_2))) #else #define MERGE(w0, sh_1, w1, sh_2) (((w0) << (sh_1)) | ((w1) >> (sh_2))) #endif #endif /* In the GNU C library. */ /* BE VERY CAREFUL IF YOU CHANGE THIS CODE! */ /* The strategy of this memcmp is: 1. Compare bytes until one of the block pointers is aligned. 2. Compare using memcmp_common_alignment or memcmp_not_common_alignment, regarding the alignment of the other block after the initial byte operations. The maximum number of full words (of type op_t) are compared in this way. 3. Compare the few remaining bytes. */ #ifndef WORDS_BIGENDIAN /* memcmp_bytes -- Compare A and B bytewise in the byte order of the machine. A and B are known to be different. This is needed only on little-endian machines. */ #ifdef __GNUC__ __inline #endif static int memcmp_bytes (a, b) op_t a, b; { long int srcp1 = (long int) &a; long int srcp2 = (long int) &b; op_t a0, b0; do { a0 = ((byte *) srcp1)[0]; b0 = ((byte *) srcp2)[0]; srcp1 += 1; srcp2 += 1; } while (a0 == b0); return a0 - b0; } #endif /* memcmp_common_alignment -- Compare blocks at SRCP1 and SRCP2 with LEN `op_t' objects (not LEN bytes!). Both SRCP1 and SRCP2 should be aligned for memory operations on `op_t's. */ #ifdef __GNUC__ __inline #endif static int memcmp_common_alignment (srcp1, srcp2, len) long int srcp1; long int srcp2; size_t len; { op_t a0, a1; op_t b0, b1; switch (len % 4) { case 2: a0 = ((op_t *) srcp1)[0]; b0 = ((op_t *) srcp2)[0]; srcp1 -= 2 * OPSIZ; srcp2 -= 2 * OPSIZ; len += 2; goto do1; case 3: a1 = ((op_t *) srcp1)[0]; b1 = ((op_t *) srcp2)[0]; srcp1 -= OPSIZ; srcp2 -= OPSIZ; len += 1; goto do2; case 0: if (OP_T_THRES <= 3 * OPSIZ && len == 0) return 0; a0 = ((op_t *) srcp1)[0]; b0 = ((op_t *) srcp2)[0]; goto do3; case 1: a1 = ((op_t *) srcp1)[0]; b1 = ((op_t *) srcp2)[0]; srcp1 += OPSIZ; srcp2 += OPSIZ; len -= 1; if (OP_T_THRES <= 3 * OPSIZ && len == 0) goto do0; /* Fall through. */ } do { a0 = ((op_t *) srcp1)[0]; b0 = ((op_t *) srcp2)[0]; if (a1 != b1) #ifdef WORDS_BIGENDIAN return a1 > b1 ? 1 : -1; #else return memcmp_bytes (a1, b1); #endif do3: a1 = ((op_t *) srcp1)[1]; b1 = ((op_t *) srcp2)[1]; if (a0 != b0) #ifdef WORDS_BIGENDIAN return a0 > b0 ? 1 : -1; #else return memcmp_bytes (a0, b0); #endif do2: a0 = ((op_t *) srcp1)[2]; b0 = ((op_t *) srcp2)[2]; if (a1 != b1) #ifdef WORDS_BIGENDIAN return a1 > b1 ? 1 : -1; #else return memcmp_bytes (a1, b1); #endif do1: a1 = ((op_t *) srcp1)[3]; b1 = ((op_t *) srcp2)[3]; if (a0 != b0) #ifdef WORDS_BIGENDIAN return a0 > b0 ? 1 : -1; #else return memcmp_bytes (a0, b0); #endif srcp1 += 4 * OPSIZ; srcp2 += 4 * OPSIZ; len -= 4; } while (len != 0); /* This is the right position for do0. Please don't move it into the loop. */ do0: if (a1 != b1) #ifdef WORDS_BIGENDIAN return a1 > b1 ? 1 : -1; #else return memcmp_bytes (a1, b1); #endif return 0; } /* memcmp_not_common_alignment -- Compare blocks at SRCP1 and SRCP2 with LEN `op_t' objects (not LEN bytes!). SRCP2 should be aligned for memory operations on `op_t', but SRCP1 *should be unaligned*. */ #ifdef __GNUC__ __inline #endif static int memcmp_not_common_alignment (srcp1, srcp2, len) long int srcp1; long int srcp2; size_t len; { op_t a0, a1, a2, a3; op_t b0, b1, b2, b3; op_t x; int shl, shr; /* Calculate how to shift a word read at the memory operation aligned srcp1 to make it aligned for comparison. */ shl = 8 * (srcp1 % OPSIZ); shr = 8 * OPSIZ - shl; /* Make SRCP1 aligned by rounding it down to the beginning of the `op_t' it points in the middle of. */ srcp1 &= -OPSIZ; switch (len % 4) { case 2: a1 = ((op_t *) srcp1)[0]; a2 = ((op_t *) srcp1)[1]; b2 = ((op_t *) srcp2)[0]; srcp1 -= 1 * OPSIZ; srcp2 -= 2 * OPSIZ; len += 2; goto do1; case 3: a0 = ((op_t *) srcp1)[0]; a1 = ((op_t *) srcp1)[1]; b1 = ((op_t *) srcp2)[0]; srcp2 -= 1 * OPSIZ; len += 1; goto do2; case 0: if (OP_T_THRES <= 3 * OPSIZ && len == 0) return 0; a3 = ((op_t *) srcp1)[0]; a0 = ((op_t *) srcp1)[1]; b0 = ((op_t *) srcp2)[0]; srcp1 += 1 * OPSIZ; goto do3; case 1: a2 = ((op_t *) srcp1)[0]; a3 = ((op_t *) srcp1)[1]; b3 = ((op_t *) srcp2)[0]; srcp1 += 2 * OPSIZ; srcp2 += 1 * OPSIZ; len -= 1; if (OP_T_THRES <= 3 * OPSIZ && len == 0) goto do0; /* Fall through. */ } do { a0 = ((op_t *) srcp1)[0]; b0 = ((op_t *) srcp2)[0]; x = MERGE(a2, shl, a3, shr); if (x != b3) #ifdef WORDS_BIGENDIAN return x > b3 ? 1 : -1; #else return memcmp_bytes (x, b3); #endif do3: a1 = ((op_t *) srcp1)[1]; b1 = ((op_t *) srcp2)[1]; x = MERGE(a3, shl, a0, shr); if (x != b0) #ifdef WORDS_BIGENDIAN return x > b0 ? 1 : -1; #else return memcmp_bytes (x, b0); #endif do2: a2 = ((op_t *) srcp1)[2]; b2 = ((op_t *) srcp2)[2]; x = MERGE(a0, shl, a1, shr); if (x != b1) #ifdef WORDS_BIGENDIAN return x > b1 ? 1 : -1; #else return memcmp_bytes (x, b1); #endif do1: a3 = ((op_t *) srcp1)[3]; b3 = ((op_t *) srcp2)[3]; x = MERGE(a1, shl, a2, shr); if (x != b2) #ifdef WORDS_BIGENDIAN return x > b2 ? 1 : -1; #else return memcmp_bytes (x, b2); #endif srcp1 += 4 * OPSIZ; srcp2 += 4 * OPSIZ; len -= 4; } while (len != 0); /* This is the right position for do0. Please don't move it into the loop. */ do0: x = MERGE(a2, shl, a3, shr); if (x != b3) #ifdef WORDS_BIGENDIAN return x > b3 ? 1 : -1; #else return memcmp_bytes (x, b3); #endif return 0; } int memcmp (s1, s2, len) const __ptr_t s1; const __ptr_t s2; size_t len; { op_t a0; op_t b0; long int srcp1 = (long int) s1; long int srcp2 = (long int) s2; op_t res; if (len >= OP_T_THRES) { /* There are at least some bytes to compare. No need to test for LEN == 0 in this alignment loop. */ while (srcp2 % OPSIZ != 0) { a0 = ((byte *) srcp1)[0]; b0 = ((byte *) srcp2)[0]; srcp1 += 1; srcp2 += 1; res = a0 - b0; if (res != 0) return res; len -= 1; } /* SRCP2 is now aligned for memory operations on `op_t'. SRCP1 alignment determines if we can do a simple, aligned compare or need to shuffle bits. */ if (srcp1 % OPSIZ == 0) res = memcmp_common_alignment (srcp1, srcp2, len / OPSIZ); else res = memcmp_not_common_alignment (srcp1, srcp2, len / OPSIZ); if (res != 0) return res; /* Number of bytes remaining in the interval [0..OPSIZ-1]. */ srcp1 += len & -OPSIZ; srcp2 += len & -OPSIZ; len %= OPSIZ; } /* There are just a few bytes to compare. Use byte memory operations. */ while (len != 0) { a0 = ((byte *) srcp1)[0]; b0 = ((byte *) srcp2)[0]; srcp1 += 1; srcp2 += 1; res = a0 - b0; if (res != 0) return res; len -= 1; } return 0; } sh-utils-1.10/lib/mktime.c100666 74504 1 21741 5527047746 14774 0ustar meyeringdaemon/* Copyright (C) 1993, 1994 Free Software Foundation, Inc. Contributed by Noel Cragg (noel@cs.oberlin.edu). This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. The GNU C Library 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 Library General Public License for more details. You should have received a copy of the GNU Library General Public License along with the GNU C Library; see the file COPYING.LIB. If not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ /* Define this to have a standalone program to test this implementation of mktime. */ /* #define DEBUG */ #ifdef HAVE_CONFIG_H #if defined (CONFIG_BROKETS) /* We use instead of "config.h" so that a compilation using -I. -I$srcdir will use ./config.h rather than $srcdir/config.h (which it would do because it found this file in $srcdir). */ #include #else #include "config.h" #endif #endif #include /* Some systems define `time_t' here. */ #include #ifndef __isleap /* Nonzero if YEAR is a leap year (every 4 years, except every 100th isn't, and every 400th is). */ #define __isleap(year) \ ((year) % 4 == 0 && ((year) % 100 != 0 || (year) % 400 == 0)) #endif #ifndef __P #if defined (__GNUC__) || (defined (__STDC__) && __STDC__) #define __P(args) args #else #define __P(args) () #endif /* GCC. */ #endif /* Not __P. */ /* How many days are in each month. */ const unsigned short int __mon_lengths[2][12] = { /* Normal years. */ { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }, /* Leap years. */ { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 } }; static int times_through_search; /* This library routine should never hang -- make sure we always return when we're searching for a value */ /* After testing this, the maximum number of iterations that I had on any number that I tried was 3! Not bad. mktime converts a `struct tm' (broken-down local time) into a `time_t'; it is the opposite of localtime. It is possible to put the following values out of range and have mktime compensate: tm_sec, tm_min, tm_hour, tm_mday, tm_year. The other values in the structure are ignored. */ #ifdef DEBUG #include #include int debugging_enabled = 0; /* Print the values in a `struct tm'. */ static void printtm (it) struct tm *it; { printf ("%d/%d/%d %d:%d:%d (%s) yday:%d f:%d o:%ld", it->tm_mon, it->tm_mday, it->tm_year, it->tm_hour, it->tm_min, it->tm_sec, it->tm_zone, it->tm_yday, it->tm_isdst, it->tm_gmtoff); } #endif static time_t dist_tm (t1, t2) struct tm *t1; struct tm *t2; { time_t distance = 0; unsigned long int v1, v2; int diff_flag = 0; v1 = v2 = 0; #define doit(x, secs) \ v1 += t1->x * secs; \ v2 += t2->x * secs; \ if (!diff_flag) \ { \ if (t1->x < t2->x) \ diff_flag = -1; \ else if (t1->x > t2->x) \ diff_flag = 1; \ } doit (tm_year, 31536000); /* Okay, not all years have 365 days. */ doit (tm_mon, 2592000); /* Okay, not all months have 30 days. */ doit (tm_mday, 86400); doit (tm_hour, 3600); doit (tm_min, 60); doit (tm_sec, 1); #undef doit /* We should also make sure that the sign of DISTANCE is correct -- if DIFF_FLAG is positive, the distance should be positive and vice versa. */ distance = (v1 > v2) ? (v1 - v2) : (v2 - v1); if (diff_flag < 0) distance = -distance; if (times_through_search > 20) /* Arbitrary # of calls, but makes sure we never hang if there's a problem with this algorithm. */ { distance = diff_flag; } /* We need this DIFF_FLAG business because it is forseeable that the distance may be zero when, in actuality, the two structures are different. This is usually the case when the dates are 366 days apart and one of the years is a leap year. */ if (distance == 0 && diff_flag) distance = 86400 * diff_flag; return distance; } /* Modified b-search -- make intelligent guesses as to where the time might lie along the timeline, assuming that our target time lies a linear distance (w/o considering time jumps of a particular region). Assume that time does not fluctuate at all along the timeline -- e.g., assume that a day will always take 86400 seconds, etc. -- and come up with a hypothetical value for the time_t representation of the struct tm TARGET, in relation to the guess variable -- it should be pretty close! */ static time_t search (target, producer) struct tm *target; struct tm *(*producer) __P ((const time_t *)); { struct tm *guess_tm; time_t guess = 0; time_t distance = 0; times_through_search = 0; do { guess += distance; times_through_search++; guess_tm = (*producer) (&guess); #ifdef DEBUG if (debugging_enabled) { printf ("guess %d == ", (int) guess); printtm (guess_tm); puts (""); } #endif /* Are we on the money? */ distance = dist_tm (target, guess_tm); } while (distance != 0); return guess; } /* Since this function will call localtime many times (and the user might be passing their `struct tm *' right from localtime, let's make a copy for ourselves and run the search on the copy. Also, we have to normalize *TIMEPTR because it's possible to call mktime with values that are out of range for a specific item (like Feb 30th). */ time_t _mktime_internal (timeptr, producer) struct tm *timeptr; struct tm *(*producer) __P ((const time_t *)); { struct tm private_mktime_struct_tm; /* Yes, users can get a ptr to this. */ struct tm *me; time_t result; me = &private_mktime_struct_tm; *me = *timeptr; #define normalize(foo,x,y,bar); \ while (me->foo < x) \ { \ me->bar--; \ me->foo = (y - (x - me->foo)); \ } \ while (me->foo > y) \ { \ me->bar++; \ me->foo = (x + (me->foo - y)); \ } normalize (tm_sec, 0, 59, tm_min); normalize (tm_min, 0, 59, tm_hour); normalize (tm_hour, 0, 23, tm_mday); /* Do the month first, so day range can be found. */ normalize (tm_mon, 0, 11, tm_year); normalize (tm_mday, 1, __mon_lengths[__isleap (me->tm_year)][me->tm_mon], tm_mon); /* Do the month again, because the day may have pushed it out of range. */ normalize (tm_mon, 0, 11, tm_year); /* Do the day again, because the month may have changed the range. */ normalize (tm_mday, 1, __mon_lengths[__isleap (me->tm_year)][me->tm_mon], tm_mon); #ifdef DEBUG if (debugging_enabled) { printf ("After normalizing: "); printtm (me); puts ("\n"); } #endif result = search (me, producer); *timeptr = *me; return result; } time_t mktime (timeptr) struct tm *timeptr; { return _mktime_internal (timeptr, localtime); } #ifdef DEBUG void main (argc, argv) int argc; char *argv[]; { int time; int result_time; struct tm *tmptr; if (argc == 1) { long q; printf ("starting long test...\n"); for (q = 10000000; q < 1000000000; q++) { struct tm *tm = localtime (&q); if ((q % 10000) == 0) { printf ("%ld\n", q); fflush (stdout); } if (q != mktime (tm)) { printf ("failed for %ld\n", q); fflush (stdout); } } printf ("test finished\n"); exit (0); } if (argc != 2) { printf ("wrong # of args\n"); exit (0); } debugging_enabled = 1; /* We want to see the info */ ++argv; time = atoi (*argv); printf ("Time: %d %s\n", time, ctime ((time_t *) &time)); tmptr = localtime ((time_t *) &time); printf ("localtime returns: "); printtm (tmptr); printf ("\n"); printf ("mktime: %d\n\n", (int) mktime (tmptr)); tmptr->tm_sec -= 20; tmptr->tm_min -= 20; tmptr->tm_hour -= 20; tmptr->tm_mday -= 20; tmptr->tm_mon -= 20; tmptr->tm_year -= 20; tmptr->tm_gmtoff -= 20000; /* This has no effect! */ tmptr->tm_zone = NULL; /* Nor does this! */ tmptr->tm_isdst = -1; printf ("changed ranges: "); printtm (tmptr); printf ("\n\n"); result_time = mktime (tmptr); printf ("\nmktime: %d\n", result_time); } #endif /* DEBUG */ sh-utils-1.10/lib/stime.c100666 74504 13 2571 5456435001 14327 0ustar meyeringuser/* stime -- set the system clock Copyright (C) 1989, 1991 Free Software Foundation, Inc. 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 2, 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, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ /* David MacKenzie */ #ifdef HAVE_CONFIG_H #if defined (CONFIG_BROKETS) /* We use instead of "config.h" so that a compilation using -I. -I$srcdir will use ./config.h rather than $srcdir/config.h (which it would do because it found this file in $srcdir). */ #include #else #include "config.h" #endif #endif #include #include /* Set the system time to *WHEN seconds past the start of 1970 GMT. */ int stime (when) time_t *when; { struct timeval tv; tv.tv_sec = *when; tv.tv_usec = 0; return settimeofday (&tv, (struct timezone *) 0); } sh-utils-1.10/lib/strcspn.c100666 74504 13 2714 5456434476 14720 0ustar meyeringuser/* Copyright (C) 1991 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. The GNU C Library 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 Library General Public License for more details. You should have received a copy of the GNU Library General Public License along with the GNU C Library; see the file COPYING.LIB. If not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #ifdef HAVE_CONFIG_H #if defined (CONFIG_BROKETS) /* We use instead of "config.h" so that a compilation using -I. -I$srcdir will use ./config.h rather than $srcdir/config.h (which it would do because it found this file in $srcdir). */ #include #else #include "config.h" #endif #endif char *index (); /* Return the length of the maximum inital segment of S which contains no characters from REJECT. */ int strcspn (s, reject) register char *s; register char *reject; { register int count = 0; while (*s != '\0') if (index (reject, *s++) == 0) ++count; else return count; return count; } sh-utils-1.10/lib/strstr.c100666 21570 13 2554 5041712220 13465 0ustar djmuser/* strstr.c -- return the offset of one string within another Copyright (C) 1989, 1990 Free Software Foundation, Inc. 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 2, 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, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ /* Author: Mike Rendell Department of Computer Science michael@garfield.mun.edu Memorial University of Newfoundland ..!uunet!garfield!michael St. John's, Nfld., Canada (709) 737-4550 A1C 5S7 */ /* Return the starting address of string S2 in S1; return 0 if it is not found. */ char * strstr (s1, s2) char *s1; char *s2; { int i; char *p1; char *p2; char *s = s1; for (p2 = s2, i = 0; *s; p2 = s2, i++, s++) { for (p1 = s; *p1 && *p2 && *p1 == *p2; p1++, p2++) ; if (!*p2) break; } if (!*p2) return s1 + i; return 0; } sh-utils-1.10/lib/strtol.c100666 74504 13 10410 5464253242 14550 0ustar meyeringuser/* Copyright (C) 1991, 1992 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. The GNU C Library 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 Library General Public License for more details. You should have received a copy of the GNU Library General Public License along with the GNU C Library; see the file COPYING.LIB. If not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #ifdef HAVE_CONFIG_H #if defined (CONFIG_BROKETS) /* We use instead of "config.h" so that a compilation using -I. -I$srcdir will use ./config.h rather than $srcdir/config.h (which it would do because it found this file in $srcdir). */ #include #else #include "config.h" #endif #endif #include #include #if HAVE_LIMITS_H #include #endif #ifndef ULONG_MAX #define ULONG_MAX ((unsigned long) ~(unsigned long) 0) #endif #ifndef LONG_MAX #define LONG_MAX (~(1 << (sizeof (long) * 8 - 1))) #endif #ifndef LONG_MIN #define LONG_MIN (-LONG_MAX - 1) #endif #if STDC_HEADERS #include #include #else #define NULL 0 extern int errno; #endif #ifndef UNSIGNED #define UNSIGNED 0 #endif /* Convert NPTR to an `unsigned long int' or `long int' in base BASE. If BASE is 0 the base is determined by the presence of a leading zero, indicating octal or a leading "0x" or "0X", indicating hexadecimal. If BASE is < 2 or > 36, it is reset to 10. If ENDPTR is not NULL, a pointer to the character after the last one converted is stored in *ENDPTR. */ #if UNSIGNED unsigned long int #define strtol strtoul #else long int #endif strtol (nptr, endptr, base) const char *nptr; char **endptr; int base; { int negative; register unsigned long int cutoff; register unsigned int cutlim; register unsigned long int i; register const char *s; register unsigned char c; const char *save; int overflow; if (base < 0 || base == 1 || base > 36) base = 10; s = nptr; /* Skip white space. */ while (isspace (*s)) ++s; if (*s == '\0') goto noconv; /* Check for a sign. */ if (*s == '-') { negative = 1; ++s; } else if (*s == '+') { negative = 0; ++s; } else negative = 0; if (base == 16 && s[0] == '0' && toupper (s[1]) == 'X') s += 2; /* If BASE is zero, figure it out ourselves. */ if (base == 0) { if (*s == '0') { if (toupper (s[1]) == 'X') { s += 2; base = 16; } else base = 8; } else base = 10; } /* Save the pointer so we can check later if anything happened. */ save = s; cutoff = ULONG_MAX / (unsigned long int) base; cutlim = ULONG_MAX % (unsigned long int) base; overflow = 0; i = 0; for (c = *s; c != '\0'; c = *++s) { if (isdigit (c)) c -= '0'; else if (isalpha (c)) c = toupper (c) - 'A' + 10; else break; if (c >= base) break; /* Check for overflow. */ if (i > cutoff || (i == cutoff && c > cutlim)) overflow = 1; else { i *= (unsigned long int) base; i += c; } } /* Check if anything actually happened. */ if (s == save) goto noconv; /* Store in ENDPTR the address of one character past the last character we converted. */ if (endptr != NULL) *endptr = (char *) s; #if !UNSIGNED /* Check for a value that is within the range of `unsigned long int', but outside the range of `long int'. */ if (i > (negative ? -(unsigned long int) LONG_MIN : (unsigned long int) LONG_MAX)) overflow = 1; #endif if (overflow) { errno = ERANGE; #if UNSIGNED return ULONG_MAX; #else return negative ? LONG_MIN : LONG_MAX; #endif } /* Return the result of the appropriate sign. */ return (negative ? -i : i); noconv:; /* There was no number to convert. */ if (endptr != NULL) *endptr = (char *) nptr; return 0L; } sh-utils-1.10/lib/strtoul.c100666 21570 13 1541 5253750141 13644 0ustar djmuser/* Copyright (C) 1991 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. The GNU C Library 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 Library General Public License for more details. You should have received a copy of the GNU Library General Public License along with the GNU C Library; see the file COPYING.LIB. If not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #define UNSIGNED 1 #include "strtol.c" sh-utils-1.10/lib/strtod.c100666 74504 1 11231 5506162765 15012 0ustar meyeringdaemon/* Copyright (C) 1991, 1992 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. The GNU C Library 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 Library General Public License for more details. You should have received a copy of the GNU Library General Public License along with the GNU C Library; see the file COPYING.LIB. If not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #ifdef HAVE_CONFIG_H #if defined (CONFIG_BROKETS) /* We use instead of "config.h" so that a compilation using -I. -I$srcdir will use ./config.h rather than $srcdir/config.h (which it would do because it found this file in $srcdir). */ #include #else #include "config.h" #endif #endif #include #include #include #ifdef HAVE_FLOAT_H #include #else #define DBL_MAX 1.7976931348623159e+308 #define DBL_MIN 2.2250738585072010e-308 #endif #if STDC_HEADERS #include #include #else #define NULL 0 extern int errno; #ifndef HUGE_VAL #define HUGE_VAL HUGE #endif #endif /* Convert NPTR to a double. If ENDPTR is not NULL, a pointer to the character after the last one used in the number is put in *ENDPTR. */ double strtod (nptr, endptr) const char *nptr; char **endptr; { register const char *s; short int sign; /* The number so far. */ double num; int got_dot; /* Found a decimal point. */ int got_digit; /* Seen any digits. */ /* The exponent of the number. */ long int exponent; if (nptr == NULL) { errno = EINVAL; goto noconv; } s = nptr; /* Eat whitespace. */ while (isspace (*s)) ++s; /* Get the sign. */ sign = *s == '-' ? -1 : 1; if (*s == '-' || *s == '+') ++s; num = 0.0; got_dot = 0; got_digit = 0; exponent = 0; for (;; ++s) { if (isdigit (*s)) { got_digit = 1; /* Make sure that multiplication by 10 will not overflow. */ if (num > DBL_MAX * 0.1) /* The value of the digit doesn't matter, since we have already gotten as many digits as can be represented in a `double'. This doesn't necessarily mean the result will overflow. The exponent may reduce it to within range. We just need to record that there was another digit so that we can multiply by 10 later. */ ++exponent; else num = (num * 10.0) + (*s - '0'); /* Keep track of the number of digits after the decimal point. If we just divided by 10 here, we would lose precision. */ if (got_dot) --exponent; } else if (!got_dot && *s == '.') /* Record that we have found the decimal point. */ got_dot = 1; else /* Any other character terminates the number. */ break; } if (!got_digit) goto noconv; if (tolower (*s) == 'e') { /* Get the exponent specified after the `e' or `E'. */ int save = errno; char *end; long int exp; errno = 0; ++s; exp = strtol (s, &end, 10); if (errno == ERANGE) { /* The exponent overflowed a `long int'. It is probably a safe assumption that an exponent that cannot be represented by a `long int' exceeds the limits of a `double'. */ if (endptr != NULL) *endptr = end; if (exp < 0) goto underflow; else goto overflow; } else if (end == s) /* There was no exponent. Reset END to point to the 'e' or 'E', so *ENDPTR will be set there. */ end = (char *) s - 1; errno = save; s = end; exponent += exp; } if (endptr != NULL) *endptr = (char *) s; if (num == 0.0) return 0.0; /* Multiply NUM by 10 to the EXPONENT power, checking for overflow and underflow. */ if (exponent < 0) { if (num < DBL_MIN * pow (10.0, (double) -exponent)) goto underflow; } else if (exponent > 0) { if (num > DBL_MAX * pow (10.0, (double) -exponent)) goto overflow; } num *= pow (10.0, (double) exponent); return num * sign; overflow: /* Return an overflow error. */ errno = ERANGE; return HUGE_VAL * sign; underflow: /* Return an underflow error. */ if (endptr != NULL) *endptr = (char *) nptr; errno = ERANGE; return 0.0; noconv: /* There was no number. */ if (endptr != NULL) *endptr = (char *) nptr; return 0.0; } sh-utils-1.10/lib/alloca.c100444 21570 1 33333 5563566260 13656 0ustar djmdaemon/* alloca.c -- allocate automatically reclaimed memory (Mostly) portable public-domain implementation -- D A Gwyn This implementation of the PWB library alloca function, which is used to allocate space off the run-time stack so that it is automatically reclaimed upon procedure exit, was inspired by discussions with J. Q. Johnson of Cornell. J.Otto Tennant contributed the Cray support. There are some preprocessor constants that can be defined when compiling for your specific system, for improved efficiency; however, the defaults should be okay. The general concept of this implementation is to keep track of all alloca-allocated blocks, and reclaim any that are found to be deeper in the stack than the current invocation. This heuristic does not reclaim storage as soon as it becomes invalid, but it will do so eventually. As a special case, alloca(0) reclaims storage without allocating any. It is a good idea to use alloca(0) in your main control loop, etc. to force garbage collection. */ #ifdef HAVE_CONFIG_H #if defined (emacs) || defined (CONFIG_BROKETS) #include #else #include "config.h" #endif #endif /* If compiling with GCC 2, this file's not needed. */ #if !defined (__GNUC__) || __GNUC__ < 2 /* If someone has defined alloca as a macro, there must be some other way alloca is supposed to work. */ #ifndef alloca #ifdef emacs #ifdef static /* actually, only want this if static is defined as "" -- this is for usg, in which emacs must undefine static in order to make unexec workable */ #ifndef STACK_DIRECTION you lose -- must know STACK_DIRECTION at compile-time #endif /* STACK_DIRECTION undefined */ #endif /* static */ #endif /* emacs */ /* If your stack is a linked list of frames, you have to provide an "address metric" ADDRESS_FUNCTION macro. */ #if defined (CRAY) && defined (CRAY_STACKSEG_END) long i00afunc (); #define ADDRESS_FUNCTION(arg) (char *) i00afunc (&(arg)) #else #define ADDRESS_FUNCTION(arg) &(arg) #endif #if __STDC__ typedef void *pointer; #else typedef char *pointer; #endif #define NULL 0 /* Different portions of Emacs need to call different versions of malloc. The Emacs executable needs alloca to call xmalloc, because ordinary malloc isn't protected from input signals. On the other hand, the utilities in lib-src need alloca to call malloc; some of them are very simple, and don't have an xmalloc routine. Non-Emacs programs expect this to call use xmalloc. Callers below should use malloc. */ #ifndef emacs #define malloc xmalloc #endif extern pointer malloc (); /* Define STACK_DIRECTION if you know the direction of stack growth for your system; otherwise it will be automatically deduced at run-time. STACK_DIRECTION > 0 => grows toward higher addresses STACK_DIRECTION < 0 => grows toward lower addresses STACK_DIRECTION = 0 => direction of growth unknown */ #ifndef STACK_DIRECTION #define STACK_DIRECTION 0 /* Direction unknown. */ #endif #if STACK_DIRECTION != 0 #define STACK_DIR STACK_DIRECTION /* Known at compile-time. */ #else /* STACK_DIRECTION == 0; need run-time code. */ static int stack_dir; /* 1 or -1 once known. */ #define STACK_DIR stack_dir static void find_stack_direction () { static char *addr = NULL; /* Address of first `dummy', once known. */ auto char dummy; /* To get stack address. */ if (addr == NULL) { /* Initial entry. */ addr = ADDRESS_FUNCTION (dummy); find_stack_direction (); /* Recurse once. */ } else { /* Second entry. */ if (ADDRESS_FUNCTION (dummy) > addr) stack_dir = 1; /* Stack grew upward. */ else stack_dir = -1; /* Stack grew downward. */ } } #endif /* STACK_DIRECTION == 0 */ /* An "alloca header" is used to: (a) chain together all alloca'ed blocks; (b) keep track of stack depth. It is very important that sizeof(header) agree with malloc alignment chunk size. The following default should work okay. */ #ifndef ALIGN_SIZE #define ALIGN_SIZE sizeof(double) #endif typedef union hdr { char align[ALIGN_SIZE]; /* To force sizeof(header). */ struct { union hdr *next; /* For chaining headers. */ char *deep; /* For stack depth measure. */ } h; } header; static header *last_alloca_header = NULL; /* -> last alloca header. */ /* Return a pointer to at least SIZE bytes of storage, which will be automatically reclaimed upon exit from the procedure that called alloca. Originally, this space was supposed to be taken from the current stack frame of the caller, but that method cannot be made to work for some implementations of C, for example under Gould's UTX/32. */ pointer alloca (size) unsigned size; { auto char probe; /* Probes stack depth: */ register char *depth = ADDRESS_FUNCTION (probe); #if STACK_DIRECTION == 0 if (STACK_DIR == 0) /* Unknown growth direction. */ find_stack_direction (); #endif /* Reclaim garbage, defined as all alloca'd storage that was allocated from deeper in the stack than currently. */ { register header *hp; /* Traverses linked list. */ for (hp = last_alloca_header; hp != NULL;) if ((STACK_DIR > 0 && hp->h.deep > depth) || (STACK_DIR < 0 && hp->h.deep < depth)) { register header *np = hp->h.next; free ((pointer) hp); /* Collect garbage. */ hp = np; /* -> next header. */ } else break; /* Rest are not deeper. */ last_alloca_header = hp; /* -> last valid storage. */ } if (size == 0) return NULL; /* No allocation required. */ /* Allocate combined header + user data storage. */ { register pointer new = malloc (sizeof (header) + size); /* Address of header. */ ((header *) new)->h.next = last_alloca_header; ((header *) new)->h.deep = depth; last_alloca_header = (header *) new; /* User storage begins just after header. */ return (pointer) ((char *) new + sizeof (header)); } } #if defined (CRAY) && defined (CRAY_STACKSEG_END) #ifdef DEBUG_I00AFUNC #include #endif #ifndef CRAY_STACK #define CRAY_STACK #ifndef CRAY2 /* Stack structures for CRAY-1, CRAY X-MP, and CRAY Y-MP */ struct stack_control_header { long shgrow:32; /* Number of times stack has grown. */ long shaseg:32; /* Size of increments to stack. */ long shhwm:32; /* High water mark of stack. */ long shsize:32; /* Current size of stack (all segments). */ }; /* The stack segment linkage control information occurs at the high-address end of a stack segment. (The stack grows from low addresses to high addresses.) The initial part of the stack segment linkage control information is 0200 (octal) words. This provides for register storage for the routine which overflows the stack. */ struct stack_segment_linkage { long ss[0200]; /* 0200 overflow words. */ long sssize:32; /* Number of words in this segment. */ long ssbase:32; /* Offset to stack base. */ long:32; long sspseg:32; /* Offset to linkage control of previous segment of stack. */ long:32; long sstcpt:32; /* Pointer to task common address block. */ long sscsnm; /* Private control structure number for microtasking. */ long ssusr1; /* Reserved for user. */ long ssusr2; /* Reserved for user. */ long sstpid; /* Process ID for pid based multi-tasking. */ long ssgvup; /* Pointer to multitasking thread giveup. */ long sscray[7]; /* Reserved for Cray Research. */ long ssa0; long ssa1; long ssa2; long ssa3; long ssa4; long ssa5; long ssa6; long ssa7; long sss0; long sss1; long sss2; long sss3; long sss4; long sss5; long sss6; long sss7; }; #else /* CRAY2 */ /* The following structure defines the vector of words returned by the STKSTAT library routine. */ struct stk_stat { long now; /* Current total stack size. */ long maxc; /* Amount of contiguous space which would be required to satisfy the maximum stack demand to date. */ long high_water; /* Stack high-water mark. */ long overflows; /* Number of stack overflow ($STKOFEN) calls. */ long hits; /* Number of internal buffer hits. */ long extends; /* Number of block extensions. */ long stko_mallocs; /* Block allocations by $STKOFEN. */ long underflows; /* Number of stack underflow calls ($STKRETN). */ long stko_free; /* Number of deallocations by $STKRETN. */ long stkm_free; /* Number of deallocations by $STKMRET. */ long segments; /* Current number of stack segments. */ long maxs; /* Maximum number of stack segments so far. */ long pad_size; /* Stack pad size. */ long current_address; /* Current stack segment address. */ long current_size; /* Current stack segment size. This number is actually corrupted by STKSTAT to include the fifteen word trailer area. */ long initial_address; /* Address of initial segment. */ long initial_size; /* Size of initial segment. */ }; /* The following structure describes the data structure which trails any stack segment. I think that the description in 'asdef' is out of date. I only describe the parts that I am sure about. */ struct stk_trailer { long this_address; /* Address of this block. */ long this_size; /* Size of this block (does not include this trailer). */ long unknown2; long unknown3; long link; /* Address of trailer block of previous segment. */ long unknown5; long unknown6; long unknown7; long unknown8; long unknown9; long unknown10; long unknown11; long unknown12; long unknown13; long unknown14; }; #endif /* CRAY2 */ #endif /* not CRAY_STACK */ #ifdef CRAY2 /* Determine a "stack measure" for an arbitrary ADDRESS. I doubt that "lint" will like this much. */ static long i00afunc (long *address) { struct stk_stat status; struct stk_trailer *trailer; long *block, size; long result = 0; /* We want to iterate through all of the segments. The first step is to get the stack status structure. We could do this more quickly and more directly, perhaps, by referencing the $LM00 common block, but I know that this works. */ STKSTAT (&status); /* Set up the iteration. */ trailer = (struct stk_trailer *) (status.current_address + status.current_size - 15); /* There must be at least one stack segment. Therefore it is a fatal error if "trailer" is null. */ if (trailer == 0) abort (); /* Discard segments that do not contain our argument address. */ while (trailer != 0) { block = (long *) trailer->this_address; size = trailer->this_size; if (block == 0 || size == 0) abort (); trailer = (struct stk_trailer *) trailer->link; if ((block <= address) && (address < (block + size))) break; } /* Set the result to the offset in this segment and add the sizes of all predecessor segments. */ result = address - block; if (trailer == 0) { return result; } do { if (trailer->this_size <= 0) abort (); result += trailer->this_size; trailer = (struct stk_trailer *) trailer->link; } while (trailer != 0); /* We are done. Note that if you present a bogus address (one not in any segment), you will get a different number back, formed from subtracting the address of the first block. This is probably not what you want. */ return (result); } #else /* not CRAY2 */ /* Stack address function for a CRAY-1, CRAY X-MP, or CRAY Y-MP. Determine the number of the cell within the stack, given the address of the cell. The purpose of this routine is to linearize, in some sense, stack addresses for alloca. */ static long i00afunc (long address) { long stkl = 0; long size, pseg, this_segment, stack; long result = 0; struct stack_segment_linkage *ssptr; /* Register B67 contains the address of the end of the current stack segment. If you (as a subprogram) store your registers on the stack and find that you are past the contents of B67, you have overflowed the segment. B67 also points to the stack segment linkage control area, which is what we are really interested in. */ stkl = CRAY_STACKSEG_END (); ssptr = (struct stack_segment_linkage *) stkl; /* If one subtracts 'size' from the end of the segment, one has the address of the first word of the segment. If this is not the first segment, 'pseg' will be nonzero. */ pseg = ssptr->sspseg; size = ssptr->sssize; this_segment = stkl - size; /* It is possible that calling this routine itself caused a stack overflow. Discard stack segments which do not contain the target address. */ while (!(this_segment <= address && address <= stkl)) { #ifdef DEBUG_I00AFUNC fprintf (stderr, "%011o %011o %011o\n", this_segment, address, stkl); #endif if (pseg == 0) break; stkl = stkl - pseg; ssptr = (struct stack_segment_linkage *) stkl; size = ssptr->sssize; pseg = ssptr->sspseg; this_segment = stkl - size; } result = address - this_segment; /* If you subtract pseg from the current end of the stack, you get the address of the previous stack segment's end. This seems a little convoluted to me, but I'll bet you save a cycle somewhere. */ while (pseg != 0) { #ifdef DEBUG_I00AFUNC fprintf (stderr, "%011o %011o\n", pseg, size); #endif stkl = stkl - pseg; ssptr = (struct stack_segment_linkage *) stkl; size = ssptr->sssize; pseg = ssptr->sspseg; result += size; } return (result); } #endif /* not CRAY2 */ #endif /* CRAY */ #endif /* no alloca */ #endif /* not GCC version 2 */ sh-utils-1.10/lib/xgetcwd.c100666 74504 13 4212 5456545330 14654 0ustar meyeringuser/* xgetcwd.c -- return current directory with unlimited length Copyright (C) 1992 Free Software Foundation, Inc. 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 2, 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, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ /* Written by David MacKenzie, djm@gnu.ai.mit.edu. */ #ifdef HAVE_CONFIG_H #if defined (CONFIG_BROKETS) /* We use instead of "config.h" so that a compilation using -I. -I$srcdir will use ./config.h rather than $srcdir/config.h (which it would do because it found this file in $srcdir). */ #include #else #include "config.h" #endif #endif #include #include #ifndef errno extern int errno; #endif #include #include "pathmax.h" #if !defined(_POSIX_VERSION) && !defined(HAVE_GETCWD) char *getwd (); #define getcwd(buf, max) getwd (buf) #else char *getcwd (); #endif /* Amount to increase buffer size by in each try. */ #define PATH_INCR 32 char *xmalloc (); char *xrealloc (); void free (); /* Return the current directory, newly allocated, arbitrarily long. Return NULL and set errno on error. */ char * xgetcwd () { char *cwd; char *ret; unsigned path_max; errno = 0; path_max = (unsigned) PATH_MAX; path_max += 2; /* The getcwd docs say to do this. */ cwd = xmalloc (path_max); errno = 0; while ((ret = getcwd (cwd, path_max)) == NULL && errno == ERANGE) { path_max += PATH_INCR; cwd = xrealloc (cwd, path_max); errno = 0; } if (ret == NULL) { int save_errno = errno; free (cwd); errno = save_errno; return NULL; } return cwd; } sh-utils-1.10/lib/xgethostname.c100644 74504 1 3243 5565053205 16152 0ustar meyeringdaemon/* xgethostname.c -- return current hostname with unlimited length Copyright (C) 1992 Free Software Foundation, Inc. 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 2, 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, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ /* Written by Jim Meyering, meyering@comco.com */ #ifdef HAVE_CONFIG_H #if defined (CONFIG_BROKETS) /* We use instead of "config.h" so that a compilation using -I. -I$srcdir will use ./config.h rather than $srcdir/config.h (which it would do because it found this file in $srcdir). */ #include #else #include "config.h" #endif #endif #include int gethostname (); char *xmalloc (); char *xrealloc (); #ifndef INITIAL_HOSTNAME_LENGTH #define INITIAL_HOSTNAME_LENGTH 33 #endif char * xgethostname () { char *hostname; size_t size; int err; size = INITIAL_HOSTNAME_LENGTH; hostname = xmalloc (size); while (1) { hostname[size - 1] = '\0'; err = gethostname (hostname, size); if (err == 0 && hostname[size - 1] == '\0') break; size *= 2; hostname = xrealloc (hostname, size); } return hostname; } sh-utils-1.10/src/ 40777 74504 1 0 5566761516 13242 5ustar meyeringdaemonsh-utils-1.10/src/Makefile.in100666 74504 1 15417 5566761064 15432 0ustar meyeringdaemon# Makefile for GNU shell utilities programs. # Copyright (C) 1991, 1992, 1993, 1994 Free Software Foundation, Inc. # 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 2, 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, write to the Free Software # Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. SHELL = /bin/sh srcdir = @srcdir@ VPATH = @srcdir@ prefix = /usr/local exec_prefix = $(prefix) bindir = $(exec_prefix)/bin binprefix = INSTALL = @INSTALL@ INSTALL_PROGRAM = @INSTALL_PROGRAM@ CC = @CC@ DEFS = -DCONFIG_BROKETS @DEFS@ LIBS = @LIBS@ CFLAGS = @CFLAGS@ LDFLAGS = @LDFLAGS@ SOURCES = basename.c date.c dirname.c echo.c env.c expr.c id.c hostname.c \ logname.c long-options.c pathchk.c printenv.c printf.c pwd.c sleep.c su.c \ tee.c test.c tty.c who.c whoami.c yes.c nice.c stty.c uname.c version.c OBJECTS = basename.o date.o dirname.o echo.o env.o expr.o id.o hostname.o \ logname.o long-options.o pathchk.o printenv.o printf.o pwd.o sleep.o su.o \ tee.o test.o tty.o users.o who.o whoami.o yes.o nice.o stty.o uname.o \ version.o DISTFILES = Makefile.in system.h $(SOURCES) groups.sh nohup.sh \ false.sh true.sh version.h long-options.h PROGS = basename date dirname echo env expr false groups hostname id logname \ pathchk printenv printf pwd sleep tee test true tty users who whoami yes @PROGS@ all: $(PROGS) su incl = -I.. -I$(srcdir) -I$(srcdir)/../lib .c.o: $(CC) -c $(CPPFLAGS) $(DEFS) $(incl) $(CFLAGS) $< Makefile: ../config.status Makefile.in CONFIG_FILES=$@ CONFIG_HEADERS= ../config.status users.o: users.c $(CC) -c $(CPPFLAGS) -DUSERS $(DEFS) $(incl) $(CFLAGS) $< users.c: who.c rm -f users.c ln $(srcdir)/who.c users.c >/dev/null 2>&1 \ || cp $(srcdir)/who.c users.c who.o: who.c $(CC) -c $(CPPFLAGS) -DWHO $(DEFS) $(incl) $(CFLAGS) $< install: all for f in $(PROGS); do \ $(INSTALL_PROGRAM) $$f $(bindir)/$(binprefix)$$f; \ done rm -f $(bindir)/'['; ln $(bindir)/$(binprefix)test $(bindir)/'[' @if test `./id -u` = 0; then \ echo you are root, so installing su; \ $(INSTALL_PROGRAM) su $(bindir)/$(binprefix)su; \ chown root $(bindir)/$(binprefix)su; \ chmod 4755 $(bindir)/$(binprefix)su; \ else echo WARNING: you are not root, so not installing su; fi uninstall: for f in $(PROGS) su; do rm -f $(bindir)/$(binprefix)$$f; done rm -f $(bindir)/'[' TAGS: $(SOURCES) etags $(SOURCES) check: clean: rm -f $(PROGS) su *.o core '[' .version mostlyclean: clean distclean: clean rm -f Makefile ./users.c realclean: distclean rm -f TAGS dist: $(DISTFILES) ln $(DISTFILES) ../`cat ../.fname`/src .version: version.c sed -e '/version_string/!d' \ -e 's/[^"]*"\([^"]*\)".*/\1/' \ -e q $(srcdir)/version.c \ > $@-t mv $@-t $@ $(PROGS) su: ../lib/libshu.a version.o link_command = $(CC) $(CFLAGS) $(LDFLAGS) -o $@ basename: basename.o long-options.o $(link_command) basename.o long-options.o \ ../lib/libshu.a version.o $(LIBS) date: date.o $(link_command) date.o ../lib/libshu.a version.o $(LIBS) dirname: dirname.o long-options.o $(link_command) dirname.o long-options.o \ ../lib/libshu.a version.o $(LIBS) echo: echo.o long-options.o $(link_command) echo.o long-options.o ../lib/libshu.a version.o $(LIBS) env: env.o $(link_command) env.o ../lib/libshu.a version.o $(LIBS) expr: expr.o long-options.o $(link_command) expr.o long-options.o ../lib/libshu.a version.o $(LIBS) false: false.sh .version rm -f $@ $@-t sed -e "s/@VERSION@/`cat .version`/" $(srcdir)/false.sh \ > $@-t mv $@-t $@ chmod +x $@ groups: groups.sh .version rm -f $@ $@-t sed -e "s,@bindir@,$(bindir),g" \ -e "s/@VERSION@/`cat .version`/" $(srcdir)/groups.sh \ > $@-t mv $@-t $@ chmod +x $@ hostname: hostname.o long-options.o $(link_command) hostname.o long-options.o ../lib/libshu.a version.o $(LIBS) id: id.o $(link_command) id.o ../lib/libshu.a version.o $(LIBS) logname: logname.o $(link_command) logname.o ../lib/libshu.a version.o $(LIBS) nohup: nohup.sh .version rm -f $@ $@-t sed -e "s,@bindir@,$(bindir),g" \ -e "s/@VERSION@/`cat .version`/" $(srcdir)/nohup.sh \ > $@-t mv $@-t $@ chmod +x $@ pathchk: pathchk.o $(link_command) pathchk.o ../lib/libshu.a version.o $(LIBS) printenv: printenv.o $(link_command) printenv.o ../lib/libshu.a version.o $(LIBS) # Link with -lm in case strtod.o needs to get `pow'. printf: printf.o long-options.o $(link_command) printf.o long-options.o ../lib/libshu.a version.o $(LIBS) -lm pwd: pwd.o long-options.o $(link_command) pwd.o long-options.o ../lib/libshu.a version.o $(LIBS) sleep: sleep.o $(link_command) sleep.o ../lib/libshu.a version.o $(LIBS) su: su.o $(link_command) su.o ../lib/libshu.a version.o $(LIBS) tee: tee.o $(link_command) tee.o ../lib/libshu.a version.o $(LIBS) test: test.o long-options.o $(link_command) test.o long-options.o ../lib/libshu.a version.o $(LIBS) true: true.sh .version rm -f $@ $@-t sed -e "s/@VERSION@/`cat .version`/" $(srcdir)/true.sh \ > $@-t mv $@-t $@ chmod +x $@ tty: tty.o $(link_command) tty.o ../lib/libshu.a version.o $(LIBS) users: users.o $(link_command) users.o ../lib/libshu.a version.o $(LIBS) who: who.o $(link_command) who.o ../lib/libshu.a version.o $(LIBS) whoami: whoami.o $(link_command) whoami.o ../lib/libshu.a version.o $(LIBS) yes: yes.o long-options.o $(link_command) yes.o long-options.o ../lib/libshu.a version.o $(LIBS) nice: nice.o $(link_command) nice.o ../lib/libshu.a version.o $(LIBS) stty: stty.o long-options.o $(link_command) stty.o long-options.o ../lib/libshu.a version.o $(LIBS) uname: uname.o $(link_command) uname.o ../lib/libshu.a version.o $(LIBS) # Special rules for some .o files. su.o: su.c $(CC) -c $(CPPFLAGS) -DSYSLOG_FAILURE -DSYSLOG_SUCCESS $(DEFS) \ $(incl) $(CFLAGS) $(srcdir)/su.c test.o: test.c $(CC) -c $(CPPFLAGS) -DTEST_STANDALONE $(DEFS) \ $(incl) $(CFLAGS) $(srcdir)/test.c env.o id.o nice.o pathchk.o stty.o su.o tty.o uname.o users.o who.o: ../lib/getopt.h expr.o: ../lib/regex.h # Make all .o files depend on these files even though there are a few # unnecessary dependencies. $(OBJECTS): ../config.h system.h version.h echo.o expr.o hostname.o printf.o pwd.o test.o yes.o: long-options.h basename.o dirname.o stty.o: long-options.h long-options.o: long-options.h # Tell versions [3.59,3.63) of GNU make not to export all variables. # Otherwise a system limit (for SysV at least) may be exceeded. .NOEXPORT: sh-utils-1.10/src/system.h100666 74504 13 6305 5523461577 14573 0ustar meyeringuser/* system-dependent definitions for shellutils programs. Copyright (C) 89, 91, 92, 93, 1994 Free Software Foundation, Inc. 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 2, 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, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ /* Include sys/types.h before this file. */ #include #ifndef S_ISREG /* Doesn't have POSIX.1 stat stuff. */ #define mode_t unsigned short #endif #ifdef STAT_MACROS_BROKEN #ifdef S_ISBLK #undef S_ISBLK #endif #ifdef S_ISCHR #undef S_ISCHR #endif #ifdef S_ISDIR #undef S_ISDIR #endif #ifdef S_ISFIFO #undef S_ISFIFO #endif #ifdef S_ISLNK #undef S_ISLNK #endif #ifdef S_ISMPB #undef S_ISMPB #endif #ifdef S_ISMPC #undef S_ISMPC #endif #ifdef S_ISNWK #undef S_ISNWK #endif #ifdef S_ISREG #undef S_ISREG #endif #ifdef S_ISSOCK #undef S_ISSOCK #endif #endif /* STAT_MACROS_BROKEN. */ #ifndef S_IFMT #define S_IFMT 0170000 #endif #if !defined(S_ISBLK) && defined(S_IFBLK) #define S_ISBLK(m) (((m) & S_IFMT) == S_IFBLK) #endif #if !defined(S_ISCHR) && defined(S_IFCHR) #define S_ISCHR(m) (((m) & S_IFMT) == S_IFCHR) #endif #if !defined(S_ISDIR) && defined(S_IFDIR) #define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR) #endif #if !defined(S_ISREG) && defined(S_IFREG) #define S_ISREG(m) (((m) & S_IFMT) == S_IFREG) #endif #if !defined(S_ISFIFO) && defined(S_IFIFO) #define S_ISFIFO(m) (((m) & S_IFMT) == S_IFIFO) #endif #if !defined(S_ISLNK) && defined(S_IFLNK) #define S_ISLNK(m) (((m) & S_IFMT) == S_IFLNK) #endif #if !defined(S_ISSOCK) && defined(S_IFSOCK) #define S_ISSOCK(m) (((m) & S_IFMT) == S_IFSOCK) #endif #if !defined(S_ISMPB) && defined(S_IFMPB) /* V7 */ #define S_ISMPB(m) (((m) & S_IFMT) == S_IFMPB) #define S_ISMPC(m) (((m) & S_IFMT) == S_IFMPC) #endif #if !defined(S_ISNWK) && defined(S_IFNWK) /* HP/UX */ #define S_ISNWK(m) (((m) & S_IFMT) == S_IFNWK) #endif #ifdef HAVE_UNISTD_H #include #endif #ifndef _POSIX_VERSION char *getlogin (); char *ttyname (); off_t lseek (); uid_t geteuid (); #endif /* _POSIX_VERSION */ #if defined(STDC_HEADERS) || defined(HAVE_STRING_H) #include #ifndef index #define index strchr #endif #ifndef rindex #define rindex strrchr #endif #ifndef bcopy #define bcopy(from, to, len) memcpy ((to), (from), (len)) #endif #ifndef bzero #define bzero(s, n) memset ((s), 0, (n)) #endif #else #include #endif #include #ifdef STDC_HEADERS #include #else char *getenv (); double atof (); long atol (); extern int errno; #endif #if defined(HAVE_FCNTL_H) || defined(_POSIX_VERSION) #include #else #include #endif #ifndef F_OK #define F_OK 0 #define X_OK 1 #define W_OK 2 #define R_OK 4 #endif #ifndef S_ISLNK #define lstat stat #endif sh-utils-1.10/src/basename.c100666 74504 13 5321 5554616563 15013 0ustar meyeringuser/* basename -- strip directory and suffix from filenames Copyright (C) 90, 91, 92, 93, 1994 Free Software Foundation, Inc. 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 2, 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, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ /* Usage: basename name [suffix] NAME is a pathname; SUFFIX is a suffix to strip from it. basename /usr/foo/lossage/functions.l => functions.l basename /usr/foo/lossage/functions.l .l => functions basename functions.lisp p => functions.lis */ #ifdef HAVE_CONFIG_H #if defined (CONFIG_BROKETS) /* We use instead of "config.h" so that a compilation using -I. -I$srcdir will use ./config.h rather than $srcdir/config.h (which it would do because it found this file in $srcdir). */ #include #else #include "config.h" #endif #endif #include #include #include "system.h" #include "long-options.h" char *basename (); void strip_trailing_slashes (); static void remove_suffix (); /* The name this program was run with. */ char *program_name; static void usage (status) int status; { if (status != 0) fprintf (stderr, "Try `%s --help' for more information.\n", program_name); else { printf ("\ Usage: %s PATH [SUFFIX]\n\ or: %s OPTION\n\ ", program_name, program_name); printf ("\ \n\ --help display this help and exit\n\ --version output version information and exit\n\ "); } exit (status); } void main (argc, argv) int argc; char **argv; { char *name; program_name = argv[0]; parse_long_options (argc, argv, "basename", usage); if (argc == 1 || argc > 3) usage (1); strip_trailing_slashes (argv[1]); name = basename (argv[1]); if (argc == 3) remove_suffix (name, argv[2]); puts (name); exit (0); } /* Remove SUFFIX from the end of NAME if it is there, unless NAME consists entirely of SUFFIX. */ static void remove_suffix (name, suffix) register char *name, *suffix; { register char *np, *sp; np = name + strlen (name); sp = suffix + strlen (suffix); while (np > name && sp > suffix) if (*--np != *--sp) return; if (np > name) *np = '\0'; } sh-utils-1.10/src/date.c100666 74504 1 16575 5555072433 14445 0ustar meyeringdaemon/* date - print or set the system date and time Copyright (C) 89, 90, 91, 92, 93, 1994 Free Software Foundation, Inc. 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 2, 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, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ /* Options: -d DATESTR Display the date DATESTR. -s DATESTR Set the date to DATESTR. -u Display or set the date in universal instead of local time. +FORMAT Specify custom date output format, described below. MMDDhhmm[[CC]YY][.ss] Set the date in the format described below. If one non-option argument is given, it is used as the date to which to set the system clock, and must have the format: MM month (01..12) DD day in month (01..31) hh hour (00..23) mm minute (00..59) CC first 2 digits of year (optional, defaults to current) (00..99) YY last 2 digits of year (optional, defaults to current) (00..99) ss second (00..61) If a non-option argument that starts with a `+' is specified, it is used to control the format in which the date is printed; it can contain any of the `%' substitutions allowed by the strftime function. A newline is always added at the end of the output. David MacKenzie */ #ifdef HAVE_CONFIG_H #if defined (CONFIG_BROKETS) /* We use instead of "config.h" so that a compilation using -I. -I$srcdir will use ./config.h rather than $srcdir/config.h (which it would do because it found this file in $srcdir). */ #include #else #include "config.h" #endif #endif #include #include #include #include "version.h" #include "system.h" #ifdef TM_IN_SYS_TIME #include #else #include #endif #ifndef STDC_HEADERS size_t strftime (); time_t time (); #endif int putenv (); int stime (); char *xrealloc (); time_t get_date (); time_t posixtime (); void error (); static void show_date (); static void usage (); /* putenv string to use Universal Coordinated Time. POSIX.2 says it should be "TZ=UCT0" or "TZ=GMT0". */ #ifndef TZ_UCT #if defined(hpux) || defined(__hpux__) || defined(ultrix) || defined(__ultrix__) || defined(USG) #define TZ_UCT "TZ=GMT0" #else #define TZ_UCT "TZ=" #endif #endif /* The name this program was run with, for error messages. */ char *program_name; /* If non-zero, display usage information and exit. */ static int show_help; /* If non-zero, print the version on standard output and exit. */ static int show_version; static struct option const long_options[] = { {"date", required_argument, NULL, 'd'}, {"help", no_argument, &show_help, 1}, {"set", required_argument, NULL, 's'}, {"uct", no_argument, NULL, 'u'}, {"universal", no_argument, NULL, 'u'}, {"version", no_argument, &show_version, 1}, {NULL, 0, NULL, 0} }; void main (argc, argv) int argc; char **argv; { int optc; char *datestr = NULL; time_t when; int set_date = 0; int universal_time = 0; program_name = argv[0]; while ((optc = getopt_long (argc, argv, "d:s:u", long_options, (int *) 0)) != EOF) switch (optc) { case 0: break; case 'd': datestr = optarg; break; case 's': datestr = optarg; set_date = 1; break; case 'u': universal_time = 1; break; default: usage (1); } if (show_version) { printf ("date - %s\n", version_string); exit (0); } if (show_help) usage (0); if (argc - optind > 1) usage (1); if (universal_time && putenv (TZ_UCT) != 0) error (1, 0, "virtual memory exhausted"); time (&when); if (datestr) when = get_date (datestr, NULL); if (argc - optind == 1 && argv[optind][0] != '+') { when = posixtime (argv[optind]); set_date = 1; } if (when == -1) error (1, 0, "invalid date"); if (set_date && stime (&when) == -1) error (0, errno, "cannot set date"); if (argc - optind == 1 && argv[optind][0] == '+') show_date (argv[optind] + 1, when); else show_date ((char *) NULL, when); exit (0); } /* Display the date and/or time in WHEN according to the format specified in FORMAT, followed by a newline. If FORMAT is NULL, use the standard output format (ctime style but with a timezone inserted). */ static void show_date (format, when) char *format; time_t when; { struct tm *tm; char *out = NULL; size_t out_length = 0; tm = localtime (&when); if (format == NULL) /* Print the date in the default format. Vanilla ANSI C strftime doesn't support %e, but POSIX requires it. If you don't use a GNU strftime, make sure yours supports %e. */ format = "%a %b %e %H:%M:%S %Z %Y"; else if (*format == '\0') { printf ("\n"); return; } do { out_length += 200; out = (char *) xrealloc (out, out_length); } while (strftime (out, out_length, format, tm) == 0); printf ("%s\n", out); free (out); } static void usage (status) int status; { if (status != 0) fprintf (stderr, "Try `%s --help' for more information.\n", program_name); else { printf ("Usage: %s [OPTION]... [+FORMAT] [MMDDhhmm[[CC]YY][.ss]]\n", program_name); printf ("\ \n\ -d, --date=STRING display time described by STRING, not `now'\n\ -s, --set=STRING set time described by STRING\n\ -u, --uct, --universal print or set Universal Coordinated Time\n\ --help display this help and exit\n\ --version output version information and exit\n\ "); printf ("\ \n\ FORMAT controls the output. Interpreted sequences are:\n\ \n\ %%%% a literal %%\n\ %%a locale's abbreviated weekday name (Sun..Sat)\n\ %%A locale's full weekday name, variable length (Sunday..Saturday)\n\ %%b locale's abbreviated month name (Jan..Dec)\n\ %%B locale's full month name, variable length (January..December)\n\ %%c locale's date and time (Sat Nov 04 12:02:33 EST 1989)\n\ %%d day of month (01..31)\n\ %%D date (mm/dd/yy)\n\ %%h same as %%b\n\ %%H hour (00..23)\n\ %%I hour (01..12)\n\ %%j day of year (001..366)\n\ %%k hour ( 0..23)\n\ %%l hour ( 1..12)\n\ %%m month (01..12)\n\ %%M minute (00..59)\n\ %%n a newline\n\ %%p locale's AM or PM\n\ %%r time, 12-hour (hh:mm:ss [AP]M)\n\ %%s seconds since 00:00:00, Jan 1, 1970 (a nonstandard extension)\n\ %%S second (00..61)\n\ %%t a horizontal tab\n\ %%T time, 24-hour (hh:mm:ss)\n\ %%U week number of year with Sunday as first day of week (00..53)\n\ %%w day of week (0..6); 0 represents Sunday\n\ %%W week number of year with Monday as first day of week (00..53)\n\ %%x locale's date representation (mm/dd/yy)\n\ %%X locale's time representation (%%H:%%M:%%S)\n\ %%y last two digits of year (00..99)\n\ %%Y year (1970...)\n\ %%Z time zone (e.g., EDT), or nothing if no time zone is determinable\n\ "); } exit (status); } sh-utils-1.10/src/dirname.c100666 74504 13 4351 5554616564 14662 0ustar meyeringuser/* dirname -- strip filename suffix from pathname Copyright (C) 90, 91, 92, 93, 1994 Free Software Foundation, Inc. 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 2, 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, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ /* Written by David MacKenzie and Jim Meyering. */ #ifdef HAVE_CONFIG_H #if defined (CONFIG_BROKETS) /* We use instead of "config.h" so that a compilation using -I. -I$srcdir will use ./config.h rather than $srcdir/config.h (which it would do because it found this file in $srcdir). */ #include #else #include "config.h" #endif #endif #include #include #include "system.h" #include "long-options.h" void strip_trailing_slashes (); /* The name this program was run with. */ char *program_name; static void usage (status) int status; { if (status != 0) fprintf (stderr, "Try `%s --help' for more information.\n", program_name); else { printf ("\ Usage: %s PATH\n\ or: %s OPTION\n\ ", program_name, program_name); printf ("\ \n\ --help display this help and exit\n\ --version output version information and exit\n\ "); } exit (status); } void main (argc, argv) int argc; char **argv; { register char *path; register char *slash; program_name = argv[0]; parse_long_options (argc, argv, "dirname", usage); if (argc != 2) usage (1); path = argv[1]; strip_trailing_slashes (path); slash = rindex (path, '/'); if (slash == NULL) path = "."; else { /* Remove any trailing slashes and final element. */ while (slash > path && *slash == '/') --slash; slash[1] = 0; } puts (path); exit (0); } sh-utils-1.10/src/echo.c100666 74504 13 13277 5554616565 14211 0ustar meyeringuser/* echo.c, taken from Bash. Copyright (C) 87, 89, 91, 92, 93, 1994 Free Software Foundation, Inc. This file is part of GNU Bash, the Bourne Again SHell. Bash 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 2, or (at your option) any later version. Bash 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 Bash; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ #ifdef HAVE_CONFIG_H #if defined (CONFIG_BROKETS) /* We use instead of "config.h" so that a compilation using -I. -I$srcdir will use ./config.h rather than $srcdir/config.h (which it would do because it found this file in $srcdir). */ #include #else #include "config.h" #endif #endif #include #include #include "system.h" #include "long-options.h" /* echo [-neE] [arg ...] Output the ARGs. If -n is specified, the trailing newline is suppressed. If the -e option is given, interpretation of the following backslash-escaped characters is turned on: \a alert (bell) \b backspace \c suppress trailing newline \f form feed \n new line \r carriage return \t horizontal tab \v vertical tab \\ backslash \num the character whose ASCII code is NUM (octal). You can explicitly turn off the interpretation of the above characters on System V systems with the -E option. */ /* If defined, interpret backslash escapes if -e is given. */ #define V9_ECHO /* If defined, interpret backslash escapes unless -E is given. V9_ECHO must also be defined. */ #define V9_DEFAULT #if defined (V9_ECHO) # if defined (V9_DEFAULT) # define VALID_ECHO_OPTIONS "neE" # else # define VALID_ECHO_OPTIONS "ne" # endif /* !V9_DEFAULT */ #else /* !V9_ECHO */ # define VALID_ECHO_OPTIONS "n" #endif /* !V9_ECHO */ /* The name this program was run with. */ char *program_name; static void usage (status) int status; { if (status != 0) fprintf (stderr, "Try `%s --help' for more information.\n", program_name); else { printf ("Usage: %s [OPTION]... [STRING]...\n", program_name); printf ("\ \n\ -n do not output the trailing newline\n\ -e (unused)\n\ -E disable interpolation of some sequences in STRINGs\n\ --help display this help and exit (should be alone)\n\ --version output version information and exit (should be alone)\n\ \n\ Without -E, the following sequences are recognized and interpolated:\n\ \n\ \\NNN the character whose ASCII code is NNN (octal)\n\ \\\\ backslash\n\ \\a alert (BEL)\n\ \\b backspace\n\ \\c suppress trailing newline\n\ \\f form feed\n\ \\n new line\n\ \\r carriage return\n\ \\t horizontal tab\n\ \\v vertical tab\n\ "); } exit (status); } /* Print the words in LIST to standard output. If the first word is `-n', then don't print a trailing newline. We also support the echo syntax from Version 9 unix systems. */ void main (argc, argv) int argc; char **argv; { int display_return = 1, do_v9 = 0; program_name = argv[0]; parse_long_options (argc, argv, "echo", usage); /* System V machines already have a /bin/sh with a v9 behaviour. We use the identical behaviour for these machines so that the existing system shell scripts won't barf. */ #if defined (V9_ECHO) && defined (V9_DEFAULT) do_v9 = 1; #endif --argc; ++argv; while (argc > 0 && *argv[0] == '-') { register char *temp; register int i; /* If it appears that we are handling options, then make sure that all of the options specified are actually valid. Otherwise, the string should just be echoed. */ temp = argv[0] + 1; for (i = 0; temp[i]; i++) { if (rindex (VALID_ECHO_OPTIONS, temp[i]) == 0) goto just_echo; } if (!*temp) goto just_echo; /* All of the options in TEMP are valid options to ECHO. Handle them. */ while (*temp) { if (*temp == 'n') display_return = 0; #if defined (V9_ECHO) else if (*temp == 'e') do_v9 = 1; #if defined (V9_DEFAULT) else if (*temp == 'E') do_v9 = 0; #endif /* V9_DEFAULT */ #endif /* V9_ECHO */ else goto just_echo; temp++; } argc--; argv++; } just_echo: if (argc > 0) { #if defined (V9_ECHO) if (do_v9) { while (argc > 0) { register char *s = argv[0]; register int c; while ((c = *s++)) { if (c == '\\' && *s) { switch (c = *s++) { case 'a': c = '\007'; break; case 'b': c = '\b'; break; case 'c': display_return = 0; continue; case 'f': c = '\f'; break; case 'n': c = '\n'; break; case 'r': c = '\r'; break; case 't': c = '\t'; break; case 'v': c = (int) 0x0B; break; case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': c -= '0'; if (*s >= '0' && *s <= '7') c = c * 8 + (*s++ - '0'); if (*s >= '0' && *s <= '7') c = c * 8 + (*s++ - '0'); break; case '\\': break; default: putchar ('\\'); break; } } putchar(c); } argc--; argv++; if (argc > 0) putchar(' '); } } else #endif /* V9_ECHO */ { while (argc > 0) { fputs (argv[0], stdout); argc--; argv++; if (argc > 0) putchar (' '); } } } if (display_return) putchar ('\n'); exit (0); } sh-utils-1.10/src/env.c100666 74504 1 13310 5555072435 14302 0ustar meyeringdaemon/* env - run a program in a modified environment Copyright (C) 86, 91, 92, 93, 1994 Free Software Foundation, Inc. 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 2, 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, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ /* Richard Mlynarik and David MacKenzie */ /* Options: - -i --ignore-environment Construct a new environment from scratch; normally the environment is inherited from the parent process, except as modified by other options. -u variable --unset=variable Unset variable VARIABLE (remove it from the environment). If VARIABLE was not set, does nothing. variable=value (an arg containing a "=" character) Set the environment variable VARIABLE to value VALUE. VALUE may be of zero length ("variable="). Setting a variable to a zero-length value is different from unsetting it. -- Indicate that the following argument is the program to invoke. This is necessary when the program's name begins with "-" or contains a "=". The first remaining argument specifies a program to invoke; it is searched for according to the specification of the PATH environment variable. Any arguments following that are passed as arguments to that program. If no command name is specified following the environment specifications, the resulting environment is printed. This is like specifying a command name of "printenv". Examples: If the environment passed to "env" is { LOGNAME=rms EDITOR=emacs PATH=.:/gnubin:/hacks } env - foo runs "foo" in a null environment. env foo runs "foo" in the environment { LOGNAME=rms EDITOR=emacs PATH=.:/gnubin:/hacks } env DISPLAY=gnu:0 nemacs runs "nemacs" in the envionment { LOGNAME=rms EDITOR=emacs PATH=.:/gnubin:/hacks DISPLAY=gnu:0 } env - LOGNAME=foo /hacks/hack bar baz runs the "hack" program on arguments "bar" and "baz" in an environment in which the only variable is "LOGNAME". Note that the "-" option clears out the PATH variable, so one should be careful to specify in which directory to find the program to call. env -u EDITOR LOGNAME=foo PATH=/energy -- e=mc2 bar baz runs the program "/energy/e=mc2" with environment { LOGNAME=foo PATH=/energy } */ #ifdef HAVE_CONFIG_H #if defined (CONFIG_BROKETS) /* We use instead of "config.h" so that a compilation using -I. -I$srcdir will use ./config.h rather than $srcdir/config.h (which it would do because it found this file in $srcdir). */ #include #else #include "config.h" #endif #endif #include #include #include #include #include "version.h" #include "system.h" int putenv (); void error (); static void usage (); extern char **environ; /* The name by which this program was run. */ char *program_name; /* If non-zero, display usage information and exit. */ static int show_help; /* If non-zero, print the version on standard output and exit. */ static int show_version; static struct option const longopts[] = { {"help", no_argument, &show_help, 1}, {"ignore-environment", no_argument, NULL, 'i'}, {"unset", required_argument, NULL, 'u'}, {"version", no_argument, &show_version, 1}, {NULL, 0, NULL, 0} }; void main (argc, argv, envp) register int argc; register char **argv; char **envp; { char *dummy_environ[1]; int optc; int ignore_environment = 0; program_name = argv[0]; while ((optc = getopt_long (argc, argv, "+iu:", longopts, (int *) 0)) != EOF) { switch (optc) { case 0: break; case 'i': ignore_environment = 1; break; case 'u': break; default: usage (2); } } if (show_version) { printf ("env - %s\n", version_string); exit (0); } if (show_help) usage (0); if (optind != argc && !strcmp (argv[optind], "-")) ignore_environment = 1; environ = dummy_environ; environ[0] = NULL; if (!ignore_environment) for (; *envp; envp++) putenv (*envp); optind = 0; /* Force GNU getopt to re-initialize. */ while ((optc = getopt_long (argc, argv, "+iu:", longopts, (int *) 0)) != EOF) if (optc == 'u') putenv (optarg); /* Requires GNU putenv. */ if (optind != argc && !strcmp (argv[optind], "-")) ++optind; while (optind < argc && index (argv[optind], '=')) putenv (argv[optind++]); /* If no program is specified, print the environment and exit. */ if (optind == argc) { while (*environ) puts (*environ++); exit (0); } execvp (argv[optind], &argv[optind]); error (errno == ENOENT ? 127 : 126, errno, "%s", argv[optind]); } static void usage (status) int status; { if (status != 0) fprintf (stderr, "Try `%s --help' for more information.\n", program_name); else { printf ("Usage: %s [OPTION]... [-] [NAME=VALUE]... [COMMAND [ARG]...]\n", program_name); printf ("\ \n\ -u, --unset=NAME remove variable from the environment\n\ -i, --ignore-environment start with an empty environment\n\ --help display this help and exit\n\ --version output version information and exit\n\ \n\ A mere - implies -i. If no COMMAND, print the resulting environment.\n\ "); } exit (status); } sh-utils-1.10/src/expr.c100666 74504 13 34460 5554616566 14247 0ustar meyeringuser/* expr -- evaluate expressions. Copyright (C) 1986, 1991 Free Software Foundation, Inc. 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 2, 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, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ /* Author: Mike Parker. This program evaluates expressions. Each token (operator, operand, parenthesis) of the expression must be a seperate argument. The parser used is a reasonably general one, though any incarnation of it is language-specific. It is especially nice for expressions. No parse tree is needed; a new node is evaluated immediately. One function can handle multiple operators all of equal precedence, provided they all associate ((x op x) op x). Define EVAL_TRACE to print an evaluation trace. */ #ifdef HAVE_CONFIG_H #if defined (CONFIG_BROKETS) /* We use instead of "config.h" so that a compilation using -I. -I$srcdir will use ./config.h rather than $srcdir/config.h (which it would do because it found this file in $srcdir). */ #include #else #include "config.h" #endif #endif #include #include #include #include #include "system.h" #include "version.h" #include "long-options.h" #if defined (STDC_HEADERS) || (!defined (isascii) && !defined (HAVE_ISASCII)) #define ISASCII(c) 1 #else #define ISASCII(c) isascii(c) #endif #define ISDIGIT(c) (ISASCII (c) && isdigit (c)) #define NEW(type) ((type *) xmalloc (sizeof (type))) #define OLD(x) free ((char *) x) /* The kinds of value we can have. */ enum valtype { integer, string }; typedef enum valtype TYPE; /* A value is.... */ struct valinfo { TYPE type; /* Which kind. */ union { /* The value itself. */ int i; char *s; } u; }; typedef struct valinfo VALUE; /* The arguments given to the program, minus the program name. */ static char **args; /* The name this program was run with. */ char *program_name; void error (); char *xstrdup (); char *strstr (); char *xmalloc (); static VALUE *docolon (); static VALUE *eval (); static VALUE *int_value (); static VALUE *str_value (); static int isstring (); static int nextarg (); static int nomoreargs (); static int null (); static int toarith (); static void freev (); static void printv (); static void tostring (); #ifdef EVAL_TRACE static void trace (); #endif static void usage (status) int status; { if (status != 0) fprintf (stderr, "Try `%s --help' for more information.\n", program_name); else { printf ("\ Usage: %s EXPRESSION\n\ or: %s OPTION\n\ ", program_name, program_name); printf ("\ \n\ --help display this help and exit\n\ --version output version information and exit\n\ \n\ "); printf ("\ EXPRESSION value is written on standard output. A white line\n\ separates increasing precedence groups. EXPRESSION may be:\n\ \n\ ARG1 | ARG2 ARG1 if it is neither null nor 0, otherwise ARG2\n\ \n\ ARG1 & ARG2 ARG1 if neither argument is null or 0, otherwise 0\n\ \n\ ARG1 < ARG2 ARG1 is less than ARG2\n\ ARG1 <= ARG2 ARG1 is less than or equal to ARG2\n\ ARG1 = ARG2 ARG1 is equal to ARG2\n\ ARG1 != ARG2 ARG1 is unequal to ARG2\n\ ARG1 >= ARG2 ARG1 is greater than or equal to ARG2\n\ ARG1 > ARG2 ARG1 is greater than ARG2\n\ \n\ ARG1 + ARG2 arithmetic sum of ARG1 and ARG2\n\ ARG1 - ARG2 arithmetic difference of ARG1 and ARG2\n\ \n\ ARG1 * ARG2 arithmetic product of ARG1 and ARG2\n\ ARG1 / ARG2 arithmetic quotient of ARG1 divided by ARG2\n\ ARG1 %% ARG2 arithmetic remainder of ARG1 divided by ARG2\n\ \n\ STRING : REGEXP anchored pattern match of REGEXP in STRING\n\ \n\ match STRING REGEXP same as STRING : REGEXP\n\ substr STRING POS LENGTH substring of STRING, POS counted from 1\n\ index STRING CHARS index in STRING where any CHARS is found, or 0\n\ length STRING length of STRING\n\ \n\ ( EXPRESSION ) value of EXPRESSION\n\ "); printf ("\ \n\ Beware that some operators need to be escaped by backslashes for shells.\n\ Comparisons are arithmetic if both ARGs are numbers, else lexicographical.\n\ Pattern matches return the string matched between \\( and \\) or null; if\n\ \\( and \\) are not used, they return the number of characters matched or 0.\n\ "); } exit (status); } void main (argc, argv) int argc; char **argv; { VALUE *v; program_name = argv[0]; parse_long_options (argc, argv, "expr", usage); if (argc == 1) usage (1); args = argv + 1; v = eval (); if (!nomoreargs ()) error (2, 0, "syntax error"); printv (v); exit (null (v)); } /* Return a VALUE for I. */ static VALUE * int_value (i) int i; { VALUE *v; v = NEW (VALUE); v->type = integer; v->u.i = i; return v; } /* Return a VALUE for S. */ static VALUE * str_value (s) char *s; { VALUE *v; v = NEW (VALUE); v->type = string; v->u.s = xstrdup (s); return v; } /* Free VALUE V, including structure components. */ static void freev (v) VALUE *v; { if (v->type == string) free (v->u.s); OLD (v); } /* Print VALUE V. */ static void printv (v) VALUE *v; { switch (v->type) { case integer: printf ("%d\n", v->u.i); break; case string: printf ("%s\n", v->u.s); break; default: abort (); } } /* Return nonzero if V is a null-string or zero-number. */ static int null (v) VALUE *v; { switch (v->type) { case integer: return v->u.i == 0; case string: return v->u.s[0] == '\0' || strcmp(v->u.s, "0") == 0; default: abort (); } } /* Return nonzero if V is a string value. */ static int isstring (v) VALUE *v; { return v->type == string; } /* Coerce V to a string value (can't fail). */ static void tostring (v) VALUE *v; { char *temp; switch (v->type) { case integer: temp = xmalloc (4 * (sizeof (int) / sizeof (char))); sprintf (temp, "%d", v->u.i); v->u.s = temp; v->type = string; break; case string: break; default: abort (); } } /* Coerce V to an integer value. Return 1 on success, 0 on failure. */ static int toarith (v) VALUE *v; { int i; int neg; char *cp; switch (v->type) { case integer: return 1; case string: i = 0; cp = v->u.s; /* Don't interpret the empty string as an integer. */ if (*cp == 0) return 0; neg = (*cp == '-'); if (neg) cp++; for (; *cp; cp++) { if (ISDIGIT (*cp)) i = i * 10 + *cp - '0'; else return 0; } free (v->u.s); v->u.i = i * (neg ? -1 : 1); v->type = integer; return 1; default: abort (); } } /* Return nonzero if the next token matches STR exactly. STR must not be NULL. */ static int nextarg (str) char *str; { if (*args == NULL) return 0; return strcmp (*args, str) == 0; } /* Return nonzero if there no more tokens. */ static int nomoreargs () { return *args == 0; } /* The comparison operator handling functions. */ #define cmpf(name, rel) \ static \ int name (l, r) VALUE *l; VALUE *r; \ { \ if (isstring (l) || isstring (r)) \ { \ tostring (l); \ tostring (r); \ return strcmp (l->u.s, r->u.s) rel 0; \ } \ else \ return l->u.i rel r->u.i; \ } cmpf (less_than, <) cmpf (less_equal, <=) cmpf (equal, ==) cmpf (not_equal, !=) cmpf (greater_equal, >=) cmpf (greater_than, >) #undef cmpf /* The arithmetic operator handling functions. */ #define arithf(name, op) \ static \ int name (l, r) VALUE *l; VALUE *r; \ { \ if (!toarith (l) || !toarith (r)) \ error (2, 0, "non-numeric argument"); \ return l->u.i op r->u.i; \ } #define arithdivf(name, op) \ int name (l, r) VALUE *l; VALUE *r; \ { \ if (!toarith (l) || !toarith (r)) \ error (2, 0, "non-numeric argument"); \ if (r->u.i == 0) \ error (2, 0, "division by zero"); \ return l->u.i op r->u.i; \ } arithf (plus, +) arithf (minus, -) arithf (multiply, *) arithdivf (divide, /) arithdivf (mod, %) #undef arithf #undef arithdivf #ifdef EVAL_TRACE /* Print evaluation trace and args remaining. */ static void trace (fxn) char *fxn; { char **a; printf ("%s:", fxn); for (a = args; *a; a++) printf (" %s", *a); putchar ('\n'); } #endif /* Do the : operator. SV is the VALUE for the lhs (the string), PV is the VALUE for the rhs (the pattern). */ static VALUE * docolon (sv, pv) VALUE *sv; VALUE *pv; { VALUE *v; const char *errmsg; struct re_pattern_buffer re_buffer; struct re_registers re_regs; int len; tostring (sv); tostring (pv); len = strlen (pv->u.s); re_buffer.allocated = 2 * len; re_buffer.buffer = (unsigned char *) xmalloc (re_buffer.allocated); re_buffer.translate = 0; errmsg = re_compile_pattern (pv->u.s, len, &re_buffer); if (errmsg) error (2, 0, "%s", errmsg); len = re_match (&re_buffer, sv->u.s, strlen (sv->u.s), 0, &re_regs); if (len >= 0) { /* Were \(...\) used? */ if (re_buffer.re_nsub > 0)/* was (re_regs.start[1] >= 0) */ { sv->u.s[re_regs.end[1]] = '\0'; v = str_value (sv->u.s + re_regs.start[1]); } else v = int_value (len); } else { /* Match failed -- return the right kind of null. */ if (strstr (pv->u.s, "\\(")) v = str_value (""); else v = int_value (0); } free (re_buffer.buffer); return v; } /* Handle bare operands and ( expr ) syntax. */ static VALUE * eval7 () { VALUE *v; #ifdef EVAL_TRACE trace ("eval7"); #endif if (nomoreargs ()) error (2, 0, "syntax error"); if (nextarg ("(")) { args++; v = eval (); if (!nextarg (")")) error (2, 0, "syntax error"); args++; return v; } if (nextarg (")")) error (2, 0, "syntax error"); return str_value (*args++); } /* Handle match, substr, index, and length keywords. */ static VALUE * eval6 () { VALUE *l; VALUE *r; VALUE *v; VALUE *i1; VALUE *i2; #ifdef EVAL_TRACE trace ("eval6"); #endif if (nextarg ("length")) { args++; r = eval6 (); tostring (r); v = int_value (strlen (r->u.s)); freev (r); return v; } else if (nextarg ("match")) { args++; l = eval6 (); r = eval6 (); v = docolon (l, r); freev (l); freev (r); return v; } else if (nextarg ("index")) { args++; l = eval6 (); r = eval6 (); tostring (l); tostring (r); v = int_value (strcspn (l->u.s, r->u.s) + 1); if (v->u.i == strlen (l->u.s) + 1) v->u.i = 0; freev (l); freev (r); return v; } else if (nextarg ("substr")) { args++; l = eval6 (); i1 = eval6 (); i2 = eval6 (); tostring (l); if (!toarith (i1) || !toarith (i2) || i1->u.i > strlen (l->u.s) || i1->u.i <= 0 || i2->u.i <= 0) v = str_value (""); else { v = NEW (VALUE); v->type = string; v->u.s = strncpy ((char *) xmalloc (i2->u.i + 1), l->u.s + i1->u.i - 1, i2->u.i); v->u.s[i2->u.i] = 0; } freev (l); freev (i1); freev (i2); return v; } else return eval7 (); } /* Handle : operator (pattern matching). Calls docolon to do the real work. */ static VALUE * eval5 () { VALUE *l; VALUE *r; VALUE *v; #ifdef EVAL_TRACE trace ("eval5"); #endif l = eval6 (); while (1) { if (nextarg (":")) { args++; r = eval6 (); v = docolon (l, r); freev (l); freev (r); l = v; } else return l; } } /* Handle *, /, % operators. */ static VALUE * eval4 () { VALUE *l; VALUE *r; int (*fxn) (); int val; #ifdef EVAL_TRACE trace ("eval4"); #endif l = eval5 (); while (1) { if (nextarg ("*")) fxn = multiply; else if (nextarg ("/")) fxn = divide; else if (nextarg ("%")) fxn = mod; else return l; args++; r = eval5 (); val = (*fxn) (l, r); freev (l); freev (r); l = int_value (val); } } /* Handle +, - operators. */ static VALUE * eval3 () { VALUE *l; VALUE *r; int (*fxn) (); int val; #ifdef EVAL_TRACE trace ("eval3"); #endif l = eval4 (); while (1) { if (nextarg ("+")) fxn = plus; else if (nextarg ("-")) fxn = minus; else return l; args++; r = eval4 (); val = (*fxn) (l, r); freev (l); freev (r); l = int_value (val); } } /* Handle comparisons. */ static VALUE * eval2 () { VALUE *l; VALUE *r; int (*fxn) (); int val; #ifdef EVAL_TRACE trace ("eval2"); #endif l = eval3 (); while (1) { if (nextarg ("<")) fxn = less_than; else if (nextarg ("<=")) fxn = less_equal; else if (nextarg ("=") || nextarg ("==")) fxn = equal; else if (nextarg ("!=")) fxn = not_equal; else if (nextarg (">=")) fxn = greater_equal; else if (nextarg (">")) fxn = greater_than; else return l; args++; r = eval3 (); toarith (l); toarith (r); val = (*fxn) (l, r); freev (l); freev (r); l = int_value (val); } } /* Handle &. */ static VALUE * eval1 () { VALUE *l; VALUE *r; #ifdef EVAL_TRACE trace ("eval1"); #endif l = eval2 (); while (1) { if (nextarg ("&")) { args++; r = eval2 (); if (null (l) || null (r)) { freev (l); freev (r); l = int_value (0); } else freev (r); } else return l; } } /* Handle |. */ static VALUE * eval () { VALUE *l; VALUE *r; #ifdef EVAL_TRACE trace ("eval"); #endif l = eval1 (); while (1) { if (nextarg ("|")) { args++; r = eval1 (); if (null (l)) { freev (l); l = r; } else freev (r); } else return l; } } sh-utils-1.10/src/id.c100666 74504 1 20576 5555072442 14120 0ustar meyeringdaemon/* id -- print real and effective UIDs and GIDs Copyright (C) 89, 90, 91, 92, 93, 1994 Free Software Foundation, Inc. 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 2, 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, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ /* Written by Arnold Robbins, arnold@audiofax.com. Major rewrite by David MacKenzie, djm@gnu.ai.mit.edu. */ #ifdef HAVE_CONFIG_H #if defined (CONFIG_BROKETS) /* We use instead of "config.h" so that a compilation using -I. -I$srcdir will use ./config.h rather than $srcdir/config.h (which it would do because it found this file in $srcdir). */ #include #else #include "config.h" #endif #endif #include #include #include #include #include #include #include "version.h" #include "system.h" #ifdef _POSIX_VERSION #include #if !defined(NGROUPS_MAX) || NGROUPS_MAX < 1 #undef NGROUPS_MAX #define NGROUPS_MAX sysconf (_SC_NGROUPS_MAX) #endif /* !NGROUPS_MAX */ #else /* not _POSIX_VERSION */ struct passwd *getpwuid (); struct group *getgrgid (); uid_t getuid (); gid_t getgid (); uid_t geteuid (); gid_t getegid (); #include #if !defined(NGROUPS_MAX) && defined(NGROUPS) #define NGROUPS_MAX NGROUPS #endif /* not NGROUPS_MAX and NGROUPS */ #endif /* not _POSIX_VERSION */ char *xmalloc (); int getugroups (); void error (); static void print_user (); static void print_group (); static void print_group_list (); static void print_full_info (); static void usage (); /* The name this program was run with. */ char *program_name; /* If nonzero, output only the group ID(s). -g */ static int just_group = 0; /* If nonzero, output user/group name instead of ID number. -n */ static int use_name = 0; /* If nonzero, output real UID/GID instead of default effective UID/GID. -r */ static int use_real = 0; /* If nonzero, output only the user ID(s). -u */ static int just_user = 0; /* If nonzero, output only the supplementary groups. -G */ static int just_group_list = 0; /* The real and effective IDs of the user to print. */ static uid_t ruid, euid; static gid_t rgid, egid; /* The number of errors encountered so far. */ static int problems = 0; /* If non-zero, display usage information and exit. */ static int show_help; /* If non-zero, print the version on standard output and exit. */ static int show_version; static struct option const longopts[] = { {"group", no_argument, NULL, 'g'}, {"groups", no_argument, NULL, 'G'}, {"help", no_argument, &show_help, 1}, {"name", no_argument, NULL, 'n'}, {"real", no_argument, NULL, 'r'}, {"user", no_argument, NULL, 'u'}, {"version", no_argument, &show_version, 1}, {NULL, 0, NULL, 0} }; void main (argc, argv) int argc; char **argv; { int optc; program_name = argv[0]; while ((optc = getopt_long (argc, argv, "gnruG", longopts, (int *) 0)) != EOF) { switch (optc) { case 0: break; case 'g': just_group = 1; break; case 'n': use_name = 1; break; case 'r': use_real = 1; break; case 'u': just_user = 1; break; case 'G': just_group_list = 1; break; default: usage (1); } } if (show_version) { printf ("id - %s\n", version_string); exit (0); } if (show_help) usage (0); if (just_user + just_group + just_group_list > 1) error (1, 0, "cannot print only user and only group"); if (just_user + just_group + just_group_list == 0 && (use_real || use_name)) error (1, 0, "cannot print only names or real IDs in default format"); if (argc - optind > 1) usage (1); if (argc - optind == 1) { struct passwd *pwd = getpwnam (argv[optind]); if (pwd == NULL) error (1, 0, "%s: No such user", argv[optind]); ruid = euid = pwd->pw_uid; rgid = egid = pwd->pw_gid; } else { euid = geteuid (); ruid = getuid (); egid = getegid (); rgid = getgid (); } if (just_user) print_user (use_real ? ruid : euid); else if (just_group) print_group (use_real ? rgid : egid); else if (just_group_list) print_group_list (argv[optind]); else print_full_info (argv[optind]); putchar ('\n'); exit (problems != 0); } /* Print the name or value of user ID UID. */ static void print_user (uid) int uid; { struct passwd *pwd = NULL; if (use_name) { pwd = getpwuid (uid); if (pwd == NULL) problems++; } if (pwd == NULL) printf ("%u", (unsigned) uid); else printf ("%s", pwd->pw_name); } /* Print the name or value of group ID GID. */ static void print_group (gid) int gid; { struct group *grp = NULL; if (use_name) { grp = getgrgid (gid); if (grp == NULL) problems++; } if (grp == NULL) printf ("%u", (unsigned) gid); else printf ("%s", grp->gr_name); } /* Print all of the distinct groups the user is in . */ static void print_group_list (username) char *username; { print_group (rgid); if (egid != rgid) { putchar (' '); print_group (egid); } #ifdef NGROUPS_MAX { int ngroups; GETGROUPS_T *groups; register int i; groups = (GETGROUPS_T *) xmalloc (NGROUPS_MAX * sizeof (GETGROUPS_T)); if (username == 0) ngroups = getgroups (NGROUPS_MAX, groups); else ngroups = getugroups (NGROUPS_MAX, groups, username); if (ngroups < 0) { error (0, errno, "cannot get supplemental group list"); problems++; free (groups); return; } for (i = 0; i < ngroups; i++) if (groups[i] != rgid && groups[i] != egid) { putchar (' '); print_group (groups[i]); } free (groups); } #endif } /* Print all of the info about the user's user and group IDs. */ static void print_full_info (username) char *username; { struct passwd *pwd; struct group *grp; printf ("uid=%u", (unsigned) ruid); pwd = getpwuid (ruid); if (pwd == NULL) problems++; else printf ("(%s)", pwd->pw_name); printf (" gid=%u", (unsigned) rgid); grp = getgrgid (rgid); if (grp == NULL) problems++; else printf ("(%s)", grp->gr_name); if (euid != ruid) { printf (" euid=%u", (unsigned) euid); pwd = getpwuid (euid); if (pwd == NULL) problems++; else printf ("(%s)", pwd->pw_name); } if (egid != rgid) { printf (" egid=%u", (unsigned) egid); grp = getgrgid (egid); if (grp == NULL) problems++; else printf ("(%s)", grp->gr_name); } #ifdef NGROUPS_MAX { int ngroups; GETGROUPS_T *groups; register int i; groups = (GETGROUPS_T *) xmalloc (NGROUPS_MAX * sizeof (GETGROUPS_T)); if (username == 0) ngroups = getgroups (NGROUPS_MAX, groups); else ngroups = getugroups (NGROUPS_MAX, groups, username); if (ngroups < 0) { error (0, errno, "cannot get supplemental group list"); problems++; free (groups); return; } if (ngroups > 0) fputs (" groups=", stdout); for (i = 0; i < ngroups; i++) { if (i > 0) putchar (','); printf ("%u", (unsigned) groups[i]); grp = getgrgid (groups[i]); if (grp == NULL) problems++; else printf ("(%s)", grp->gr_name); } free (groups); } #endif } static void usage (status) int status; { if (status != 0) fprintf (stderr, "Try `%s --help' for more information.\n", program_name); else { printf ("Usage: %s [OPTION]... [USERNAME]\n", program_name); printf ("\ \n\ -g, --group print only the group ID\n\ -G, --groups print only the supplementary groups\n\ -n, --name print a name instead of a number, for -ugG\n\ -r, --real print the real ID instead of effective ID, for -ugG\n\ -u, --user print only the user ID\n\ --help display this help and exit\n\ --version output version information and exit\n\ \n\ Without any OPTION, print some useful set of identified information.\n\ "); } exit (status); } sh-utils-1.10/src/hostname.c100644 74504 1 5644 5566704125 15317 0ustar meyeringdaemon/* hostname - set or print the name of current host system Copyright (C) 1994 Free Software Foundation, Inc. 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 2, 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, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ /* Jim Meyering */ #ifdef HAVE_CONFIG_H #if defined (CONFIG_BROKETS) /* We use instead of "config.h" so that a compilation using -I. -I$srcdir will use ./config.h rather than $srcdir/config.h (which it would do because it found this file in $srcdir). */ #include #else #include "config.h" #endif #endif #include #include #include "system.h" #include "long-options.h" #if !defined(HAVE_SETHOSTNAME) && defined(HAVE_SYSINFO) && \ defined (HAVE_SYS_SYSTEMINFO_H) && defined(HAVE_LIMITS_H) #include #include int sethostname (name, namelen) char *name; int namelen; { /* Using sysinfo() is the SVR4 mechanism to set a hostname. */ int result; result = sysinfo (SI_SET_HOSTNAME, name, namelen); return (result == -1 ? result : 0); } #define HAVE_SETHOSTNAME 1 /* Now we have it... */ #endif void error (); char *xgethostname (); /* The name this program was run with. */ char *program_name; static void usage (status) int status; { if (status != 0) fprintf (stderr, "Try `%s --help' for more information.\n", program_name); else { printf ("\ Usage: %s [NAME]\n\ or: %s OPTION\n\ \n\ --help display this help and exit\n\ --version output version information and exit\n\ " , program_name, program_name); } exit (status); } void main (argc, argv) int argc; char **argv; { char *hostname; program_name = argv[0]; parse_long_options (argc, argv, "hostname", usage); #ifdef HAVE_SETHOSTNAME if (argc == 2) { int err; /* Set hostname to argv[1]. */ err = sethostname (argv[1], strlen (argv[1])); if (err != 0) error (1, errno, "%s", argv[1]); exit (0); } #else if (argc == 2) error (1, 0, "cannot set hostname; this system lacks the functionality"); #endif if (argc == 1) { hostname = xgethostname (); if (hostname == NULL) error (1, errno, "cannot determine hostname"); printf ("%s\n", hostname); } else { error (2, 0, "too many arguments"); usage (1); } exit (0); } sh-utils-1.10/src/logname.c100666 74504 1 5153 5555072443 15121 0ustar meyeringdaemon/* logname -- print user's login name Copyright (C) 90, 91, 92, 93, 1994 Free Software Foundation, Inc. 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 2, 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, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #ifdef HAVE_CONFIG_H #if defined (CONFIG_BROKETS) /* We use instead of "config.h" so that a compilation using -I. -I$srcdir will use ./config.h rather than $srcdir/config.h (which it would do because it found this file in $srcdir). */ #include #else #include "config.h" #endif #endif #include #include #include #include "version.h" #include "system.h" /* The name this program was run with. */ char *program_name; /* If non-zero, display usage information and exit. */ static int show_help; /* If non-zero, print the version on standard output and exit. */ static int show_version; static struct option const long_options[] = { {"help", no_argument, &show_help, 1}, {"version", no_argument, &show_version, 1}, {0, 0, 0, 0} }; static void usage (status) int status; { if (status != 0) fprintf (stderr, "Try `%s --help' for more information.\n", program_name); else { printf ("Usage: %s [OPTION]...\n", program_name); printf ("\ \n\ --help display this help and exit\n\ --version output version information and exit\n\ "); } exit (status); } void main (argc, argv) int argc; char **argv; { register char *cp; int c; program_name = argv[0]; while ((c = getopt_long (argc, argv, "", long_options, (int *) 0)) != EOF) { switch (c) { case 0: break; default: usage (1); } } if (show_version) { printf ("logname - %s\n", version_string); exit (0); } if (show_help) usage (0); if (argc - optind != 0) usage (1); /* POSIX.2 requires using getlogin (or equivalent code). */ cp = getlogin (); if (cp) { puts (cp); exit (0); } /* POSIX.2 prohibits using a fallback technique. */ fprintf (stderr,"%s: no login name\n", argv[0]); exit (1); } sh-utils-1.10/src/long-options.c100644 74504 1 4454 5555072444 16127 0ustar meyeringdaemon/* Utility to accept --help and --version options as unobtrusively as possible. Copyright (C) 1993, 1994 Free Software Foundation, Inc. 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 2, 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, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ /* Jim Meyering (meyering@comco.com) */ #ifdef HAVE_CONFIG_H #if defined (CONFIG_BROKETS) /* We use instead of "config.h" so that a compilation using -I. -I$srcdir will use ./config.h rather than $srcdir/config.h (which it would do because it found this file in $srcdir). */ #include #else #include "config.h" #endif #endif #include #include #include #include "system.h" #include "version.h" #include "long-options.h" static struct option const long_options[] = { {"help", no_argument, 0, 'h'}, {"version", no_argument, 0, 'v'}, {0, 0, 0, 0} }; /* Process long options --help and --version, but only if argc == 2. Be careful not to gobble up `--'. */ void parse_long_options (argc, argv, command_name, usage) int argc; char **argv; const char *command_name; void (*usage)(); { int c; int saved_opterr; int saved_optind; saved_opterr = opterr; saved_optind = optind; /* Don't print an error message for unrecognized options. */ opterr = 0; if (argc == 2 && (c = getopt_long (argc, argv, "+", long_options, (int *) 0)) != EOF) { switch (c) { case 'h': (*usage) (0); case 'v': printf ("%s - %s\n", command_name, version_string); exit (0); default: /* Don't process any other long-named options. */ break; } } /* Restore previous value. */ opterr = saved_opterr; /* Restore optind in case it has advanced past a leading `--'. */ optind = saved_optind; } sh-utils-1.10/src/pathchk.c100666 74504 1 23333 5564702121 15132 0ustar meyeringdaemon/* pathchk -- check whether pathnames are valid or portable Copyright (C) 91, 92, 93, 1994 Free Software Foundation, Inc. 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 2, 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, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ /* Usage: pathchk [-p] [--portability] path... For each PATH, print a message if any of these conditions are false: * all existing leading directories in PATH have search (execute) permission * strlen (PATH) <= PATH_MAX * strlen (each_directory_in_PATH) <= NAME_MAX Exit status: 0 All PATH names passed all of the tests. 1 An error occurred. Options: -p, --portability Instead of performing length checks on the underlying filesystem, test the length of the pathname and its components against the POSIX.1 minimum limits for portability, _POSIX_NAME_MAX and _POSIX_PATH_MAX in 2.9.2. Also check that the pathname contains no character not in the portable filename character set. David MacKenzie and Jim Meyering */ #ifdef HAVE_CONFIG_H #if defined (CONFIG_BROKETS) /* We use instead of "config.h" so that a compilation using -I. -I$srcdir will use ./config.h rather than $srcdir/config.h (which it would do because it found this file in $srcdir). */ #include #else #include "config.h" #endif #endif #include #include #include #include "version.h" #include "system.h" #ifdef _POSIX_VERSION #include #ifndef PATH_MAX #define PATH_MAX_FOR(p) pathconf ((p), _PC_PATH_MAX) #endif /* not PATH_MAX */ #ifndef NAME_MAX #define NAME_MAX_FOR(p) pathconf ((p), _PC_NAME_MAX); #endif /* not NAME_MAX */ #else /* not _POSIX_VERSION */ #include #ifndef PATH_MAX #ifdef MAXPATHLEN #define PATH_MAX MAXPATHLEN #else /* not MAXPATHLEN */ #define PATH_MAX _POSIX_PATH_MAX #endif /* not MAXPATHLEN */ #endif /* not PATH_MAX */ #ifndef NAME_MAX #ifdef MAXNAMLEN #define NAME_MAX MAXNAMLEN #else /* not MAXNAMLEN */ #define NAME_MAX _POSIX_NAME_MAX #endif /* not MAXNAMLEN */ #endif /* not NAME_MAX */ #endif /* not _POSIX_VERSION */ #ifndef _POSIX_PATH_MAX #define _POSIX_PATH_MAX 255 #endif #ifndef _POSIX_NAME_MAX #define _POSIX_NAME_MAX 14 #endif #ifndef PATH_MAX_FOR #define PATH_MAX_FOR(p) PATH_MAX #endif #ifndef NAME_MAX_FOR #define NAME_MAX_FOR(p) NAME_MAX #endif char *xstrdup (); void error (); static int validate_path (); static void usage (); /* The name this program was run with. */ char *program_name; /* If non-zero, display usage information and exit. */ static int show_help; /* If non-zero, print the version on standard output and exit. */ static int show_version; static struct option const longopts[] = { {"help", no_argument, &show_help, 1}, {"portability", no_argument, NULL, 'p'}, {"version", no_argument, &show_version, 1}, {NULL, 0, NULL, 0} }; void main (argc, argv) int argc; char **argv; { int exit_status = 0; int check_portability = 0; int optc; program_name = argv[0]; while ((optc = getopt_long (argc, argv, "p", longopts, (int *) 0)) != EOF) { switch (optc) { case 0: break; case 'p': check_portability = 1; break; default: usage (1); } } if (show_version) { printf ("pathchk - %s\n", version_string); exit (0); } if (show_help) usage (0); if (optind == argc) usage (1); for (; optind < argc; ++optind) exit_status |= validate_path (argv[optind], check_portability); exit (exit_status); } /* Each element is nonzero if the corresponding ASCII character is in the POSIX portable character set, and zero if it is not. In addition, the entry for `/' is nonzero to simplify checking. */ static char const portable_chars[256] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0-15 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 16-31 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, /* 32-47 */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, /* 48-63 */ 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 64-79 */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, /* 80-95 */ 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 96-111 */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, /* 112-127 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; /* If PATH contains only portable characters, return 1, else 0. */ static int portable_chars_only (path) const char *path; { const char *p; for (p = path; *p; ++p) if (portable_chars[(const unsigned char) *p] == 0) { error (0, 0, "path `%s' contains nonportable character `%c'", path, *p); return 0; } return 1; } /* Return 1 if PATH is a usable leading directory, 0 if not, 2 if it doesn't exist. */ static int dir_ok (path) const char *path; { struct stat stats; if (stat (path, &stats)) return 2; if (!S_ISDIR (stats.st_mode)) { error (0, 0, "`%s' is not a directory", path); return 0; } /* Use access to test for search permission because testing permission bits of st_mode can lose with new access control mechanisms. Of course, access loses if you're running setuid. */ if (access (path, X_OK) != 0) { if (errno == EACCES) error (0, 0, "directory `%s' is not searchable", path); else error (0, errno, "%s", path); return 0; } return 1; } /* Make sure that strlen (PATH) <= PATH_MAX && strlen (each-existing-directory-in-PATH) <= NAME_MAX If PORTABILITY is nonzero, compare against _POSIX_PATH_MAX and _POSIX_NAME_MAX instead, and make sure that PATH contains no characters not in the POSIX portable filename character set, which consists of A-Z, a-z, 0-9, ., _, -. Make sure that all leading directories along PATH that exist have `x' permission. Return 0 if all of these tests are successful, 1 if any fail. */ static int validate_path (path, portability) char *path; int portability; { int path_max; int last_elem; /* Nonzero if checking last element of path. */ int exists; /* 2 if the path element exists. */ char *slash; char *parent; /* Last existing leading directory so far. */ if (portability && !portable_chars_only (path)) return 1; if (*path == '\0') return 0; #ifdef lint /* Suppress `used before initialized' warning. */ exists = 0; #endif /* Figure out the parent of the first element in PATH. */ parent = xstrdup (*path == '/' ? "/" : "."); slash = path; last_elem = 0; while (1) { int name_max; int length; /* Length of partial path being checked. */ char *start; /* Start of path element being checked. */ /* Find the end of this element of the path. Then chop off the rest of the path after this element. */ while (*slash == '/') slash++; start = slash; slash = index (slash, '/'); if (slash != NULL) *slash = '\0'; else { last_elem = 1; slash = index (start, '\0'); } if (!last_elem) { exists = dir_ok (path); if (dir_ok == 0) { free (parent); return 1; } } length = slash - start; /* Since we know that `parent' is a directory, it's ok to call pathconf with it as the argument. (If `parent' isn't a directory or doesn't exist, the behavior of pathconf is undefined.) But if `parent' is a directory and is on a remote file system, it's likely that pathconf can't give us a reasonable value and will return -1. (NFS and tempfs are not POSIX . . .) In that case, we have no choice but to assume the pessimal POSIX minimums. */ name_max = portability ? _POSIX_NAME_MAX : NAME_MAX_FOR (parent); if (name_max < 0) name_max = _POSIX_NAME_MAX; if (length > name_max) { error (0, 0, "name `%s' has length %d; exceeds limit of %d", start, length, name_max); free (parent); return 1; } if (last_elem) break; if (exists == 1) { free (parent); parent = xstrdup (path); } *slash++ = '/'; } /* `parent' is now the last existing leading directory in the whole path, so it's ok to call pathconf with it as the argument. */ path_max = portability ? _POSIX_PATH_MAX : PATH_MAX_FOR (parent); if (path_max < 0) path_max = _POSIX_PATH_MAX; free (parent); if (strlen (path) > path_max) { error (0, 0, "path `%s' has length %d; exceeds limit of %d", path, strlen (path), path_max); return 1; } return 0; } static void usage (status) int status; { if (status != 0) fprintf (stderr, "Try `%s --help' for more information.\n", program_name); else { printf ("Usage: %s [OPTION]... PATH...\n", program_name); printf ("\ \n\ -p, --portability check for all POSIX systems, not only this one\n\ --help display this help and exit\n\ --version output version information and exit\n\ "); } exit (status); } sh-utils-1.10/src/printenv.c100666 74504 1 6630 5555072451 15344 0ustar meyeringdaemon/* printenv -- print all or part of environment Copyright (C) 89, 90, 91, 92, 93, 1994 Free Software Foundation, Inc. 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 2, 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, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ /* Usage: printenv [variable...] If no arguments are given, print the entire environment. If one or more variable names are given, print the value of each one that is set, and nothing for ones that are not set. Exit status: 0 if all variables specified were found 1 if not David MacKenzie and Richard Mlynarik */ #ifdef HAVE_CONFIG_H #if defined (CONFIG_BROKETS) /* We use instead of "config.h" so that a compilation using -I. -I$srcdir will use ./config.h rather than $srcdir/config.h (which it would do because it found this file in $srcdir). */ #include #else #include "config.h" #endif #endif #include #include #include #include "version.h" #include "system.h" void error (); /* The name this program was run with. */ char *program_name; /* If non-zero, display usage information and exit. */ static int show_help; /* If non-zero, print the version on standard output and exit. */ static int show_version; static struct option const long_options[] = { {"help", no_argument, &show_help, 1}, {"version", no_argument, &show_version, 1}, {0, 0, 0, 0} }; extern char **environ; static void usage (status) int status; { if (status != 0) fprintf (stderr, "Try `%s --help' for more information.\n", program_name); else { printf ("Usage: %s [OPTION]... [VARIABLE]...\n", program_name); printf ("\ \n\ --help display this help and exit\n\ --version output version information and exit\n\ \n\ If no VARIABLE, print them all.\n\ "); } exit (status); } void main (argc, argv) int argc; char **argv; { char **env; char *ep, *ap; int i; int matches = 0; int c; int exit_status; program_name = argv[0]; while ((c = getopt_long (argc, argv, "", long_options, (int *) 0)) != EOF) { switch (c) { case 0: break; default: usage (1); } } if (show_version) { printf ("printenv - %s\n", version_string); exit (0); } if (show_help) usage (0); if (optind == argc) { for (env = environ; *env != NULL; ++env) puts (*env); exit_status = 0; } else { for (i = optind; i < argc; ++i) { for (env = environ; *env; ++env) { ep = *env; ap = argv[i]; while (*ep != '\0' && *ap != '\0' && *ep++ == *ap++) { if (*ep == '=' && *ap == '\0') { puts (ep + 1); ++matches; break; } } } } exit_status = (matches != argc - optind); } if (ferror (stdout) || fclose (stdout) == EOF) error (2, errno, "standard output"); exit (exit_status); } sh-utils-1.10/src/printf.c100666 74504 13 26360 5554616571 14567 0ustar meyeringuser/* printf - format and print data Copyright (C) 90, 91, 92, 93, 1994 Free Software Foundation, Inc. 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 2, 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, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ /* Usage: printf format [argument...] A front end to the printf function that lets it be used from the shell. Backslash escapes: \" = double quote \\ = backslash \a = alert (bell) \b = backspace \c = produce no further output \f = form feed \n = new line \r = carriage return \t = horizontal tab \v = vertical tab \0ooo = octal number (ooo is 0 to 3 digits) \xhhh = hexadecimal number (hhh is 1 to 3 digits) Additional directive: %b = print an argument string, interpreting backslash escapes The `format' argument is re-used as many times as necessary to convert all of the given arguments. David MacKenzie */ #ifdef HAVE_CONFIG_H #if defined (CONFIG_BROKETS) /* We use instead of "config.h" so that a compilation using -I. -I$srcdir will use ./config.h rather than $srcdir/config.h (which it would do because it found this file in $srcdir). */ #include #else #include "config.h" #endif #endif #include #include #include #include #include "system.h" #include "version.h" #include "long-options.h" #if defined (STDC_HEADERS) || (!defined (isascii) && !defined (HAVE_ISASCII)) #define ISASCII(c) 1 #else #define ISASCII(c) isascii(c) #endif #define ISDIGIT(c) (ISASCII (c) && isdigit (c)) #define ISXDIGIT(c) (ISASCII (c) && isxdigit (c)) #ifndef STDC_HEADERS double strtod (); long strtol (); unsigned long strtoul (); #endif #define isodigit(c) ((c) >= '0' && (c) <= '7') #define hextobin(c) ((c)>='a'&&(c)<='f' ? (c)-'a'+10 : (c)>='A'&&(c)<='F' ? (c)-'A'+10 : (c)-'0') #define octtobin(c) ((c) - '0') char *xmalloc (); void error (); static double xstrtod (); static int print_esc (); static int print_formatted (); static long xstrtol (); static unsigned long xstrtoul (); static void print_direc (); static void print_esc_char (); static void print_esc_string (); static void verify (); /* The value to return to the calling program. */ static int exit_status; /* The name this program was run with. */ char *program_name; static void usage (status) int status; { if (status != 0) fprintf (stderr, "Try `%s --help' for more information.\n", program_name); else { printf ("\ Usage: %s FORMAT [ARGUMENT]...\n\ or: %s OPTION\n\ ", program_name, program_name); printf ("\ \n\ --help display this help and exit\n\ --version output version information and exit\n\ \n\ FORMAT controls the output as in C printf. Interpreted sequences are:\n\ \n\ \\\" double quote\n\ \\0NNN character with octal value NNN (0 to 3 digits)\n\ \\\\ backslash\n\ \\a alert (BEL)\n\ \\b backspace\n\ \\c produce no further output\n\ \\f form feed\n\ \\n new line\n\ \\r carriage return\n\ \\t horizontal tab\n\ \\v vertical tab\n\ \\xNNN character with hexadecimal value NNN (1 to 3 digits)\n\ \n\ %%%% a single %%\n\ %%b ARGUMENT as a string with `\\' escapes interpreted\n\ \n\ and all C format specifications ending with one of diouxXfeEgGcs, with\n\ ARGUMENTs converted to proper type first. Variable widths are handled.\n\ "); } exit (status); } void main (argc, argv) int argc; char **argv; { char *format; int args_used; program_name = argv[0]; exit_status = 0; parse_long_options (argc, argv, "printf", usage); if (argc == 1) { fprintf (stderr, "Usage: %s format [argument...]\n", program_name); exit (1); } format = argv[1]; argc -= 2; argv += 2; do { args_used = print_formatted (format, argc, argv); argc -= args_used; argv += args_used; } while (args_used > 0 && argc > 0); exit (exit_status); } /* Print the text in FORMAT, using ARGV (with ARGC elements) for arguments to any `%' directives. Return the number of elements of ARGV used. */ static int print_formatted (format, argc, argv) char *format; int argc; char **argv; { int save_argc = argc; /* Preserve original value. */ char *f; /* Pointer into `format'. */ char *direc_start; /* Start of % directive. */ int direc_length; /* Length of % directive. */ int field_width; /* Arg to first '*', or -1 if none. */ int precision; /* Arg to second '*', or -1 if none. */ for (f = format; *f; ++f) { switch (*f) { case '%': direc_start = f++; direc_length = 1; field_width = precision = -1; if (*f == '%') { putchar ('%'); break; } if (*f == 'b') { if (argc > 0) { print_esc_string (*argv); ++argv; --argc; } break; } if (index ("-+ #", *f)) { ++f; ++direc_length; } if (*f == '*') { ++f; ++direc_length; if (argc > 0) { field_width = xstrtoul (*argv); ++argv; --argc; } else field_width = 0; } else while (ISDIGIT (*f)) { ++f; ++direc_length; } if (*f == '.') { ++f; ++direc_length; if (*f == '*') { ++f; ++direc_length; if (argc > 0) { precision = xstrtoul (*argv); ++argv; --argc; } else precision = 0; } else while (ISDIGIT (*f)) { ++f; ++direc_length; } } if (*f == 'l' || *f == 'L' || *f == 'h') { ++f; ++direc_length; } if (!index ("diouxXfeEgGcs", *f)) error (1, 0, "%%%c: invalid directive", *f); ++direc_length; if (argc > 0) { print_direc (direc_start, direc_length, field_width, precision, *argv); ++argv; --argc; } else print_direc (direc_start, direc_length, field_width, precision, ""); break; case '\\': f += print_esc (f); break; default: putchar (*f); } } return save_argc - argc; } /* Print a \ escape sequence starting at ESCSTART. Return the number of characters in the escape sequence besides the backslash. */ static int print_esc (escstart) char *escstart; { register char *p = escstart + 1; int esc_value = 0; /* Value of \nnn escape. */ int esc_length; /* Length of \nnn escape. */ /* \0ooo and \xhhh escapes have maximum length of 3 chars. */ if (*p == 'x') { for (esc_length = 0, ++p; esc_length < 3 && ISXDIGIT (*p); ++esc_length, ++p) esc_value = esc_value * 16 + hextobin (*p); if (esc_length == 0) error (1, 0, "missing hexadecimal number in escape"); putchar (esc_value); } else if (*p == '0') { for (esc_length = 0, ++p; esc_length < 3 && isodigit (*p); ++esc_length, ++p) esc_value = esc_value * 8 + octtobin (*p); putchar (esc_value); } else if (index ("\"\\abcfnrtv", *p)) print_esc_char (*p++); else error (1, 0, "\\%c: invalid escape", *p); return p - escstart - 1; } /* Output a single-character \ escape. */ static void print_esc_char (c) char c; { switch (c) { case 'a': /* Alert. */ putchar (7); break; case 'b': /* Backspace. */ putchar (8); break; case 'c': /* Cancel the rest of the output. */ exit (0); break; case 'f': /* Form feed. */ putchar (12); break; case 'n': /* New line. */ putchar (10); break; case 'r': /* Carriage return. */ putchar (13); break; case 't': /* Horizontal tab. */ putchar (9); break; case 'v': /* Vertical tab. */ putchar (11); break; default: putchar (c); break; } } /* Print string STR, evaluating \ escapes. */ static void print_esc_string (str) char *str; { for (; *str; str++) if (*str == '\\') str += print_esc (str); else putchar (*str); } /* Output a % directive. START is the start of the directive, LENGTH is its length, and ARGUMENT is its argument. If FIELD_WIDTH or PRECISION is non-negative, they are args for '*' values in those fields. */ static void print_direc (start, length, field_width, precision, argument) char *start; int length; int field_width; int precision; char *argument; { char *p; /* Null-terminated copy of % directive. */ p = xmalloc ((unsigned) (length + 1)); strncpy (p, start, length); p[length] = 0; switch (p[length - 1]) { case 'd': case 'i': if (field_width < 0) { if (precision < 0) printf (p, xstrtol (argument)); else printf (p, precision, xstrtol (argument)); } else { if (precision < 0) printf (p, field_width, xstrtol (argument)); else printf (p, field_width, precision, xstrtol (argument)); } break; case 'o': case 'u': case 'x': case 'X': if (field_width < 0) { if (precision < 0) printf (p, xstrtoul (argument)); else printf (p, precision, xstrtoul (argument)); } else { if (precision < 0) printf (p, field_width, xstrtoul (argument)); else printf (p, field_width, precision, xstrtoul (argument)); } break; case 'f': case 'e': case 'E': case 'g': case 'G': if (field_width < 0) { if (precision < 0) printf (p, xstrtod (argument)); else printf (p, precision, xstrtod (argument)); } else { if (precision < 0) printf (p, field_width, xstrtod (argument)); else printf (p, field_width, precision, xstrtod (argument)); } break; case 'c': printf (p, *argument); break; case 's': if (field_width < 0) { if (precision < 0) printf (p, argument); else printf (p, precision, argument); } else { if (precision < 0) printf (p, field_width, argument); else printf (p, field_width, precision, argument); } break; } free (p); } static unsigned long xstrtoul (s) char *s; { char *end; unsigned long val; errno = 0; val = strtoul (s, &end, 0); verify (s, end); return val; } static long xstrtol (s) char *s; { char *end; long val; errno = 0; val = strtol (s, &end, 0); verify (s, end); return val; } static double xstrtod (s) char *s; { char *end; double val; errno = 0; val = strtod (s, &end); verify (s, end); return val; } static void verify (s, end) char *s, *end; { if (errno) { error (0, errno, "%s", s); exit_status = 1; } else if (*end) { if (s == end) error (0, 0, "%s: expected a numeric value", s); else error (0, 0, "%s: value not completely converted", s); exit_status = 1; } } sh-utils-1.10/src/pwd.c100644 74504 1 3746 5565025641 14272 0ustar meyeringdaemon/* pwd - print current directory Copyright (C) 1994 Free Software Foundation, Inc. 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 2, 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, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ /* Jim Meyering */ #ifdef HAVE_CONFIG_H #if defined (CONFIG_BROKETS) /* We use instead of "config.h" so that a compilation using -I. -I$srcdir will use ./config.h rather than $srcdir/config.h (which it would do because it found this file in $srcdir). */ #include #else #include "config.h" #endif #endif #include #include #include "system.h" #include "long-options.h" void error (); char *xgetcwd (); /* The name this program was run with. */ char *program_name; static void usage (status) int status; { if (status != 0) fprintf (stderr, "Try `%s --help' for more information.\n", program_name); else { printf ("Usage: %s [OPTION]\n", program_name); printf ("\ \n\ --help display this help and exit\n\ --version output version information and exit\n\ "); } exit (status); } void main (argc, argv) int argc; char **argv; { char *wd; program_name = argv[0]; parse_long_options (argc, argv, "pwd", usage); if (argc != 1) error (0, 0, "ignoring non-option arguments"); wd = xgetcwd (); if (wd == NULL) error (1, errno, "cannot get current directory"); printf ("%s\n", wd); exit (0); } sh-utils-1.10/src/sleep.c100666 74504 1 6244 5555072452 14611 0ustar meyeringdaemon/* sleep - delay for a specified amount of time. Copyright (C) 84, 91, 92, 93, 1994 Free Software Foundation, Inc. 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 2, 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, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #ifdef HAVE_CONFIG_H #if defined (CONFIG_BROKETS) /* We use instead of "config.h" so that a compilation using -I. -I$srcdir will use ./config.h rather than $srcdir/config.h (which it would do because it found this file in $srcdir). */ #include #else #include "config.h" #endif #endif #include #include #include #include "version.h" #include "system.h" void error (); static long argdecode (); /* The name by which this program was run. */ char *program_name; /* If non-zero, display usage information and exit. */ static int show_help; /* If non-zero, print the version on standard output and exit. */ static int show_version; static struct option const long_options[] = { {"help", no_argument, &show_help, 1}, {"version", no_argument, &show_version, 1}, {0, 0, 0, 0} }; static void usage (status) int status; { if (status != 0) fprintf (stderr, "Try `%s --help' for more information.\n", program_name); else { printf ("Usage: %s [OPTION]... NUMBER[SUFFIX]\n", program_name); printf ("\ \n\ --help display this help and exit\n\ --version output version information and exit\n\ \n\ SUFFIX may be s for seconds, m for minutes, h for hours or d for days.\n\ "); } exit (status); } void main (argc, argv) int argc; char **argv; { int i; unsigned seconds = 0; int c; program_name = argv[0]; while ((c = getopt_long (argc, argv, "", long_options, (int *) 0)) != EOF) { switch (c) { case 0: break; default: usage (1); } } if (show_version) { printf ("sleep - %s\n", version_string); exit (0); } if (show_help) usage (0); if (argc == 1) { fprintf (stderr, "Usage: %s number[smhd]...\n", argv[0]); exit (1); } for (i = 1; i < argc; i++) seconds += argdecode (argv[i]); sleep (seconds); exit (0); } static long argdecode (s) char *s; { long value; register char *p = s; register char c; value = 0; while ((c = *p++) >= '0' && c <= '9') value = value * 10 + c - '0'; switch (c) { case 's': break; case 'm': value *= 60; break; case 'h': value *= 60 * 60; break; case 'd': value *= 60 * 60 * 24; break; default: p--; } if (*p) error (1, 0, "invalid time interval `%s'", s); return value; } sh-utils-1.10/src/su.c100666 74504 1 34705 5555072455 14156 0ustar meyeringdaemon/* su for GNU. Run a shell with substitute user and group IDs. Copyright (C) 92, 93, 1994 Free Software Foundation, Inc. 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 2, 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, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ /* Run a shell with the real and effective UID and GID and groups of USER, default `root'. The shell run is taken from USER's password entry, /bin/sh if none is specified there. If the account has a password, su prompts for a password unless run by a user with real UID 0. Does not change the current directory. Sets `HOME' and `SHELL' from the password entry for USER, and if USER is not root, sets `USER' and `LOGNAME' to USER. The subshell is not a login shell. If one or more ARGs are given, they are passed as additional arguments to the subshell. Does not handle /bin/sh or other shells specially (setting argv[0] to "-su", passing -c only to certain shells, etc.). I don't see the point in doing that, and it's ugly. This program intentionally does not support a "wheel group" that restricts who can su to UID 0 accounts. RMS considers that to be fascist. Options: -, -l, --login Make the subshell a login shell. Unset all environment variables except TERM, HOME and SHELL (set as above), and USER and LOGNAME (set unconditionally as above), and set PATH to a default value. Change to USER's home directory. Prepend "-" to the shell's name. -c, --commmand=COMMAND Pass COMMAND to the subshell with a -c option instead of starting an interactive shell. -f, --fast Pass the -f option to the subshell. -m, -p, --preserve-environment Do not change HOME, USER, LOGNAME, SHELL. Run $SHELL instead of USER's shell from /etc/passwd unless not the superuser and USER's shell is restricted. Overridden by --login and --shell. -s, --shell=shell Run SHELL instead of USER's shell from /etc/passwd unless not the superuser and USER's shell is restricted. Compile-time options: -DSYSLOG_SUCCESS Log successful su's (by default, to root) with syslog. -DSYSLOG_FAILURE Log failed su's (by default, to root) with syslog. -DSYSLOG_NON_ROOT Log all su's, not just those to root (UID 0). Never logs attempted su's to nonexistent accounts. Written by David MacKenzie . */ #ifdef HAVE_CONFIG_H #if defined (CONFIG_BROKETS) /* We use instead of "config.h" so that a compilation using -I. -I$srcdir will use ./config.h rather than $srcdir/config.h (which it would do because it found this file in $srcdir). */ #include #else #include "config.h" #endif #endif #include #include #include #include #include #include "system.h" #ifdef HAVE_SYSLOG_H #include static void log_su (); #else /* !HAVE_SYSLOG_H */ #ifdef SYSLOG_SUCCESS #undef SYSLOG_SUCCESS #endif #ifdef SYSLOG_FAILURE #undef SYSLOG_FAILURE #endif #ifdef SYSLOG_NON_ROOT #undef SYSLOG_NON_ROOT #endif #endif /* !HAVE_SYSLOG_H */ #ifdef _POSIX_VERSION #include #ifdef NGROUPS_MAX #undef NGROUPS_MAX #endif #define NGROUPS_MAX sysconf (_SC_NGROUPS_MAX) #else /* not _POSIX_VERSION */ struct passwd *getpwuid (); struct group *getgrgid (); uid_t getuid (); #include #if !defined(NGROUPS_MAX) && defined(NGROUPS) #define NGROUPS_MAX NGROUPS #endif #endif /* not _POSIX_VERSION */ #ifdef _POSIX_SOURCE #define endgrent() #define endpwent() #endif #ifdef HAVE_SHADOW_H #include #endif #include "version.h" /* The default PATH for simulated logins to non-superuser accounts. */ #define DEFAULT_LOGIN_PATH ":/usr/ucb:/bin:/usr/bin" /* The default PATH for simulated logins to superuser accounts. */ #define DEFAULT_ROOT_LOGIN_PATH "/usr/ucb:/bin:/usr/bin:/etc" /* The shell to run if none is given in the user's passwd entry. */ #define DEFAULT_SHELL "/bin/sh" /* The user to become if none is specified. */ #define DEFAULT_USER "root" char *crypt (); char *getpass (); char *getusershell (); void endusershell (); void setusershell (); char *basename (); char *xmalloc (); char *xrealloc (); void error (); static char *concat (); static int correct_password (); static int elements (); static int restricted_shell (); static void change_identity (); static void modify_environment (); static void run_shell (); static void usage (); static void xputenv (); extern char **environ; /* The name this program was run with. */ char *program_name; /* If non-zero, display usage information and exit. */ static int show_help; /* If non-zero, print the version on standard output and exit. */ static int show_version; /* If nonzero, pass the `-f' option to the subshell. */ static int fast_startup; /* If nonzero, simulate a login instead of just starting a shell. */ static int simulate_login; /* If nonzero, change some environment vars to indicate the user su'd to. */ static int change_environment; static struct option const longopts[] = { {"command", required_argument, 0, 'c'}, {"fast", no_argument, &fast_startup, 1}, {"help", no_argument, &show_help, 1}, {"login", no_argument, &simulate_login, 1}, {"preserve-environment", no_argument, &change_environment, 0}, {"shell", required_argument, 0, 's'}, {"version", no_argument, &show_version, 1}, {0, 0, 0, 0} }; void main (argc, argv) int argc; char **argv; { int optc; char *new_user = DEFAULT_USER; char *command = 0; char **additional_args = 0; char *shell = 0; struct passwd *pw; program_name = argv[0]; fast_startup = 0; simulate_login = 0; change_environment = 1; while ((optc = getopt_long (argc, argv, "c:flmps:", longopts, (int *) 0)) != EOF) { switch (optc) { case 0: break; case 'c': command = optarg; break; case 'f': fast_startup = 1; break; case 'l': simulate_login = 1; break; case 'm': case 'p': change_environment = 0; break; case 's': shell = optarg; break; default: usage (1); } } if (show_version) { printf ("su - %s\n", version_string); exit (0); } if (show_help) usage (0); if (optind < argc && !strcmp (argv[optind], "-")) { simulate_login = 1; ++optind; } if (optind < argc) new_user = argv[optind++]; if (optind < argc) additional_args = argv + optind; pw = getpwnam (new_user); if (pw == 0) error (1, 0, "user %s does not exist", new_user); endpwent (); if (!correct_password (pw)) { #ifdef SYSLOG_FAILURE log_su (pw, 0); #endif error (1, 0, "incorrect password"); } #ifdef SYSLOG_SUCCESS else { log_su (pw, 1); } #endif if (pw->pw_shell == 0 || pw->pw_shell[0] == 0) pw->pw_shell = DEFAULT_SHELL; if (shell == 0 && change_environment == 0) shell = getenv ("SHELL"); if (shell != 0 && getuid () && restricted_shell (pw->pw_shell)) { /* The user being su'd to has a nonstandard shell, and so is probably a uucp account or has restricted access. Don't compromise the account by allowing access with a standard shell. */ error (0, 0, "using restricted shell %s", pw->pw_shell); shell = 0; } if (shell == 0) shell = pw->pw_shell; shell = strcpy (xmalloc (strlen (shell) + 1), shell); modify_environment (pw, shell); change_identity (pw); if (simulate_login && chdir (pw->pw_dir)) error (0, errno, "warning: cannot change directory to %s", pw->pw_dir); run_shell (shell, command, additional_args); } /* Ask the user for a password. Return 1 if the user gives the correct password for entry PW, 0 if not. Return 1 without asking for a password if run by UID 0 or if PW has an empty password. */ static int correct_password (pw) struct passwd *pw; { char *unencrypted, *encrypted, *correct; #ifdef HAVE_SHADOW_H /* Shadow passwd stuff for SVR3 and maybe other systems. */ struct spwd *sp = getspnam (pw->pw_name); endspent (); if (sp) correct = sp->sp_pwdp; else #endif correct = pw->pw_passwd; if (getuid () == 0 || correct == 0 || correct[0] == '\0') return 1; unencrypted = getpass ("Password:"); if (unencrypted == NULL) { error (0, 0, "getpass: cannot open /dev/tty"); return 0; } encrypted = crypt (unencrypted, correct); bzero (unencrypted, strlen (unencrypted)); return strcmp (encrypted, correct) == 0; } /* Update `environ' for the new shell based on PW, with SHELL being the value for the SHELL environment variable. */ static void modify_environment (pw, shell) struct passwd *pw; char *shell; { char *term; if (simulate_login) { /* Leave TERM unchanged. Set HOME, SHELL, USER, LOGNAME, PATH. Unset all other environment variables. */ term = getenv ("TERM"); environ = (char **) xmalloc (2 * sizeof (char *)); environ[0] = 0; if (term) xputenv (concat ("TERM", "=", term)); xputenv (concat ("HOME", "=", pw->pw_dir)); xputenv (concat ("SHELL", "=", shell)); xputenv (concat ("USER", "=", pw->pw_name)); xputenv (concat ("LOGNAME", "=", pw->pw_name)); xputenv (concat ("PATH", "=", pw->pw_uid ? DEFAULT_LOGIN_PATH : DEFAULT_ROOT_LOGIN_PATH)); } else { /* Set HOME, SHELL, and if not becoming a super-user, USER and LOGNAME. */ if (change_environment) { xputenv (concat ("HOME", "=", pw->pw_dir)); xputenv (concat ("SHELL", "=", shell)); if (pw->pw_uid) { xputenv (concat ("USER", "=", pw->pw_name)); xputenv (concat ("LOGNAME", "=", pw->pw_name)); } } } } /* Become the user and group(s) specified by PW. */ static void change_identity (pw) struct passwd *pw; { #ifdef NGROUPS_MAX errno = 0; if (initgroups (pw->pw_name, pw->pw_gid) == -1) error (1, errno, "cannot set groups"); endgrent (); #endif if (setgid (pw->pw_gid)) error (1, errno, "cannot set group id"); if (setuid (pw->pw_uid)) error (1, errno, "cannot set user id"); } /* Run SHELL, or DEFAULT_SHELL if SHELL is empty. If COMMAND is nonzero, pass it to the shell with the -c option. If ADDITIONAL_ARGS is nonzero, pass it to the shell as more arguments. */ static void run_shell (shell, command, additional_args) char *shell; char *command; char **additional_args; { char **args; int argno = 1; if (additional_args) args = (char **) xmalloc (sizeof (char *) * (10 + elements (additional_args))); else args = (char **) xmalloc (sizeof (char *) * 10); if (simulate_login) { args[0] = xmalloc (strlen (shell) + 2); args[0][0] = '-'; strcpy (args[0] + 1, basename (shell)); } else args[0] = basename (shell); if (fast_startup) args[argno++] = "-f"; if (command) { args[argno++] = "-c"; args[argno++] = command; } if (additional_args) for (; *additional_args; ++additional_args) args[argno++] = *additional_args; args[argno] = 0; execv (shell, args); error (1, errno, "cannot run %s", shell); } #if defined (SYSLOG_SUCCESS) || defined (SYSLOG_FAILURE) /* Log the fact that someone has run su to the user given by PW; if SUCCESSFUL is nonzero, they gave the correct password, etc. */ static void log_su (pw, successful) struct passwd *pw; int successful; { char *new_user, *old_user, *tty; #ifndef SYSLOG_NON_ROOT if (pw->pw_uid) return; #endif new_user = pw->pw_name; /* The utmp entry (via getlogin) is probably the best way to identify the user, especially if someone su's from a su-shell. */ old_user = getlogin (); if (old_user == 0) old_user = ""; tty = ttyname (2); if (tty == 0) tty = ""; /* 4.2BSD openlog doesn't have the third parameter. */ openlog (basename (program_name), 0 #ifdef LOG_AUTH , LOG_AUTH #endif ); syslog (LOG_NOTICE, #ifdef SYSLOG_NON_ROOT "%s(to %s) %s on %s", #else "%s%s on %s", #endif successful ? "" : "FAILED SU ", #ifdef SYSLOG_NON_ROOT new_user, #endif old_user, tty); closelog (); } #endif /* Return 1 if SHELL is a restricted shell (one not returned by getusershell), else 0, meaning it is a standard shell. */ static int restricted_shell (shell) char *shell; { char *line; setusershell (); while ((line = getusershell ()) != NULL) { if (*line != '#' && strcmp (line, shell) == 0) { endusershell (); return 0; } } endusershell (); return 1; } /* Return the number of elements in ARR, a null-terminated array. */ static int elements (arr) char **arr; { int n = 0; for (n = 0; *arr; ++arr) ++n; return n; } /* Add VAL to the environment, checking for out of memory errors. */ static void xputenv (val) char *val; { if (putenv (val)) error (1, 0, "virtual memory exhausted"); } /* Return a newly-allocated string whose contents concatenate those of S1, S2, S3. */ static char * concat (s1, s2, s3) char *s1, *s2, *s3; { int len1 = strlen (s1), len2 = strlen (s2), len3 = strlen (s3); char *result = (char *) xmalloc (len1 + len2 + len3 + 1); strcpy (result, s1); strcpy (result + len1, s2); strcpy (result + len1 + len2, s3); result[len1 + len2 + len3] = 0; return result; } static void usage (status) int status; { if (status != 0) fprintf (stderr, "Try `%s --help' for more information.\n", program_name); else { printf ("Usage: %s [OPTION]... [-] [USER [ARG]...]\n", program_name); printf ("\ \n\ -l, --login make the shell a login shell\n\ -c, --commmand=COMMAND pass a single COMMAND to the shell with -c\n\ -f, --fast pass -f to the shell (for csh or tcsh)\n\ -m, --preserve-environment do not reset environment variables\n\ -p same as -m\n\ -s, --shell=SHELL run SHELL if /etc/shells allows it\n\ --help display this help and exit\n\ --version output version information and exit\n\ \n\ A mere - implies -l. If USER not given, assume root.\n\ "); } exit (status); } sh-utils-1.10/src/tee.c100666 74504 1 12740 5555072456 14300 0ustar meyeringdaemon/* tee - read from standard input and write to standard output and files. Copyright (C) 85, 90, 91, 92, 93, 1994 Free Software Foundation, Inc. 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 2, 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, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ /* Mike Parker, Richard M. Stallman, and David MacKenzie */ #ifdef HAVE_CONFIG_H #if defined (CONFIG_BROKETS) /* We use instead of "config.h" so that a compilation using -I. -I$srcdir will use ./config.h rather than $srcdir/config.h (which it would do because it found this file in $srcdir). */ #include #else #include "config.h" #endif #endif #include #include #include #include #include "system.h" #include "version.h" char *xmalloc (); void error (); int full_write (); static int tee (); /* If nonzero, append to output files rather than truncating them. */ static int append; /* If nonzero, ignore interrupts. */ static int ignore_interrupts; /* The name that this program was run with. */ char *program_name; /* If non-zero, display usage information and exit. */ static int show_help; /* If non-zero, print the version on standard output and exit. */ static int show_version; static struct option const long_options[] = { {"append", no_argument, NULL, 'a'}, {"help", no_argument, &show_help, 1}, {"ignore-interrupts", no_argument, NULL, 'i'}, {"version", no_argument, &show_version, 1}, {NULL, 0, NULL, 0} }; static void usage (status) int status; { if (status != 0) fprintf (stderr, "Try `%s --help' for more information.\n", program_name); else { printf ("Usage: %s [OPTION]... [FILE]...\n", program_name); printf ("\ \n\ -a, --append append to the given FILEs, do not overwrite\n\ -i, --ignore-interrupts ignore interrupt signals\n\ --help display this help and exit\n\ --version output version information and exit\n\ "); } exit (status); } void main (argc, argv) int argc; char **argv; { int errs; int optc; program_name = argv[0]; append = 0; ignore_interrupts = 0; while ((optc = getopt_long (argc, argv, "ai", long_options, (int *) 0)) != EOF) { switch (optc) { case 0: break; case 'a': append = 1; break; case 'i': ignore_interrupts = 1; break; default: usage (1); } } if (show_version) { printf ("tee - %s\n", version_string); exit (0); } if (show_help) usage (0); if (ignore_interrupts) { #ifdef _POSIX_VERSION struct sigaction sigact; sigact.sa_handler = SIG_IGN; sigemptyset (&sigact.sa_mask); sigact.sa_flags = 0; sigaction (SIGINT, &sigact, NULL); #else /* !_POSIX_VERSION */ signal (SIGINT, SIG_IGN); #endif /* _POSIX_VERSION */ } errs = tee (argc - optind, &argv[optind]); if (close (0) != 0) error (1, errno, "standard input"); if (close (1) != 0) error (1, errno, "standard output"); exit (errs); } /* Copy the standard input into each of the NFILES files in FILES and into the standard output. Return 0 if successful, 1 if any errors occur. */ static int tee (nfiles, files) int nfiles; char **files; { int *descriptors; char buffer[BUFSIZ]; register int bytes_read, i, ret = 0, mode; descriptors = (int *) xmalloc ((nfiles + 1) * sizeof (int)); mode = O_WRONLY | O_CREAT; if (append) mode |= O_APPEND; else mode |= O_TRUNC; /* Move all the names `up' one in the argv array to make room for the entry for standard output. This writes into argv[argc]. */ for (i = nfiles; i >= 1; i--) files[i] = files[i - 1]; /* In the array of NFILES + 1 descriptors, make the first one correspond to standard output. */ descriptors[0] = 1; files[0] = "standard output"; for (i = 1; i <= nfiles; i++) { descriptors[i] = open (files[i], mode, 0666); if (descriptors[i] == -1) { error (0, errno, "%s", files[i]); ret = 1; } } while (1) { bytes_read = read (0, buffer, sizeof buffer); #ifdef EINTR if (bytes_read < 0 && errno == EINTR) continue; #endif if (bytes_read <= 0) break; /* Write to all NFILES + 1 descriptors. Standard output is the first one. */ for (i = 0; i <= nfiles; i++) { if (descriptors[i] != -1 && full_write (descriptors[i], buffer, bytes_read) < 0) { error (0, errno, "%s", files[i]); /* Don't close stdout. That's done in main. */ if (descriptors[i] != 1) close (descriptors[i]); descriptors[i] = -1; ret = 1; } } } if (bytes_read == -1) { error (0, errno, "read error"); ret = 1; } /* Close the files, but not standard output. */ for (i = 1; i <= nfiles; i++) if (descriptors[i] != -1 && close (descriptors[i]) != 0) { error (0, errno, "%s", files[i]); ret = 1; } free (descriptors); return ret; } sh-utils-1.10/src/test.c100666 74504 1 64413 5556777121 14510 0ustar meyeringdaemon/* GNU test program (ksb and mjb) */ /* Modified to run with the GNU shell by bfox. */ /* Copyright (C) 1987-1993, 1994 Free Software Foundation, Inc. This file is part of GNU Bash, the Bourne Again SHell. Bash 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 2, or (at your option) any later version. Bash 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 Bash; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ /* Define TEST_STANDALONE to get the /bin/test version. Otherwise, you get the shell builtin version. */ /* #define TEST_STANDALONE */ #ifdef HAVE_CONFIG_H #if defined (CONFIG_BROKETS) /* We use instead of "config.h" so that a compilation using -I. -I$srcdir will use ./config.h rather than $srcdir/config.h (which it would do because it found this file in $srcdir). */ #include #else #include "config.h" #endif #endif #include #include #if !defined (TEST_STANDALONE) # include "shell.h" # include "posixstat.h" # include "filecntl.h" #else /* TEST_STANDALONE */ # include "system.h" # if !defined (S_IXUGO) # define S_IXUGO 0111 # endif /* S_IXUGO */ # if defined (_POSIX_VERSION) # include # else /* !_POSIX_VERSION */ # include # endif /* _POSIX_VERSION */ # if defined (NGROUPS_MAX) || defined (_SC_NGROUPS_MAX) || defined (NGROUPS) # define HAVE_GETGROUPS # endif /* NGROUPS_MAX || _SC_NGROUPS_MAX || NGROUPS */ #define whitespace(c) (((c) == ' ') || ((c) == '\t')) #define digit(c) ((c) >= '0' && (c) <= '9') #define digit_value(c) ((c) - '0') char *program_name; #endif /* TEST_STANDALONE */ #if !defined (_POSIX_VERSION) # include #endif /* !_POSIX_VERSION */ #include #if !defined (errno) extern int errno; #endif /* !errno */ #if !defined (STREQ) # define STREQ(a, b) ((a)[0] == (b)[0] && strcmp (a, b) == 0) #endif /* !STREQ */ #if !defined (member) # define member(c, s) ((c) ? (index ((s), (c)) ? 1 : 0) : 0) #endif /* !member */ extern gid_t getgid (), getegid (); extern uid_t geteuid (); #if !defined (R_OK) #define R_OK 4 #define W_OK 2 #define X_OK 1 #define F_OK 0 #endif /* R_OK */ /* This name is used solely when printing --version information. */ #define COMMAND_NAME "test" /* The following few defines control the truth and false output of each stage. TRUE and FALSE are what we use to compute the final output value. SHELL_BOOLEAN is the form which returns truth or falseness in shell terms. TRUTH_OR is how to do logical or with TRUE and FALSE. TRUTH_AND is how to do logical and with TRUE and FALSE.. Default is TRUE = 1, FALSE = 0, TRUTH_OR = a | b, TRUTH_AND = a & b, SHELL_BOOLEAN = (!value). */ #define TRUE 1 #define FALSE 0 #define SHELL_BOOLEAN(value) (!(value)) #define TRUTH_OR(a, b) ((a) | (b)) #define TRUTH_AND(a, b) ((a) & (b)) #if defined (TEST_STANDALONE) # define test_exit(val) exit (val) #else static jmp_buf test_exit_buf; static int test_error_return = 0; # define test_exit(val) test_error_return = val, longjmp (test_exit_buf, 1) #endif /* !TEST_STANDALONE */ char *xrealloc (); static int pos; /* The offset of the current argument in ARGV. */ static int argc; /* The number of arguments present in ARGV. */ static char **argv; /* The argument list. */ static int unop (); static int binop (); static int unary_operator (); static int binary_operator (); static int two_arguments (); static int three_arguments (); static int posixtest (); static int expr (); static int term (); static int and (); static int or (); static int group_member (); static void test_syntax_error (format, arg) char *format, *arg; { fprintf (stderr, "%s: ", argv[0]); fprintf (stderr, format, arg); fflush (stderr); test_exit (SHELL_BOOLEAN (FALSE)); } /* A wrapper for stat () which disallows pathnames that are empty strings. */ static int test_stat (path, finfo) char *path; struct stat *finfo; { if (*path == '\0') { errno = ENOENT; return (-1); } return (stat (path, finfo)); } /* Do the same thing access(2) does, but use the effective uid and gid, and don't make the mistake of telling root that any file is executable. */ static int eaccess (path, mode) char *path; int mode; { struct stat st; static int euid = -1; if (test_stat (path, &st) < 0) return (-1); if (euid == -1) euid = geteuid (); if (euid == 0) { /* Root can read or write any file. */ if (mode != X_OK) return (0); /* Root can execute any file that has any one of the execute bits set. */ if (st.st_mode & S_IXUGO) return (0); } if (st.st_uid == euid) /* owner */ mode <<= 6; else if (group_member (st.st_gid)) mode <<= 3; if (st.st_mode & mode) return (0); return (-1); } #if defined (HAVE_GETGROUPS) /* The number of groups that this user is a member of. */ static int ngroups = 0; static GETGROUPS_T *group_array = (GETGROUPS_T *)NULL; static int default_group_array_size = 0; #endif /* HAVE_GETGROUPS */ /* Return non-zero if GID is one that we have in our groups list. */ static int group_member (gid) gid_t gid; { #if !defined (HAVE_GETGROUPS) return ((gid == getgid ()) || (gid == getegid ())); #else register int i; /* getgroups () returns the number of elements that it was able to place into the array. We simply continue to call getgroups () until the number of elements placed into the array is smaller than the physical size of the array. */ while (ngroups == default_group_array_size) { default_group_array_size += 64; group_array = (GETGROUPS_T *) xrealloc (group_array, default_group_array_size * sizeof (GETGROUPS_T)); ngroups = getgroups (default_group_array_size, group_array); } /* In case of error, the user loses. */ if (ngroups < 0) return (0); /* Search through the list looking for GID. */ for (i = 0; i < ngroups; i++) if (gid == group_array[i]) return (1); return (0); #endif /* HAVE_GETGROUPS */ } /* Increment our position in the argument list. Check that we're not past the end of the argument list. This check is supressed if the argument is FALSE. Made a macro for efficiency. */ #define advance(f) \ do \ { \ ++pos; \ if ((f) && pos >= argc) \ beyond (); \ } \ while (0) #if !defined (advance) static int advance (f) int f; { ++pos; if (f && pos >= argc) beyond (); } #endif /* advance */ #define unary_advance() \ do \ { \ advance (1); \ ++pos; \ } \ while (0) /* * beyond - call when we're beyond the end of the argument list (an * error condition) */ static void beyond () { test_syntax_error ("argument expected\n", (char *)NULL); } /* Syntax error for when an integer argument was expected, but something else was found. */ static void integer_expected_error (pch) char *pch; { test_syntax_error ("integer expression expected %s\n", pch); } /* Return non-zero if the characters pointed to by STRING constitute a valid number. Stuff the converted number into RESULT if RESULT is a non-null pointer to a long. */ static int isint (string, result) register char *string; long *result; { int sign; long value; sign = 1; value = 0; if (result) *result = 0; /* Skip leading whitespace characters. */ while (whitespace (*string)) string++; if (!*string) return (0); /* We allow leading `-' or `+'. */ if (*string == '-' || *string == '+') { if (!digit (string[1])) return (0); if (*string == '-') sign = -1; string++; } while (digit (*string)) { if (result) value = (value * 10) + digit_value (*string); string++; } /* Skip trailing whitespace, if any. */ while (whitespace (*string)) string++; /* Error if not at end of string. */ if (*string) return (0); if (result) { value *= sign; *result = value; } return (1); } /* Find the modification time of FILE, and stuff it into AGE, a pointer to a long. Return non-zero if successful, else zero. */ static int age_of (filename, age) char *filename; long *age; { struct stat finfo; if (test_stat (filename, &finfo) < 0) return (0); if (age) *age = finfo.st_mtime; return (1); } /* * term - parse a term and return 1 or 0 depending on whether the term * evaluates to true or false, respectively. * * term ::= * '-'('h'|'d'|'f'|'r'|'s'|'w'|'c'|'b'|'p'|'u'|'g'|'k') filename * '-'('L'|'x') filename * '-t' [ int ] * '-'('z'|'n') string * string * string ('!='|'=') string * '-'(eq|ne|le|lt|ge|gt) * file '-'(nt|ot|ef) file * '(' ')' * int ::= * '-l' string * positive and negative integers */ static int term () { int value; if (pos >= argc) beyond (); /* Deal with leading "not"'s. */ if ('!' == argv[pos][0] && '\000' == argv[pos][1]) { value = FALSE; while (pos < argc && '!' == argv[pos][0] && '\000' == argv[pos][1]) { advance (1); value ^= (TRUE); } return (value ^ (term ())); } /* A paren-bracketed argument. */ if (argv[pos][0] == '(' && !argv[pos][1]) { advance (1); value = expr (); if (argv[pos][0] != ')' || argv[pos][1]) test_syntax_error ("')' expected, found %s\n", argv[pos]); advance (0); return (TRUE == (value)); } /* are there enough arguments left that this could be dyadic? */ if (((pos + 3 <= argc) && binop (argv[pos + 1])) || ((pos + 4 <= argc && STREQ (argv[pos], "-l") && binop (argv[pos + 2])))) value = binary_operator (); /* Might be a switch type argument */ else if ('-' == argv[pos][0] && 0 == argv[pos][2]) { if (unop (argv[pos][1])) value = unary_operator (); else test_syntax_error ("%s: unary operator expected\n", argv[pos]); } else { value = (argv[pos][0] != '\0'); advance (0); } return (value); } static int binary_operator () { register int op; struct stat stat_buf, stat_spare; long int l, r, value; /* Are the left and right integer expressions of the form '-l string'? */ int l_is_l, r_is_l; if (strcmp (argv[pos], "-l") == 0) { l_is_l = 1; op = pos + 2; /* Make sure that OP is still a valid binary operator. */ if ((op >= argc - 1) || (binop (argv[op]) == 0)) test_syntax_error ("%s: binary operator expected\n", argv[op]); advance (0); } else { l_is_l = 0; op = pos + 1; } if ((op < argc - 2) && (strcmp (argv[op + 1], "-l") == 0)) { r_is_l = 1; advance (0); } else r_is_l = 0; if (argv[op][0] == '-') { /* check for eq, nt, and stuff */ switch (argv[op][1]) { default: break; case 'l': if (argv[op][2] == 't' && !argv[op][3]) { /* lt */ if (l_is_l) l = strlen (argv[op - 1]); else { if (!isint (argv[op - 1], &l)) integer_expected_error ("before -lt"); } if (r_is_l) r = strlen (argv[op + 2]); else { if (!isint (argv[op + 1], &r)) integer_expected_error ("after -lt"); } pos += 3; return (TRUE == (l < r)); } if (argv[op][2] == 'e' && !argv[op][3]) { /* le */ if (l_is_l) l = strlen (argv[op - 1]); else { if (!isint (argv[op - 1], &l)) integer_expected_error ("before -le"); } if (r_is_l) r = strlen (argv[op + 2]); else { if (!isint (argv[op + 1], &r)) integer_expected_error ("after -le"); } pos += 3; return (TRUE == (l <= r)); } break; case 'g': if (argv[op][2] == 't' && !argv[op][3]) { /* gt integer greater than */ if (l_is_l) l = strlen (argv[op - 1]); else { if (!isint (argv[op - 1], &l)) integer_expected_error ("before -gt"); } if (r_is_l) r = strlen (argv[op + 2]); else { if (!isint (argv[op + 1], &r)) integer_expected_error ("after -gt"); } pos += 3; return (TRUE == (l > r)); } if (argv[op][2] == 'e' && !argv[op][3]) { /* ge - integer greater than or equal to */ if (l_is_l) l = strlen (argv[op - 1]); else { if (!isint (argv[op - 1], &l)) integer_expected_error ("before -ge"); } if (r_is_l) r = strlen (argv[op + 2]); else { if (!isint (argv[op + 1], &r)) integer_expected_error ("after -ge"); } pos += 3; return (TRUE == (l >= r)); } break; case 'n': if (argv[op][2] == 't' && !argv[op][3]) { /* nt - newer than */ pos += 3; if (l_is_l || r_is_l) test_syntax_error ("-nt does not accept -l\n", (char *)NULL); if (age_of (argv[op - 1], &l) && age_of (argv[op + 1], &r)) return (TRUE == (l > r)); else return (FALSE); } if (argv[op][2] == 'e' && !argv[op][3]) { /* ne - integer not equal */ if (l_is_l) l = strlen (argv[op - 1]); else { if (!isint (argv[op - 1], &l)) integer_expected_error ("before -ne"); } if (r_is_l) r = strlen (argv[op + 2]); else { if (!isint (argv[op + 1], &r)) integer_expected_error ("after -ne"); } pos += 3; return (TRUE == (l != r)); } break; case 'e': if (argv[op][2] == 'q' && !argv[op][3]) { /* eq - integer equal */ if (l_is_l) l = strlen (argv[op - 1]); else { if (!isint (argv[op - 1], &l)) integer_expected_error ("before -eq"); } if (r_is_l) r = strlen (argv[op + 2]); else { if (!isint (argv[op + 1], &r)) integer_expected_error ("after -eq"); } pos += 3; return (TRUE == (l == r)); } if (argv[op][2] == 'f' && !argv[op][3]) { /* ef - hard link? */ pos += 3; if (l_is_l || r_is_l) test_syntax_error ("-ef does not accept -l\n", (char *)NULL); if (stat (argv[op - 1], &stat_buf) < 0) return (FALSE); if (stat (argv[op + 1], &stat_spare) < 0) return (FALSE); return (TRUE == (stat_buf.st_dev == stat_spare.st_dev && stat_buf.st_ino == stat_spare.st_ino)); } break; case 'o': if ('t' == argv[op][2] && '\000' == argv[op][3]) { /* ot - older than */ pos += 3; if (l_is_l || r_is_l) test_syntax_error ("-nt does not accept -l\n", (char *)NULL); if (age_of (argv[op - 1], &l) && age_of (argv[op + 1], &r)) return (TRUE == (l < r)); return (FALSE); } break; } test_syntax_error ("unknown binary operator", argv[op]); } if (argv[op][0] == '=' && !argv[op][1]) { value = (strcmp (argv[pos], argv[pos + 2]) == 0); pos += 3; return (TRUE == value); } if (strcmp (argv[op], "!=") == 0) { value = (strcmp (argv[pos], argv[pos + 2]) != 0); pos += 3; return (TRUE == value); } /* Not reached. */ abort (); } static int unary_operator () { long r, value; struct stat stat_buf; switch (argv[pos][1]) { default: return (FALSE); /* All of the following unary operators use unary_advance (), which checks to make sure that there is an argument, and then advances pos right past it. This means that pos - 1 is the location of the argument. */ case 'a': /* file exists in the file system? */ case 'e': unary_advance (); value = -1 != test_stat (argv[pos - 1], &stat_buf); return (TRUE == value); case 'r': /* file is readable? */ unary_advance (); value = -1 != eaccess (argv[pos - 1], R_OK); return (TRUE == value); case 'w': /* File is writeable? */ unary_advance (); value = -1 != eaccess (argv[pos - 1], W_OK); return (TRUE == value); case 'x': /* File is executable? */ unary_advance (); value = -1 != eaccess (argv[pos - 1], X_OK); return (TRUE == value); case 'O': /* File is owned by you? */ unary_advance (); if (test_stat (argv[pos - 1], &stat_buf) < 0) return (FALSE); return (TRUE == (geteuid () == stat_buf.st_uid)); case 'G': /* File is owned by your group? */ unary_advance (); if (test_stat (argv[pos - 1], &stat_buf) < 0) return (FALSE); return (TRUE == (getegid () == stat_buf.st_gid)); case 'f': /* File is a file? */ unary_advance (); if (test_stat (argv[pos - 1], &stat_buf) < 0) return (FALSE); /* Under POSIX, -f is true if the given file exists and is a regular file. */ return (TRUE == ((S_ISREG (stat_buf.st_mode)) || (0 == (stat_buf.st_mode & S_IFMT)))); case 'd': /* File is a directory? */ unary_advance (); if (test_stat (argv[pos - 1], &stat_buf) < 0) return (FALSE); return (TRUE == (S_ISDIR (stat_buf.st_mode))); case 's': /* File has something in it? */ unary_advance (); if (test_stat (argv[pos - 1], &stat_buf) < 0) return (FALSE); return (TRUE == (stat_buf.st_size > (off_t) 0)); case 'S': /* File is a socket? */ #if !defined (S_ISSOCK) return (FALSE); #else unary_advance (); if (test_stat (argv[pos - 1], &stat_buf) < 0) return (FALSE); return (TRUE == (S_ISSOCK (stat_buf.st_mode))); #endif /* S_ISSOCK */ case 'c': /* File is character special? */ unary_advance (); if (test_stat (argv[pos - 1], &stat_buf) < 0) return (FALSE); return (TRUE == (S_ISCHR (stat_buf.st_mode))); case 'b': /* File is block special? */ unary_advance (); if (test_stat (argv[pos - 1], &stat_buf) < 0) return (FALSE); return (TRUE == (S_ISBLK (stat_buf.st_mode))); case 'p': /* File is a named pipe? */ unary_advance (); #ifndef S_ISFIFO return (FALSE); #else if (test_stat (argv[pos - 1], &stat_buf) < 0) return (FALSE); return (TRUE == (S_ISFIFO (stat_buf.st_mode))); #endif /* S_ISFIFO */ case 'L': /* Same as -h */ /*FALLTHROUGH*/ case 'h': /* File is a symbolic link? */ unary_advance (); #ifndef S_ISLNK return (FALSE); #else /* An empty filename is not a valid pathname. */ if ((argv[pos - 1][0] == '\0') || (lstat (argv[pos - 1], &stat_buf) < 0)) return (FALSE); return (TRUE == (S_ISLNK (stat_buf.st_mode))); #endif /* S_IFLNK */ case 'u': /* File is setuid? */ unary_advance (); if (test_stat (argv[pos - 1], &stat_buf) < 0) return (FALSE); return (TRUE == (0 != (stat_buf.st_mode & S_ISUID))); case 'g': /* File is setgid? */ unary_advance (); if (test_stat (argv[pos - 1], &stat_buf) < 0) return (FALSE); return (TRUE == (0 != (stat_buf.st_mode & S_ISGID))); case 'k': /* File has sticky bit set? */ unary_advance (); if (test_stat (argv[pos - 1], &stat_buf) < 0) return (FALSE); #if !defined (S_ISVTX) /* This is not Posix, and is not defined on some Posix systems. */ return (FALSE); #else return (TRUE == (0 != (stat_buf.st_mode & S_ISVTX))); #endif case 't': /* File (fd) is a terminal? (fd) defaults to stdout. */ advance (0); if (pos < argc && isint (argv[pos], &r)) { advance (0); return (TRUE == (isatty ((int) r))); } return (TRUE == (isatty (1))); case 'n': /* True if arg has some length. */ unary_advance (); return (TRUE == (argv[pos - 1][0] != 0)); case 'z': /* True if arg has no length. */ unary_advance (); return (TRUE == (argv[pos - 1][0] == '\0')); } } /* * and: * term * term '-a' and */ static int and () { int value; value = term (); while ((pos < argc) && strcmp (argv[pos], "-a") == 0) { advance (0); value = TRUTH_AND (value, and ()); } return (TRUE == value); } /* * or: * and * and '-o' or */ static int or () { int value; value = and (); while ((pos < argc) && strcmp (argv[pos], "-o") == 0) { advance (0); value = TRUTH_OR (value, or ()); } return (TRUE == value); } /* * expr: * or */ static int expr () { if (pos >= argc) beyond (); return (FALSE ^ (or ())); /* Same with this. */ } /* Return TRUE if S is one of the test command's binary operators. */ static int binop (s) char *s; { return ((STREQ (s, "=")) || (STREQ (s, "!=")) || (STREQ (s, "-nt")) || (STREQ (s, "-ot")) || (STREQ (s, "-ef")) || (STREQ (s, "-eq")) || (STREQ (s, "-ne")) || (STREQ (s, "-lt")) || (STREQ (s, "-le")) || (STREQ (s, "-gt")) || (STREQ (s, "-ge"))); } /* Return non-zero if OP is one of the test command's unary operators. */ static int unop (op) int op; { return (member (op, "abcdefgkLhprsStuwxOGnz")); } static int two_arguments () { int value; if (STREQ (argv[pos], "!")) value = strlen (argv[pos+1]) == 0; else if ((argv[pos][0] == '-') && (argv[pos][2] == '\0')) { if (unop (argv[pos][1])) value = unary_operator (); else test_syntax_error ("%s: unary operator expected\n", argv[pos]); } else beyond (); return (value); } static int three_arguments () { int value; if (STREQ (argv[pos], "!")) { advance (1); value = !two_arguments (); } else if (binop (argv[pos+1])) { value = binary_operator (); pos = argc; } else if ((STREQ (argv[pos+1], "-a")) || (STREQ (argv[pos+1], "-o")) || (argv[pos][0] == '(')) value = expr (); else test_syntax_error ("%s: binary operator expected\n", argv[pos+1]); return (value); } /* This is an implementation of a Posix.2 proposal by David Korn. */ static int posixtest () { int value; switch (argc - 1) /* one extra passed in */ { case 0: value = FALSE; pos = argc; break; case 1: value = strlen (argv[1]) != 0; pos = argc; break; case 2: value = two_arguments (); pos = argc; break; case 3: value = three_arguments (); break; case 4: if (STREQ (argv[pos], "!")) { advance (1); value = !three_arguments (); break; } /* FALLTHROUGH */ case 5: default: value = expr (); } return (value); } #if defined (TEST_STANDALONE) #include "long-options.h" static void usage (status) int status; { if (status != 0) fprintf (stderr, "Try `%s --help' for more information.\n", program_name); else { printf ("\ Usage: %s EXPRESSION\n\ or: [ EXPRESSION ]\n\ or: %s OPTION\n\ ", program_name, program_name); printf ("\ \n\ --help display this help and exit\n\ --version output version information and exit\n\ \n\ EXPRESSION is true or false and sets exit status. It is one of:\n\ "); printf ("\ \n\ ( EXPRESSION ) EXPRESSION is true\n\ ! EXPRESSION EXPRESSION is false\n\ EXPRESSION1 -a EXPRESSION2 both EXPRESSION1 and EXPRESSION2 are true\n\ EXPRESSION1 -o EXPRESSION2 either EXPRESSION1 or EXPRESSION2 is true\n\ \n\ [-n] STRING the length of STRING is non-zero\n\ -z STRING the length of STRING is zero\n\ STRING1 = STRING2 the strings are equal\n\ STRING1 != STRING2 the strings are not equal\n\ \n\ INTEGER1 -eq INTEGER2 INTEGER1 is equal to INTEGER2\n\ INTEGER1 -ge INTEGER2 INTEGER1 is greater than or equal to INTEGER2\n\ INTEGER1 -gt INTEGER2 INTEGER1 is greater than INTEGER2\n\ INTEGER1 -le INTEGER2 INTEGER1 is less than or equal to INTEGER2\n\ INTEGER1 -lt INTEGER2 INTEGER1 is less than INTEGER2\n\ INTEGER1 -ne INTEGER2 INTEGER1 is not equal to INTEGER2\n\ "); printf ("\ \n\ FILE1 -ef FILE2 FILE1 and FILE2 have the same device and inode numbers\n\ FILE1 -nt FILE2 FILE1 is newer (modification date) than FILE2\n\ FILE1 -ot FILE2 FILE1 is older than FILE2\n\ \n\ -G FILE FILE exists and is owned by the effective group ID\n\ -L FILE FILE exists and is a symbolic link\n\ -O FILE FILE exists and is owned by the effective user ID\n\ -S FILE FILE exists and is a socket\n\ -b FILE FILE exists and is block special\n\ -c FILE FILE exists and is character special\n\ -d FILE FILE exists and is a directory\n\ -e FILE FILE exists\n\ -f FILE FILE exists and is a regular file\n\ -g FILE FILE exists and is set-group-ID\n\ -k FILE FILE exists and has its sticky bit set\n\ -p FILE FILE exists and is a named pipe\n\ -r FILE FILE exists and is readable\n\ -s FILE FILE exists and has a size greater than zero\n\ -t standard output is opened on a terminal\n\ -t FD file descriptor FD is opened on a terminal\n\ -u FILE FILE exists and its set-user-ID bit is set\n\ -w FILE FILE exists and is writable\n\ -x FILE FILE exists and is executable\n\ "); printf ("\ \n\ --help display this help and exit\n\ --version output version information and exit\n\ \n\ Beware that parentheses need to be escaped by backslashes for shells.\n\ INTEGER may also be -l STRING, which evaluates to the length of STRING.\n\ "); } exit (status); } #endif /* TEST_STANDALONE */ /* * [: * '[' expr ']' * test: * test expr */ int #if defined (TEST_STANDALONE) main (margc, margv) #else test_command (margc, margv) #endif /* !TEST_STANDALONE */ int margc; char **margv; { int value; #if !defined (TEST_STANDALONE) int code; code = setjmp (test_exit_buf); if (code) return (test_error_return); #else /* TEST_STANDALONE */ program_name = margv[0]; #endif /* TEST_STANDALONE */ argv = margv; if (margv[0] && strcmp (margv[0], "[") == 0) { parse_long_options (argc, argv, COMMAND_NAME, usage); --margc; if (margc < 2) test_exit (SHELL_BOOLEAN (FALSE)); if (margv[margc] && strcmp (margv[margc], "]") != 0) test_syntax_error ("missing `]'\n", (char *)NULL); } argc = margc; pos = 1; if (pos >= argc) test_exit (SHELL_BOOLEAN (FALSE)); parse_long_options (argc, argv, COMMAND_NAME, usage); value = posixtest (); if (pos != argc) test_syntax_error ("too many arguments\n", (char *)NULL); test_exit (SHELL_BOOLEAN (value)); } sh-utils-1.10/src/tty.c100666 74504 1 6264 5555072462 14324 0ustar meyeringdaemon/* tty -- print the path of the terminal connected to standard input Copyright (C) 90, 91, 92, 93, 1994 Free Software Foundation, Inc. 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 2, 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, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ /* Displays "not a tty" if stdin is not a terminal. Displays nothing if -s option is given. Exit status 0 if stdin is a tty, 1 if not, 2 if usage error, 3 if write error. Written by David MacKenzie . */ #ifdef HAVE_CONFIG_H #if defined (CONFIG_BROKETS) /* We use instead of "config.h" so that a compilation using -I. -I$srcdir will use ./config.h rather than $srcdir/config.h (which it would do because it found this file in $srcdir). */ #include #else #include "config.h" #endif #endif #include #include #include #include "system.h" #include "version.h" void error (); static void usage (); /* The name under which this program was run. */ char *program_name; /* If nonzero, return an exit status but produce no output. */ static int silent; /* If non-zero, display usage information and exit. */ static int show_help; /* If non-zero, print the version on standard output and exit. */ static int show_version; static struct option const longopts[] = { {"help", no_argument, &show_help, 1}, {"silent", no_argument, NULL, 's'}, {"quiet", no_argument, NULL, 's'}, {"version", no_argument, &show_version, 1}, {NULL, 0, NULL, 0} }; void main (argc, argv) int argc; char **argv; { char *tty; int optc; program_name = argv[0]; silent = 0; while ((optc = getopt_long (argc, argv, "s", longopts, (int *) 0)) != EOF) { switch (optc) { case 0: break; case 's': silent = 1; break; default: usage (2); } } if (show_version) { printf ("tty - %s\n", version_string); exit (0); } if (show_help) usage (0); if (optind != argc) usage (2); tty = ttyname (0); if (!silent) { if (tty) puts (tty); else puts ("not a tty"); if (ferror (stdout) || fclose (stdout) == EOF) error (3, errno, "standard output"); } exit (isatty (0) ? 0 : 1); } static void usage (status) int status; { if (status != 0) fprintf (stderr, "Try `%s --help' for more information.\n", program_name); else { printf ("Usage: %s [OPTION]...\n", program_name); printf ("\ \n\ -s, --silent, --quiet print nothing, only return an exit status\n\ --help display this help and exit\n\ --version output version information and exit\n\ "); } exit (status); } sh-utils-1.10/src/who.c100666 74504 1 31500 5564702122 14301 0ustar meyeringdaemon/* GNU's users/who. Copyright (C) 92, 93, 1994 Free Software Foundation, Inc. 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 2, 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, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ /* Written by jla; revised by djm */ /* Output format: name [state] line time [idle] host state: -T name, line, time: not -q idle: -u Options: -m Same as 'who am i', for POSIX. -q Only user names and # logged on; overrides all other options. -s Name, line, time (default). -i, -u Idle hours and minutes; '.' means active in last minute; 'old' means idle for >24 hours. -H Print column headings at top. -w, -T -s plus mesg (+ or -, or ? if bad line). */ #ifdef HAVE_CONFIG_H #if defined (CONFIG_BROKETS) /* We use instead of "config.h" so that a compilation using -I. -I$srcdir will use ./config.h rather than $srcdir/config.h (which it would do because it found this file in $srcdir). */ #include #else #include "config.h" #endif #endif #include #include #ifdef HAVE_UTMPX_H #include #define STRUCT_UTMP struct utmpx #else #include #define STRUCT_UTMP struct utmp #endif #include #include #ifndef _POSIX_SOURCE #include #endif #include "system.h" #include "version.h" #if !defined (UTMP_FILE) && defined (_PATH_UTMP) /* 4.4BSD. */ #define UTMP_FILE _PATH_UTMP #endif #if defined (UTMPX_FILE) /* Solaris, SysVr4 */ #undef UTMP_FILE #define UTMP_FILE UTMPX_FILE #endif #ifndef UTMP_FILE #define UTMP_FILE "/etc/utmp" #endif #ifndef MAXHOSTNAMELEN #define MAXHOSTNAMELEN 64 #endif #ifndef S_IWGRP #define S_IWGRP 020 #endif #ifdef WHO #define COMMAND_NAME "who" #else #ifdef USERS #define COMMAND_NAME "users" #else error You must define one of WHO and USERS. #endif /* USERS */ #endif /* WHO */ char *xmalloc (); void error (); char *ttyname (); int gethostname (); static int read_utmp (); #ifdef WHO static char *idle_string (); static STRUCT_UTMP *search_entries (); static void print_entry (); static void print_heading (); static void scan_entries (); static void who_am_i (); #endif /* WHO */ static void list_entries (); static void usage (); static void who (); /* The name this program was run with. */ char *program_name; /* If non-zero, display usage information and exit. */ static int show_help; /* If non-zero, print the version on standard output and exit. */ static int show_version; #ifdef WHO /* If nonzero, display only a list of usernames and count of the users logged on. Ignored for `who am i'. */ static int short_list; /* If nonzero, display the hours:minutes since each user has touched the keyboard, or "." if within the last minute, or "old" if not within the last day. */ static int include_idle; /* If nonzero, display a line at the top describing each field. */ static int include_heading; /* If nonzero, display a `+' for each user if mesg y, a `-' if mesg n, or a `?' if their tty cannot be statted. */ static int include_mesg; #endif /* WHO */ static struct option const longopts[] = { #ifdef WHO {"count", no_argument, NULL, 'q'}, {"idle", no_argument, NULL, 'u'}, {"heading", no_argument, NULL, 'H'}, {"message", no_argument, NULL, 'T'}, {"mesg", no_argument, NULL, 'T'}, {"writable", no_argument, NULL, 'T'}, #endif /* WHO */ {"help", no_argument, &show_help, 1}, {"version", no_argument, &show_version, 1}, {NULL, 0, NULL, 0} }; void main (argc, argv) int argc; char **argv; { int optc, longind; #ifdef WHO int my_line_only = 0; #endif /* WHO */ program_name = argv[0]; #ifdef WHO while ((optc = getopt_long (argc, argv, "imqsuwHT", longopts, &longind)) #else while ((optc = getopt_long (argc, argv, "", longopts, &longind)) #endif /* WHO */ != EOF) { switch (optc) { case 0: break; #ifdef WHO case 'm': my_line_only = 1; break; case 'q': short_list = 1; break; case 's': break; case 'i': case 'u': include_idle = 1; break; case 'H': include_heading = 1; break; case 'w': case 'T': include_mesg = 1; break; #endif /* WHO */ default: error (0, 0, "too many arguments"); usage (1); } } if (show_version) { printf ("%s - %s\n", COMMAND_NAME, version_string); exit (0); } if (show_help) usage (0); switch (argc - optind) { case 0: /* who */ #ifdef WHO if (my_line_only) who_am_i (UTMP_FILE); else #endif /* WHO */ who (UTMP_FILE); break; case 1: /* who */ #ifdef WHO if (my_line_only) who_am_i (argv[optind]); else #endif /* WHO */ who (argv[optind]); break; #ifdef WHO case 2: /* who */ who_am_i (UTMP_FILE); break; #endif /* WHO */ default: /* lose */ usage (1); } exit (0); } static STRUCT_UTMP *utmp_contents; /* Display a list of who is on the system, according to utmp file FILENAME. */ static void who (filename) char *filename; { int users; users = read_utmp (filename); #ifdef WHO if (short_list) list_entries (users); else scan_entries (users); #else #ifdef USERS list_entries (users); #endif /* USERS */ #endif /* WHO */ } /* Read the utmp file FILENAME into UTMP_CONTENTS and return the number of entries it contains. */ static int read_utmp (filename) char *filename; { FILE *utmp; struct stat file_stats; int n_read; utmp = fopen (filename, "r"); if (utmp == NULL) error (1, errno, "%s", filename); fstat (fileno (utmp), &file_stats); if (file_stats.st_size > 0) utmp_contents = (STRUCT_UTMP *) xmalloc ((unsigned) file_stats.st_size); else { fclose (utmp); return 0; } /* Use < instead of != in case the utmp just grew. */ n_read = fread (utmp_contents, 1, file_stats.st_size, utmp); if (ferror (utmp) || fclose (utmp) == EOF || n_read < file_stats.st_size) error (1, errno, "%s", filename); return file_stats.st_size / sizeof (STRUCT_UTMP); } #ifdef WHO /* Display a line of information about entry THIS. */ static void print_entry (this) STRUCT_UTMP *this; { struct stat stats; time_t last_change; char mesg; #define DEV_DIR_WITH_TRAILING_SLASH "/dev/" #define DEV_DIR_LEN (sizeof (DEV_DIR_WITH_TRAILING_SLASH) - 1) char line[sizeof (this->ut_line) + DEV_DIR_LEN + 1]; /* Copy ut_line into LINE, prepending `/dev/' if ut_line is not already an absolute pathname. Some system may put the full, absolute pathname in ut_line. */ if (this->ut_line[0] == '/') { strncpy (line, this->ut_line, sizeof (this->ut_line)); line[sizeof (this->ut_line)] = '\0'; } else { strcpy(line, DEV_DIR_WITH_TRAILING_SLASH); strncpy (line + DEV_DIR_LEN, this->ut_line, sizeof (this->ut_line)); line[DEV_DIR_LEN + sizeof (this->ut_line)] = '\0'; } if (stat (line, &stats) == 0) { mesg = (stats.st_mode & S_IWGRP) ? '+' : '-'; last_change = stats.st_atime; } else { mesg = '?'; last_change = 0; } printf ("%-8.*s", (int) sizeof (this->ut_name), this->ut_name); if (include_mesg) printf (" %c ", mesg); printf (" %-8.*s", (int) sizeof (this->ut_line), this->ut_line); #ifdef HAVE_UTMPX_H printf (" %-12.12s", ctime (&this->ut_tv.tv_sec) + 4); #else printf (" %-12.12s", ctime (&this->ut_time) + 4); #endif if (include_idle) { if (last_change) printf (" %s", idle_string (last_change)); else printf (" . "); } #ifdef HAVE_UT_HOST if (this->ut_host[0]) printf (" (%-.*s)", (int) sizeof (this->ut_host), this->ut_host); #endif putchar ('\n'); } #endif /* WHO */ #if defined (WHO) || defined (USERS) /* Print the username of each valid entry and the number of valid entries in `utmp_contents', which should have N elements. */ static void list_entries (n) int n; { register STRUCT_UTMP *this = utmp_contents; register int entries = 0; while (n--) { if (this->ut_name[0] #ifdef USER_PROCESS && this->ut_type == USER_PROCESS #endif ) { char trimmed_name[sizeof (this->ut_name) + 1]; int i; strncpy (trimmed_name, this->ut_name, sizeof (this->ut_name)); trimmed_name[sizeof (this->ut_name)] = ' '; for (i = 0; i <= sizeof (this->ut_name); i++) { if (trimmed_name[i] == ' ') break; } trimmed_name[i] = '\0'; printf ("%s ", trimmed_name); entries++; } this++; } #ifdef WHO printf ("\n# users=%u\n", entries); #else putchar('\n'); #endif /* WHO */ } #endif /* defined (WHO) || defined (USERS) */ #ifdef WHO static void print_heading () { printf ("%-8s ", "USER"); if (include_mesg) printf ("MESG "); printf ("%-8s ", "LINE"); printf ("LOGIN-TIME "); if (include_idle) printf ("IDLE "); printf ("FROM\n"); } /* Display `utmp_contents', which should have N entries. */ static void scan_entries (n) int n; { register STRUCT_UTMP *this = utmp_contents; if (include_heading) print_heading (); while (n--) { if (this->ut_name[0] #ifdef USER_PROCESS && this->ut_type == USER_PROCESS #endif ) print_entry (this); this++; } } /* Search `utmp_contents', which should have N entries, for an entry with a `ut_line' field identical to LINE. Return the first matching entry found, or NULL if there is no matching entry. */ static STRUCT_UTMP * search_entries (n, line) int n; char *line; { register STRUCT_UTMP *this = utmp_contents; while (n--) { if (this->ut_name[0] #ifdef USER_PROCESS && this->ut_type == USER_PROCESS #endif && !strncmp (line, this->ut_line, sizeof (this->ut_line))) return this; this++; } return NULL; } /* Display the entry in utmp file FILENAME for this tty on standard input, or nothing if there is no entry for it. */ static void who_am_i (filename) char *filename; { register STRUCT_UTMP *utmp_entry; char hostname[MAXHOSTNAMELEN + 1]; char *tty; if (gethostname (hostname, MAXHOSTNAMELEN + 1)) *hostname = 0; if (include_heading) { printf ("%*s ", (int) strlen (hostname), " "); print_heading (); } tty = ttyname (0); if (tty == NULL) return; tty += 5; /* Remove "/dev/". */ utmp_entry = search_entries (read_utmp (filename), tty); if (utmp_entry == NULL) return; printf ("%s!", hostname); print_entry (utmp_entry); } /* Return a string representing the time between WHEN and the time that this function is first run. */ static char * idle_string (when) time_t when; { static time_t now = 0; static char idle[10]; time_t seconds_idle; if (now == 0) time (&now); seconds_idle = now - when; if (seconds_idle < 60) /* One minute. */ return " . "; if (seconds_idle < (24 * 60 * 60)) /* One day. */ { sprintf (idle, "%02d:%02d", (int) (seconds_idle / (60 * 60)), (int) ((seconds_idle % (60 * 60)) / 60)); return idle; } return " old "; } static void usage (status) int status; { if (status != 0) fprintf (stderr, "Try `%s --help' for more information.\n", program_name); else { printf ("Usage: %s [OPTION]... [ FILE | ARG1 ARG2 ]\n", program_name); printf ("\ \n\ -H, --heading print line of column headings\n\ -T, -w, --mesg add user's message status as +, - or ?\n\ -i, -u, --idle add user idle time as HOURS:MINUTES, . or old\n\ -m only hostname and user associated with stdin\n\ -q, --count all login names and number of users logged on\n\ -s (ignored)\n\ --help display this help and exit\n\ --message same as -T\n\ --version output version information and exit\n\ --writeable same as -T\n\ \n\ If FILE not given, uses /etc/utmp. /etc/wtmp as FILE is common.\n\ If ARG1 ARG2 given, -m presumed: `am i' or `mom likes' are usual.\n\ "); } exit (status); } #endif /* WHO */ #if defined (USERS) static void usage (status) int status; { if (status != 0) fprintf (stderr, "Try `%s --help' for more information.\n", program_name); else { printf ("Usage: %s [OPTION]... [ FILE ]\n", program_name); printf ("\ \n\ --help display this help and exit\n\ --version output version information and exit\n\ \n\ If FILE not given, uses /etc/utmp. /etc/wtmp as FILE is common.\n\ "); } exit (status); } #endif /* USERS */ sh-utils-1.10/src/whoami.c100666 74504 1 5311 5555072466 14764 0ustar meyeringdaemon/* whoami -- print effective userid Copyright (C) 89, 90, 91, 92, 93, 1994 Free Software Foundation, Inc. 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 2, 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, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ /* Equivalent to `id -un'. */ /* Written by Richard Mlynarik. */ #ifdef HAVE_CONFIG_H #if defined (CONFIG_BROKETS) /* We use instead of "config.h" so that a compilation using -I. -I$srcdir will use ./config.h rather than $srcdir/config.h (which it would do because it found this file in $srcdir). */ #include #else #include "config.h" #endif #endif #include #include #include #include #include "version.h" #include "system.h" /* The name this program was run with. */ char *program_name; /* If non-zero, display usage information and exit. */ static int show_help; /* If non-zero, print the version on standard output and exit. */ static int show_version; static struct option const long_options[] = { {"help", no_argument, &show_help, 1}, {"version", no_argument, &show_version, 1}, {0, 0, 0, 0} }; static void usage (status) int status; { if (status != 0) fprintf (stderr, "Try `%s --help' for more information.\n", program_name); else { printf ("Usage: %s [OPTION]...\n", program_name); printf ("\ \n\ --help display this help and exit\n\ --version output version information and exit\n\ \n\ Same as id -un.\n\ "); } exit (status); } void main (argc, argv) int argc; char *argv[]; { register struct passwd *pw; register uid_t uid; int c; program_name = argv[0]; while ((c = getopt_long (argc, argv, "", long_options, (int *) 0)) != EOF) { switch (c) { case 0: break; default: usage (1); } } if (show_version) { printf ("whoami - %s\n", version_string); exit (0); } if (show_help) usage (0); if (optind != argc) usage (1); uid = geteuid (); pw = getpwuid (uid); if (pw) { puts (pw->pw_name); exit (0); } fprintf (stderr, "%s: cannot find username for UID %u\n", program_name, (unsigned) uid); exit (1); } sh-utils-1.10/src/yes.c100666 74504 1 3765 5557763576 14326 0ustar meyeringdaemon/* yes - output a string repeatedly until killed Copyright (C) 91, 92, 93, 1994 Free Software Foundation, Inc. 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 2, 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, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ /* David MacKenzie */ #ifdef HAVE_CONFIG_H #if defined (CONFIG_BROKETS) /* We use instead of "config.h" so that a compilation using -I. -I$srcdir will use ./config.h rather than $srcdir/config.h (which it would do because it found this file in $srcdir). */ #include #else #include "config.h" #endif #endif #include #include #include "long-options.h" /* The name this program was run with. */ char *program_name; static void usage (status) int status; { if (status != 0) fprintf (stderr, "Try `%s --help' for more information.\n", program_name); else { printf ("Usage: %s [OPTION]... [STRING]...\n", program_name); printf ("\ \n\ --help display this help and exit\n\ --version output version information and exit\n\ \n\ Without any STRING, assume `y'.\n\ "); } exit (status); } void main (argc, argv) int argc; char **argv; { program_name = argv[0]; parse_long_options (argc, argv, "yes", usage); if (argc == 1) while (1) puts ("y"); while (1) { int i; for (i = 1; i < argc; i++) { fputs (argv[i], stdout); putchar (i == argc - 1 ? '\n' : ' '); } } } sh-utils-1.10/src/nice.c100666 74504 1 11054 5555072445 14434 0ustar meyeringdaemon/* nice -- run a program with modified scheduling priority Copyright (C) 90, 91, 92, 93, 1994 Free Software Foundation, Inc. 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 2, 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, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ /* David MacKenzie */ #ifdef HAVE_CONFIG_H #if defined (CONFIG_BROKETS) /* We use instead of "config.h" so that a compilation using -I. -I$srcdir will use ./config.h rather than $srcdir/config.h (which it would do because it found this file in $srcdir). */ #include #else #include "config.h" #endif #endif #include #include #include #ifndef NICE_PRIORITY #include #include #endif #include "version.h" #include "system.h" #ifdef NICE_PRIORITY #define GET_PRIORITY() nice (0) #else #define GET_PRIORITY() getpriority (PRIO_PROCESS, 0) #endif void error (); static int isinteger (); static void usage (); /* The name this program was run with. */ char *program_name; /* If non-zero, display usage information and exit. */ static int show_help; /* If non-zero, print the version on standard output and exit. */ static int show_version; static struct option const longopts[] = { {"adjustment", required_argument, NULL, 'n'}, {"help", no_argument, &show_help, 1}, {"version", no_argument, &show_version, 1}, {NULL, 0, NULL, 0} }; void main (argc, argv) int argc; char **argv; { int current_priority; int adjustment = 0; int minusflag = 0; int adjustment_given = 0; int optc; program_name = argv[0]; while ((optc = getopt_long (argc, argv, "+0123456789-n:", longopts, (int *) 0)) != EOF) { switch (optc) { case '?': usage (1); case 0: break; case 'n': if (!isinteger (optarg)) error (1, 0, "invalid priority `%s'", optarg); adjustment = atoi (optarg); adjustment_given = 1; break; case '-': minusflag = 1; break; default: adjustment = adjustment * 10 + optc - '0'; adjustment_given = 1; } } if (show_version) { printf ("nice - %s\n", version_string); exit (0); } if (show_help) usage (0); if (minusflag) adjustment = -adjustment; if (!adjustment_given) adjustment = 10; if (optind == argc) { if (adjustment_given) { error (0, 0, "a command must be given with an adjustment"); usage (1); } /* No command given; print the priority. */ errno = 0; current_priority = GET_PRIORITY (); if (current_priority == -1 && errno != 0) error (1, errno, "cannot get priority"); printf ("%d\n", current_priority); exit (0); } #ifndef NICE_PRIORITY errno = 0; current_priority = GET_PRIORITY (); if (current_priority == -1 && errno != 0) error (1, errno, "cannot get priority"); if (setpriority (PRIO_PROCESS, 0, current_priority + adjustment)) #else if (nice (adjustment) == -1) #endif error (1, errno, "cannot set priority"); execvp (argv[optind], &argv[optind]); error (errno == ENOENT ? 127 : 126, errno, "%s", argv[optind]); } /* Return nonzero if S represents a (possibly signed) decimal integer, zero if not. */ static int isinteger (s) char *s; { if (*s == '-' || *s == '+') ++s; if (*s == 0) return 0; while (*s) { if (*s < '0' || *s > '9') return 0; ++s; } return 1; } static void usage (status) int status; { if (status != 0) fprintf (stderr, "Try `%s --help' for more information.\n", program_name); else { printf ("Usage: %s [OPTION]... [COMMAND [ARG]...]\n", program_name); printf ("\ \n\ -ADJUST increment priority by ADJUST first\n\ -n, --adjustment=ADJUST same as -ADJUST\n\ --help display this help and exit\n\ --version output version information and exit\n\ \n\ With no COMMAND, print the current scheduling priority. ADJUST is 10\n\ by default. Range goes from -20 (highest priority) to 19 (lowest).\n\ "); } exit (status); } sh-utils-1.10/src/stty.c100644 74504 13 125157 5554616573 14312 0ustar meyeringuser/* stty -- change and print terminal line settings Copyright (C) 90, 91, 92, 93, 1994 Free Software Foundation, Inc. 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 2, 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, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ /* Usage: stty [-ag] [--all] [--save] [setting...] Options: -a, --all Write all current settings to stdout in human-readable form. -g, --save Write all current settings to stdout in stty-readable form. If no args are given, write to stdout the baud rate and settings that have been changed from their defaults. Mode reading and changes are done on stdin. David MacKenzie */ #ifdef HAVE_CONFIG_H #if defined (CONFIG_BROKETS) /* We use instead of "config.h" so that a compilation using -I. -I$srcdir will use ./config.h rather than $srcdir/config.h (which it would do because it found this file in $srcdir). */ #include #else #include "config.h" #endif #endif #include #include #include #ifdef GWINSZ_IN_SYS_IOCTL #include #endif #ifdef WINSIZE_IN_PTEM #include #include #endif #include #ifdef __STDC__ #include #define VA_START(args, lastarg) va_start(args, lastarg) #else #include #define VA_START(args, lastarg) va_start(args) #endif #include "system.h" #include "long-options.h" #if defined(GWINSZ_BROKEN) /* Such as for SCO UNIX 3.2.2. */ #undef TIOCGWINSZ #endif #ifndef _POSIX_VDISABLE #define _POSIX_VDISABLE ((unsigned char) 0) #endif #define Control(c) ((c) & 0x1f) /* Canonical values for control characters. */ #ifndef CINTR #define CINTR Control ('c') #endif #ifndef CQUIT #define CQUIT 28 #endif #ifndef CERASE #define CERASE 127 #endif #ifndef CKILL #define CKILL Control ('u') #endif #ifndef CEOF #define CEOF Control ('d') #endif #ifndef CEOL #define CEOL _POSIX_VDISABLE #endif #ifndef CSTART #define CSTART Control ('q') #endif #ifndef CSTOP #define CSTOP Control ('s') #endif #ifndef CSUSP #define CSUSP Control ('z') #endif #if defined(VEOL2) && !defined(CEOL2) #define CEOL2 _POSIX_VDISABLE #endif #if defined(VSWTCH) && !defined(CSWTCH) #define CSWTCH _POSIX_VDISABLE #endif /* SunOS 5.3 loses (^Z doesn't work) if `swtch' is the same as `susp'. So the default is to disable `swtch.' */ #if defined (__sparc__) && defined (__svr4__) #undef CSWTCH #define CSWTCH _POSIX_VDISABLE #endif #if defined(VDSUSP) && !defined (CDSUSP) #define CDSUSP Control ('y') #endif #if !defined(VREPRINT) && defined(VRPRNT) /* Irix 4.0.5 */ #define VREPRINT VRPRNT #endif #if defined(VREPRINT) && !defined(CRPRNT) #define CRPRNT Control ('r') #endif #if defined(VWERASE) && !defined(CWERASE) #define CWERASE Control ('w') #endif #if defined(VLNEXT) && !defined(CLNEXT) #define CLNEXT Control ('v') #endif #if defined(VDISCARD) && !defined(VFLUSHO) #define VFLUSHO VDISCARD #endif #if defined(VFLUSHO) && !defined(CFLUSHO) #define CFLUSHO Control ('o') #endif #if defined(VSTATUS) && !defined(CSTATUS) #define CSTATUS Control ('t') #endif static char *visible (); static unsigned long baud_to_value (); static int recover_mode (); static int screen_columns (); static int set_mode (); static long integer_arg (); static speed_t string_to_baud (); static tcflag_t *mode_type_flag (); static void display_all (); static void display_changed (); static void display_recoverable (); static void display_settings (); static void display_speed (); static void display_window_size (); static void sane_mode (); static void set_control_char (); static void set_speed (); static void set_window_size (); void error (); /* Which speeds to set. */ enum speed_setting { input_speed, output_speed, both_speeds }; /* What to output and how. */ enum output_type { changed, all, recoverable /* Default, -a, -g. */ }; /* Which member(s) of `struct termios' a mode uses. */ enum mode_type { control, input, output, local, combination }; /* Flags for `struct mode_info'. */ #define SANE_SET 1 /* Set in `sane' mode. */ #define SANE_UNSET 2 /* Unset in `sane' mode. */ #define REV 4 /* Can be turned off by prepending `-'. */ #define OMIT 8 /* Don't display value. */ /* Each mode. */ struct mode_info { char *name; /* Name given on command line. */ enum mode_type type; /* Which structure element to change. */ char flags; /* Setting and display options. */ unsigned long bits; /* Bits to set for this mode. */ unsigned long mask; /* Other bits to turn off for this mode. */ }; static struct mode_info mode_info[] = { {"parenb", control, REV, PARENB, 0}, {"parodd", control, REV, PARODD, 0}, {"cs5", control, 0, CS5, CSIZE}, {"cs6", control, 0, CS6, CSIZE}, {"cs7", control, 0, CS7, CSIZE}, {"cs8", control, 0, CS8, CSIZE}, {"hupcl", control, REV, HUPCL, 0}, {"hup", control, REV | OMIT, HUPCL, 0}, {"cstopb", control, REV, CSTOPB, 0}, {"cread", control, SANE_SET | REV, CREAD, 0}, {"clocal", control, REV, CLOCAL, 0}, #ifdef CRTSCTS {"crtscts", control, REV, CRTSCTS, 0}, #endif {"ignbrk", input, SANE_UNSET | REV, IGNBRK, 0}, {"brkint", input, SANE_SET | REV, BRKINT, 0}, {"ignpar", input, REV, IGNPAR, 0}, {"parmrk", input, REV, PARMRK, 0}, {"inpck", input, REV, INPCK, 0}, {"istrip", input, REV, ISTRIP, 0}, {"inlcr", input, SANE_UNSET | REV, INLCR, 0}, {"igncr", input, SANE_UNSET | REV, IGNCR, 0}, {"icrnl", input, SANE_SET | REV, ICRNL, 0}, {"ixon", input, REV, IXON, 0}, {"ixoff", input, SANE_UNSET | REV, IXOFF, 0}, {"tandem", input, REV | OMIT, IXOFF, 0}, #ifdef IUCLC {"iuclc", input, SANE_UNSET | REV, IUCLC, 0}, #endif #ifdef IXANY {"ixany", input, SANE_UNSET | REV, IXANY, 0}, #endif #ifdef IMAXBEL {"imaxbel", input, SANE_SET | REV, IMAXBEL, 0}, #endif {"opost", output, SANE_SET | REV, OPOST, 0}, #ifdef OLCUC {"olcuc", output, SANE_UNSET | REV, OLCUC, 0}, #endif #ifdef OCRNL {"ocrnl", output, SANE_UNSET | REV, OCRNL, 0}, #endif #ifdef ONLCR {"onlcr", output, SANE_SET | REV, ONLCR, 0}, #endif #ifdef ONOCR {"onocr", output, SANE_UNSET | REV, ONOCR, 0}, #endif #ifdef ONLRET {"onlret", output, SANE_UNSET | REV, ONLRET, 0}, #endif #ifdef OFILL {"ofill", output, SANE_UNSET | REV, OFILL, 0}, #endif #ifdef OFDEL {"ofdel", output, SANE_UNSET | REV, OFDEL, 0}, #endif #ifdef NLDLY {"nl1", output, SANE_UNSET, NL1, NLDLY}, {"nl0", output, SANE_SET, NL0, NLDLY}, #endif #ifdef CRDLY {"cr3", output, SANE_UNSET, CR3, CRDLY}, {"cr2", output, SANE_UNSET, CR2, CRDLY}, {"cr1", output, SANE_UNSET, CR1, CRDLY}, {"cr0", output, SANE_SET, CR0, CRDLY}, #endif #ifdef TABDLY {"tab3", output, SANE_UNSET, TAB3, TABDLY}, {"tab2", output, SANE_UNSET, TAB2, TABDLY}, {"tab1", output, SANE_UNSET, TAB1, TABDLY}, {"tab0", output, SANE_SET, TAB0, TABDLY}, #endif #ifdef BSDLY {"bs1", output, SANE_UNSET, BS1, BSDLY}, {"bs0", output, SANE_SET, BS0, BSDLY}, #endif #ifdef VTDLY {"vt1", output, SANE_UNSET, VT1, VTDLY}, {"vt0", output, SANE_SET, VT0, VTDLY}, #endif #ifdef FFDLY {"ff1", output, SANE_UNSET, FF1, FFDLY}, {"ff0", output, SANE_SET, FF0, FFDLY}, #endif {"isig", local, SANE_SET | REV, ISIG, 0}, {"icanon", local, SANE_SET | REV, ICANON, 0}, #ifdef IEXTEN {"iexten", local, SANE_SET | REV, IEXTEN, 0}, #endif {"echo", local, SANE_SET | REV, ECHO, 0}, {"echoe", local, SANE_SET | REV, ECHOE, 0}, {"crterase", local, REV | OMIT, ECHOE, 0}, {"echok", local, SANE_SET | REV, ECHOK, 0}, {"echonl", local, SANE_UNSET | REV, ECHONL, 0}, {"noflsh", local, SANE_UNSET | REV, NOFLSH, 0}, #ifdef XCASE {"xcase", local, SANE_UNSET | REV, XCASE, 0}, #endif #ifdef TOSTOP {"tostop", local, SANE_UNSET | REV, TOSTOP, 0}, #endif #ifdef ECHOPRT {"echoprt", local, SANE_UNSET | REV, ECHOPRT, 0}, {"prterase", local, REV | OMIT, ECHOPRT, 0}, #endif #ifdef ECHOCTL {"echoctl", local, SANE_SET | REV, ECHOCTL, 0}, {"ctlecho", local, REV | OMIT, ECHOCTL, 0}, #endif #ifdef ECHOKE {"echoke", local, SANE_SET | REV, ECHOKE, 0}, {"crtkill", local, REV | OMIT, ECHOKE, 0}, #endif {"evenp", combination, REV | OMIT, 0, 0}, {"parity", combination, REV | OMIT, 0, 0}, {"oddp", combination, REV | OMIT, 0, 0}, {"nl", combination, REV | OMIT, 0, 0}, {"ek", combination, OMIT, 0, 0}, {"sane", combination, OMIT, 0, 0}, {"cooked", combination, REV | OMIT, 0, 0}, {"raw", combination, REV | OMIT, 0, 0}, {"pass8", combination, REV | OMIT, 0, 0}, {"litout", combination, REV | OMIT, 0, 0}, {"cbreak", combination, REV | OMIT, 0, 0}, #ifdef IXANY {"decctlq", combination, REV | OMIT, 0, 0}, #endif #ifdef TABDLY {"tabs", combination, REV | OMIT, 0, 0}, #endif #if defined(XCASE) && defined(IUCLC) && defined(OLCUC) {"lcase", combination, REV | OMIT, 0, 0}, {"LCASE", combination, REV | OMIT, 0, 0}, #endif {"crt", combination, OMIT, 0, 0}, {"dec", combination, OMIT, 0, 0}, {NULL, control, 0, 0, 0} }; /* Control character settings. */ struct control_info { char *name; /* Name given on command line. */ unsigned char saneval; /* Value to set for `stty sane'. */ int offset; /* Offset in c_cc. */ }; /* Control characters. */ static struct control_info control_info[] = { {"intr", CINTR, VINTR}, {"quit", CQUIT, VQUIT}, {"erase", CERASE, VERASE}, {"kill", CKILL, VKILL}, {"eof", CEOF, VEOF}, {"eol", CEOL, VEOL}, #ifdef VEOL2 {"eol2", CEOL2, VEOL2}, #endif #ifdef VSWTCH {"swtch", CSWTCH, VSWTCH}, #endif {"start", CSTART, VSTART}, {"stop", CSTOP, VSTOP}, {"susp", CSUSP, VSUSP}, #ifdef VDSUSP {"dsusp", CDSUSP, VDSUSP}, #endif #ifdef VREPRINT {"rprnt", CRPRNT, VREPRINT}, #endif #ifdef VWERASE {"werase", CWERASE, VWERASE}, #endif #ifdef VLNEXT {"lnext", CLNEXT, VLNEXT}, #endif #ifdef VFLUSHO {"flush", CFLUSHO, VFLUSHO}, #endif #ifdef VSTATUS {"status", CSTATUS, VSTATUS}, #endif /* These must be last because of the display routines. */ {"min", 1, VMIN}, {"time", 0, VTIME}, {NULL, 0, 0} }; /* The width of the screen, for output wrapping. */ static int max_col; /* Current position, to know when to wrap. */ static int current_col; static struct option longopts[] = { {"all", no_argument, NULL, 'a'}, {"save", no_argument, NULL, 'g'}, {NULL, 0, NULL, 0} }; /* The name this program was run with. */ char *program_name; /* Print format string MESSAGE and optional args. Wrap to next line first if it won't fit. Print a space first unless MESSAGE will start a new line. */ /* VARARGS */ static void #ifdef __STDC__ wrapf (char *message, ...) #else wrapf (message, va_alist) char *message; va_dcl #endif { va_list args; char buf[1024]; /* Plenty long for our needs. */ int buflen; VA_START (args, message); vsprintf (buf, message, args); va_end (args); buflen = strlen (buf); if (current_col + (current_col > 0) + buflen >= max_col) { putchar ('\n'); current_col = 0; } if (current_col > 0) { putchar (' '); current_col++; } fputs (buf, stdout); current_col += buflen; } static void usage (status) int status; { if (status != 0) fprintf (stderr, "Try `%s --help' for more information.\n", program_name); else { printf ("\ Usage: %s [SETTING]...\n\ or: %s OPTION\n\ ", program_name, program_name); printf ("\ \n\ -a, --all print all current settings in human-readable form\n\ -g, --save print all current settings in a stty-readable form\n\ --help display this help and exit\n\ --version output version information and exit\n\ \n\ Optional - before SETTING indicates negation. An * marks non-POSIX\n\ settings. The underlying system defines which settings are available.\n\ "); printf ("\ \n\ Special characters:\n\ * dsusp CHAR CHAR will send a terminal stop signal once input flushed\n\ eof CHAR CHAR will send an end of file (terminate the input)\n\ eol CHAR CHAR will end the line\n\ * eol2 CHAR alternate CHAR for ending the line\n\ erase CHAR CHAR will erase the last character typed\n\ intr CHAR CHAR will send an interrupt signal\n\ kill CHAR CHAR will erase the current line\n\ * lnext CHAR CHAR will enter the next character quoted\n\ quit CHAR CHAR will send a quit signal\n\ * rprnt CHAR CHAR will redraw the current line\n\ start CHAR CHAR will restart the output after stopping it\n\ stop CHAR CHAR will stop the output\n\ susp CHAR CHAR will send a terminal stop signal\n\ * swtch CHAR CHAR will switch to a different shell layer\n\ * werase CHAR CHAR will erase the last word typed\n\ "); printf ("\ \n\ Special settings:\n\ N set the input and output speeds to N bauds\n\ * cols N tell the kernel that the terminal has N columns\n\ * columns N same as cols N\n\ ispeed N set the input speed to N\n\ * line N use line discipline N\n\ min N with -icanon, set N characters minimum for a completed read\n\ ospeed N set the output speed to N\n\ * rows N tell the kernel that the terminal has N rows\n\ * size print the number of rows and columns according to the kernel\n\ speed print the terminal speed\n\ time N with -icanon, set read timeout of N tenths of a second\n\ "); printf ("\ \n\ Control settings:\n\ [-]clocal disable modem control signals\n\ [-]cread allow input to be received\n\ * [-]crtscts enable RTS/CTS handshaking\n\ csN set character size to N bits, N in [5..8]\n\ [-]cstopb use two stop bits per character (one with `-')\n\ [-]hup send a hangup signal when the last process closes the tty\n\ [-]hupcl same as [-]hup\n\ [-]parenb generate parity bit in output and expect parity bit in input\n\ [-]parodd set odd parity (even with `-')\n\ "); printf ("\ \n\ Input settings:\n\ [-]brkint breaks cause an interrupt signal\n\ [-]icrnl translate carriage return to newline\n\ [-]ignbrk ignore breaks\n\ [-]igncr ignore carriage return\n\ [-]ignpar ignore parity errors\n\ * [-]imaxbel beep and do not flush a full input buffer on a character\n\ [-]inlcr translate newline to carriage return\n\ [-]inpck enable input parity checking\n\ [-]istrip clear high (8th) bit of input characters\n\ * [-]iuclc translate uppercase characters to lowercase\n\ * [-]ixany let any character restart output, not only start character\n\ [-]ixoff enable sending of start/stop characters\n\ [-]ixon enable XON/XOFF flow control\n\ [-]parmrk mark parity errors (with a 255-0-character sequence)\n\ [-]tandem same as [-]ixoff\n\ "); printf ("\ \n\ Output settings:\n\ * bsN backspace delay style, N in [0..1]\n\ * crN carriage return delay style, N in [0..3]\n\ * ffN form feed delay style, N in [0..1]\n\ * nlN newline delay style, N in [0..1]\n\ * [-]ocrnl translate carriage return to newline\n\ * [-]ofdel use delete characters for fill instead of null characters\n\ * [-]ofill use fill (padding) characters instead of timing for delays\n\ * [-]olcuc translate lowercase characters to uppercase\n\ * [-]onlcr translate newline to carriage return-newline\n\ * [-]onlret newline performs a carriage return\n\ * [-]onocr do not print carriage returns in the first column\n\ [-]opost postprocess output\n\ * tabN horizontal tab delay style, N in [0..3]\n\ * tabs same as tab0\n\ * -tabs same as tab3\n\ * vtN vertical tab delay style, N in [0..1]\n\ "); printf ("\ \n\ Local settings:\n\ [-]crterase echo erase characters as backspace-space-backspace\n\ * crtkill kill all line by obeying the echoprt and echoe settings\n\ * -crtkill kill all line by obeying the echoctl and echok settings\n\ * [-]ctlecho echo control characters in hat notation (`^c')\n\ [-]echo echo input characters\n\ * [-]echoctl same as [-]ctlecho\n\ [-]echoe same as [-]crterase\n\ [-]echok echo a newline after a kill character\n\ * [-]echoke same as [-]crtkill\n\ [-]echonl echo newline even if not echoing other characters\n\ * [-]echoprt echo erased characters backward, between `\\' and '/'\n\ [-]icanon enable erase, kill, werase, and rprnt special characters\n\ [-]iexten enable non-POSIX special characters\n\ [-]isig enable interrupt, quit, and suspend special characters\n\ [-]noflsh disable flushing after interrupt and quit special characters\n\ * [-]prterase same as [-]echoprt\n\ * [-]tostop stop background jobs that try to write to the terminal\n\ * [-]xcase with icanon, escape with `\\' for uppercase characters\n\ "); printf ("\ \n\ Combination settings:\n\ * [-]LCASE same as [-]lcase\n\ cbreak same as -icanon\n\ -cbreak same as icanon\n\ cooked same as brkint ignpar istrip icrnl ixon opost isig\n\ icanon, eof and eol characters to their default values\n\ -cooked same as raw\n\ crt same as echoe echoctl echoke\n\ dec same as echoe echoctl echoke -ixany intr ^c erase 0177\n\ kill ^u\n\ * [-]decctlq same as [-]ixany\n\ ek erase and kill characters to their default values\n\ evenp same as parenb -parodd cs7\n\ -evenp same as -parenb cs8\n\ * [-]lcase same as xcase iuclc olcuc\n\ litout same as -parenb -istrip -opost cs8\n\ -litout same as parenb istrip opost cs7\n\ nl same as -icrnl -onlcr\n\ -nl same as icrnl -inlcr -igncr onlcr -ocrnl -onlret\n\ oddp same as parenb parodd cs7\n\ -oddp same as -parenb cs8\n\ [-]parity same as [-]evenp\n\ pass8 same as -parenb -istrip cs8\n\ -pass8 same as parenb istrip cs7\n\ raw same as -ignbrk -brkint -ignpar -parmrk -inpck -istrip\n\ -inlcr -igncr -icrnl -ixon -ixoff -iuclc -ixany\n\ -imaxbel -opost -isig -icanon -xcase min 1 time 0\n\ -raw same as cooked\n\ sane same as cread -ignbrk brkint -inlcr -igncr icrnl\n\ -ixoff -iucl -ixany imaxbel opost -olcuc -ocrnl onlcr\n\ -onocr -onlret -ofill -ofdel nl0 cr0 tab0 bs0 vt0 ff0\n\ isig icanon iexten echo echoe echok -echonl -noflsh\n\ -xcase -tostop -echoprt echoctl echoke, all special\n\ characters to their default values.\n\ "); printf ("\ \n\ Handle the tty line connected to standard input. Without arguments,\n\ prints baud rate, line discipline, and deviations from stty sane. In\n\ settings, CHAR is taken literally, or coded as in ^c, 0x37, 0177 or\n\ 127; special values ^- or undef used to disable special characters.\n\ "); } exit (status); } void main (argc, argv) int argc; char **argv; { struct termios mode; enum output_type output_type; int optc; int require_set_attr; int speed_was_set; int verbose_output; int recoverable_output; int k; program_name = argv[0]; parse_long_options (argc, argv, "stty", usage); output_type = changed; verbose_output = 0; recoverable_output = 0; /* Recognize the long options only. */ opterr = 0; while ((optc = getopt_long_only (argc, argv, "ag", longopts, (int *) 0)) != EOF) { switch (optc) { case 'a': verbose_output = 1; output_type = all; break; case 'g': recoverable_output = 1; output_type = recoverable; break; default: break; } } /* Recognize short options and combinations: -a, -g, -ag, and -ga. They need not precede non-options. We cannot use GNU getopt because it would treat -tabs and -ixany as uses of the -a option. */ for (k = optind; k < argc; k++) { if (argv[k][0] == '-') { if (argv[k][1] == 'a' && argv[k][2] == '\0') { ++optind; verbose_output = 1; } else if (argv[k][1] == 'g' && argv[k][2] == '\0') { ++optind; recoverable_output = 1; } else if ((argv[k][1] == 'g' && argv[k][2] == 'a' && argv[k][3] == '\0') || (argv[k][1] == 'a' && argv[k][2] == 'g' && argv[k][3] == '\0')) { ++optind; verbose_output = 1; recoverable_output = 1; } } } /* Specifying both -a and -g gets an error. */ if (verbose_output && recoverable_output) error (2, 0, "the options for verbose and stty-readable output styles are\n\ \tmutually exclusive"); /* Specifying any other arguments with -a or -g gets an error. */ if (argc - optind > 0 && (verbose_output || recoverable_output)) error (2, 0, "when specifying an output style, modes may not be set"); /* Initialize to all zeroes so there is no risk memcmp will report a spurious difference in an uninitialized portion of the structure. */ bzero (&mode, sizeof (mode)); if (tcgetattr (0, &mode)) error (1, errno, "standard input"); if (verbose_output || recoverable_output || argc == 1) { max_col = screen_columns (); current_col = 0; display_settings (output_type, &mode); exit (0); } speed_was_set = 0; require_set_attr = 0; k = 1; while (k < argc) { int match_found = 0; int reversed = 0; int i; if (argv[k][0] == '-') { ++argv[k]; reversed = 1; } for (i = 0; mode_info[i].name != NULL; ++i) { if (!strcmp (argv[k], mode_info[i].name)) { match_found = set_mode (&mode_info[i], reversed, &mode); require_set_attr = 1; break; } } if (match_found == 0 && reversed) { error (0, 0, "invalid argument `%s'", --argv[k]); usage (1); } if (match_found == 0) { for (i = 0; control_info[i].name != NULL; ++i) { if (!strcmp (argv[k], control_info[i].name)) { if (k == argc - 1) { error (0, 0, "missing argument to `%s'", argv[k]); usage (1); } match_found = 1; ++k; set_control_char (&control_info[i], argv[k], &mode); require_set_attr = 1; break; } } } if (match_found == 0) { if (!strcmp (argv[k], "ispeed")) { if (k == argc - 1) { error (0, 0, "missing argument to `%s'", argv[k]); usage (1); } ++k; set_speed (input_speed, argv[k], &mode); speed_was_set = 1; require_set_attr = 1; } else if (!strcmp (argv[k], "ospeed")) { if (k == argc - 1) { error (0, 0, "missing argument to `%s'", argv[k]); usage (1); } ++k; set_speed (output_speed, argv[k], &mode); speed_was_set = 1; require_set_attr = 1; } #ifdef TIOCGWINSZ else if (!strcmp (argv[k], "rows")) { if (k == argc - 1) { error (0, 0, "missing argument to `%s'", argv[k]); usage (1); } ++k; set_window_size ((int) integer_arg (argv[k]), -1); } else if (!strcmp (argv[k], "cols") || !strcmp (argv[k], "columns")) { if (k == argc - 1) { error (0, 0, "missing argument to `%s'", argv[k]); usage (1); } ++k; set_window_size (-1, (int) integer_arg (argv[k])); } else if (!strcmp (argv[k], "size")) display_window_size (0); #endif #ifdef HAVE_C_LINE else if (!strcmp (argv[k], "line")) { if (k == argc - 1) { error (0, 0, "missing argument to `%s'", argv[k]); usage (1); } ++k; mode.c_line = integer_arg (argv[k]); require_set_attr = 1; } #endif else if (!strcmp (argv[k], "speed")) display_speed (&mode, 0); else if (string_to_baud (argv[k]) != (speed_t) -1) { set_speed (both_speeds, argv[k], &mode); speed_was_set = 1; require_set_attr = 1; } else { if (recover_mode (argv[k], &mode) == 0) { error (0, 0, "invalid argument `%s'", argv[k]); usage (1); } require_set_attr = 1; } } k++; } if (require_set_attr) { struct termios new_mode; if (tcsetattr (0, TCSADRAIN, &mode)) error (1, errno, "standard input"); /* POSIX (according to Zlotnick's book) tcsetattr returns zero if it performs *any* of the requested operations. This means it can report `success' when it has actually failed to perform some proper subset of the requested operations. To detect this partial failure, get the current terminal attributes and compare them to the requested ones. */ /* Initialize to all zeroes so there is no risk memcmp will report a spurious difference in an uninitialized portion of the structure. */ bzero (&new_mode, sizeof (new_mode)); if (tcgetattr (0, &new_mode)) error (1, errno, "standard input"); /* Normally, one shouldn't use memcmp to compare structures that may have `holes' containing uninitialized data, but we have been careful to initialize the storage of these two variables to all zeroes. One might think it more efficient simply to compare the modified fields, but that would require enumerating those fields -- and not all systems have the same fields in this structure. */ if (memcmp (&mode, &new_mode, sizeof (mode)) != 0) { #ifdef CIBAUD /* SunOS 4.1.3 (at least) has the problem that after this sequence, tcgetattr(&m1); tcsetattr(&m1); tcgetattr(&m2); sometimes (m1 != m2). The only difference is in the four bits of the c_cflag field corresponding to the baud rate. To save Sun users a little confusion, don't report an error if this happens. But suppress the error only if we haven't tried to set the baud rate explicitly -- otherwise we'd never give an error for a true failure to set the baud rate. */ new_mode.c_cflag &= (~CIBAUD); if (speed_was_set || memcmp (&mode, &new_mode, sizeof (mode)) != 0) #endif error (1, 0, "standard input: unable to perform all requested operations"); } } exit (0); } /* Return 0 if not applied because not reversible; otherwise return 1. */ static int set_mode (info, reversed, mode) struct mode_info *info; int reversed; struct termios *mode; { tcflag_t *bitsp; if (reversed && (info->flags & REV) == 0) return 0; bitsp = mode_type_flag (info->type, mode); if (bitsp == NULL) { /* Combination mode. */ if (!strcmp (info->name, "evenp") || !strcmp (info->name, "parity")) { if (reversed) mode->c_cflag = (mode->c_cflag & ~PARENB & ~CSIZE) | CS8; else mode->c_cflag = (mode->c_cflag & ~PARODD & ~CSIZE) | PARENB | CS7; } else if (!strcmp (info->name, "oddp")) { if (reversed) mode->c_cflag = (mode->c_cflag & ~PARENB & ~CSIZE) | CS8; else mode->c_cflag = (mode->c_cflag & ~CSIZE) | CS7 | PARODD | PARENB; } else if (!strcmp (info->name, "nl")) { if (reversed) { mode->c_iflag = (mode->c_iflag | ICRNL) & ~INLCR & ~IGNCR; mode->c_oflag = (mode->c_oflag #ifdef ONLCR | ONLCR #endif ) #ifdef OCRNL & ~OCRNL #endif #ifdef ONLRET & ~ONLRET #endif ; } else { mode->c_iflag = mode->c_iflag & ~ICRNL; #ifdef ONLCR mode->c_oflag = mode->c_oflag & ~ONLCR; #endif } } else if (!strcmp (info->name, "ek")) { mode->c_cc[VERASE] = CERASE; mode->c_cc[VKILL] = CKILL; } else if (!strcmp (info->name, "sane")) sane_mode (mode); else if (!strcmp (info->name, "cbreak")) { if (reversed) mode->c_lflag |= ICANON; else mode->c_lflag &= ~ICANON; } else if (!strcmp (info->name, "pass8")) { if (reversed) { mode->c_cflag = (mode->c_cflag & ~CSIZE) | CS7 | PARENB; mode->c_iflag |= ISTRIP; } else { mode->c_cflag = (mode->c_cflag & ~PARENB & ~CSIZE) | CS8; mode->c_iflag &= ~ISTRIP; } } else if (!strcmp (info->name, "litout")) { if (reversed) { mode->c_cflag = (mode->c_cflag & ~CSIZE) | CS7 | PARENB; mode->c_iflag |= ISTRIP; mode->c_oflag |= OPOST; } else { mode->c_cflag = (mode->c_cflag & ~PARENB & ~CSIZE) | CS8; mode->c_iflag &= ~ISTRIP; mode->c_oflag &= ~OPOST; } } else if (!strcmp (info->name, "raw") || !strcmp (info->name, "cooked")) { if ((info->name[0] == 'r' && reversed) || (info->name[0] == 'c' && !reversed)) { /* Cooked mode. */ mode->c_iflag |= BRKINT | IGNPAR | ISTRIP | ICRNL | IXON; mode->c_oflag |= OPOST; mode->c_lflag |= ISIG | ICANON; #if VMIN == VEOF mode->c_cc[VEOF] = CEOF; #endif #if VTIME == VEOL mode->c_cc[VEOL] = CEOL; #endif } else { /* Raw mode. */ mode->c_iflag = 0; mode->c_oflag &= ~OPOST; mode->c_lflag &= ~(ISIG | ICANON #ifdef XCASE | XCASE #endif ); mode->c_cc[VMIN] = 1; mode->c_cc[VTIME] = 0; } } #ifdef IXANY else if (!strcmp (info->name, "decctlq")) { if (reversed) mode->c_iflag |= IXANY; else mode->c_iflag &= ~IXANY; } #endif #ifdef TABDLY else if (!strcmp (info->name, "tabs")) { if (reversed) mode->c_oflag = (mode->c_oflag & ~TABDLY) | TAB3; else mode->c_oflag = (mode->c_oflag & ~TABDLY) | TAB0; } #endif #if defined(XCASE) && defined(IUCLC) && defined(OLCUC) else if (!strcmp (info->name, "lcase") || !strcmp (info->name, "LCASE")) { if (reversed) { mode->c_lflag &= ~XCASE; mode->c_iflag &= ~IUCLC; mode->c_oflag &= ~OLCUC; } else { mode->c_lflag |= XCASE; mode->c_iflag |= IUCLC; mode->c_oflag |= OLCUC; } } #endif else if (!strcmp (info->name, "crt")) mode->c_lflag |= ECHOE #ifdef ECHOCTL | ECHOCTL #endif #ifdef ECHOKE | ECHOKE #endif ; else if (!strcmp (info->name, "dec")) { mode->c_cc[VINTR] = 3; /* ^C */ mode->c_cc[VERASE] = 127; /* DEL */ mode->c_cc[VKILL] = 21; /* ^U */ mode->c_lflag |= ECHOE #ifdef ECHOCTL | ECHOCTL #endif #ifdef ECHOKE | ECHOKE #endif ; #ifdef IXANY mode->c_iflag &= ~IXANY; #endif } } else if (reversed) *bitsp = *bitsp & ~info->mask & ~info->bits; else *bitsp = (*bitsp & ~info->mask) | info->bits; return 1; } static void set_control_char (info, arg, mode) struct control_info *info; char *arg; struct termios *mode; { unsigned char value; if (!strcmp (info->name, "min") || !strcmp (info->name, "time")) value = integer_arg (arg); else if (arg[0] == '\0' || arg[1] == '\0') value = arg[0]; else if (!strcmp (arg, "^-") || !strcmp (arg, "undef")) value = _POSIX_VDISABLE; else if (arg[0] == '^' && arg[1] != '\0') /* Ignore any trailing junk. */ { if (arg[1] == '?') value = 127; else value = arg[1] & ~0140; /* Non-letters get weird results. */ } else value = integer_arg (arg); mode->c_cc[info->offset] = value; } static void set_speed (type, arg, mode) enum speed_setting type; char *arg; struct termios *mode; { speed_t baud; baud = string_to_baud (arg); if (type == input_speed || type == both_speeds) cfsetispeed (mode, baud); if (type == output_speed || type == both_speeds) cfsetospeed (mode, baud); } #ifdef TIOCGWINSZ /* Get window size information. First try getting the information associated with standard output and if that fails, try standard input. Return zero for success, non-zero if both ioctl's failed. */ static int get_win_size (win) struct winsize *win; { int err; err = ioctl (1, TIOCGWINSZ, (char *) win); if (err != 0) err = ioctl (0, TIOCGWINSZ, (char *) win); return err; } static void set_window_size (rows, cols) int rows, cols; { struct winsize win; if (get_win_size (&win)) { if (errno != EINVAL) error (1, errno, "standard input"); bzero (&win, sizeof (win)); } if (rows >= 0) win.ws_row = rows; if (cols >= 0) win.ws_col = cols; #ifdef TIOCSSIZE /* Alexander Dupuy wrote: The following code deals with a bug in the SunOS 4.x (and 3.x?) kernel. This comment from sys/ttold.h describes Sun's twisted logic - a better test would have been (ts_lines > 64k || ts_cols > 64k || ts_cols == 0). At any rate, the problem is gone in Solaris 2.x. Unfortunately, the old TIOCSSIZE code does collide with TIOCSWINSZ, but they can be disambiguated by checking whether a "struct ttysize" structure's "ts_lines" field is greater than 64K or not. If so, it's almost certainly a "struct winsize" instead. At any rate, the bug manifests itself when ws_row == 0; the symptom is that ws_row is set to ws_col, and ws_col is set to (ws_xpixel<<16) + ws_ypixel. Since GNU stty sets rows and columns separately, this bug caused "stty rows 0 cols 0" to set rows to cols and cols to 0, while "stty cols 0 rows 0" would do the right thing. On a little-endian machine like the sun386i, the problem is the same, but for ws_col == 0. The workaround is to do the ioctl once with row and col = 1 to set the pixel info, and then do it again using a TIOCSSIZE to set rows/cols. */ if (win.ws_row == 0 || win.ws_col == 0) { struct ttysize ttysz; ttysz.ts_lines = win.ws_row; ttysz.ts_cols = win.ws_col; win.ws_row = 1; win.ws_col = 1; if (ioctl (0, TIOCSWINSZ, (char *) &win)) error (1, errno, "standard input"); if (ioctl (0, TIOCSSIZE, (char *) &ttysz)) error (1, errno, "standard input"); return; } #endif if (ioctl (0, TIOCSWINSZ, (char *) &win)) error (1, errno, "standard input"); } static void display_window_size (fancy) int fancy; { struct winsize win; if (get_win_size (&win)) { if (errno != EINVAL) error (1, errno, "standard input"); } else { wrapf (fancy ? "rows %d; columns %d;" : "%d %d\n", win.ws_row, win.ws_col); if (!fancy) current_col = 0; } } #endif static int screen_columns () { #ifdef TIOCGWINSZ struct winsize win; if (get_win_size (&win)) { /* With Solaris 2.[123], this ioctl fails and errno is set to EINVAL for telnet (but not rlogin) sessions. */ if (errno != EINVAL) error (1, errno, "standard input"); } else if (win.ws_col > 0) return win.ws_col; #endif if (getenv ("COLUMNS")) return atoi (getenv ("COLUMNS")); return 80; } static tcflag_t * mode_type_flag (type, mode) enum mode_type type; struct termios *mode; { switch (type) { case control: return &mode->c_cflag; case input: return &mode->c_iflag; case output: return &mode->c_oflag; case local: return &mode->c_lflag; case combination: return NULL; default: abort (); } } static void display_settings (output_type, mode) enum output_type output_type; struct termios *mode; { switch (output_type) { case changed: display_changed (mode); break; case all: display_all (mode); break; case recoverable: display_recoverable (mode); break; } } static void display_changed (mode) struct termios *mode; { int i; int empty_line; tcflag_t *bitsp; unsigned long mask; enum mode_type prev_type = control; display_speed (mode, 1); #ifdef HAVE_C_LINE wrapf ("line = %d;", mode->c_line); #endif putchar ('\n'); current_col = 0; empty_line = 1; for (i = 0; strcmp (control_info[i].name, "min"); ++i) { if (mode->c_cc[control_info[i].offset] == control_info[i].saneval) continue; empty_line = 0; wrapf ("%s = %s;", control_info[i].name, visible (mode->c_cc[control_info[i].offset])); } if ((mode->c_lflag & ICANON) == 0) { wrapf ("min = %d; time = %d;\n", (int) mode->c_cc[VMIN], (int) mode->c_cc[VTIME]); } else if (empty_line == 0) putchar ('\n'); current_col = 0; empty_line = 1; for (i = 0; mode_info[i].name != NULL; ++i) { if (mode_info[i].flags & OMIT) continue; if (mode_info[i].type != prev_type) { if (empty_line == 0) { putchar ('\n'); current_col = 0; empty_line = 1; } prev_type = mode_info[i].type; } bitsp = mode_type_flag (mode_info[i].type, mode); mask = mode_info[i].mask ? mode_info[i].mask : mode_info[i].bits; if ((*bitsp & mask) == mode_info[i].bits) { if (mode_info[i].flags & SANE_UNSET) { wrapf ("%s", mode_info[i].name); empty_line = 0; } } else if ((mode_info[i].flags & (SANE_SET | REV)) == (SANE_SET | REV)) { wrapf ("-%s", mode_info[i].name); empty_line = 0; } } if (empty_line == 0) putchar ('\n'); current_col = 0; } static void display_all (mode) struct termios *mode; { int i; tcflag_t *bitsp; unsigned long mask; enum mode_type prev_type = control; display_speed (mode, 1); #ifdef TIOCGWINSZ display_window_size (1); #endif #ifdef HAVE_C_LINE wrapf ("line = %d;", mode->c_line); #endif putchar ('\n'); current_col = 0; for (i = 0; strcmp (control_info[i].name, "min"); ++i) { wrapf ("%s = %s;", control_info[i].name, visible (mode->c_cc[control_info[i].offset])); } wrapf ("min = %d; time = %d;\n", mode->c_cc[VMIN], mode->c_cc[VTIME]); current_col = 0; for (i = 0; mode_info[i].name != NULL; ++i) { if (mode_info[i].flags & OMIT) continue; if (mode_info[i].type != prev_type) { putchar ('\n'); current_col = 0; prev_type = mode_info[i].type; } bitsp = mode_type_flag (mode_info[i].type, mode); mask = mode_info[i].mask ? mode_info[i].mask : mode_info[i].bits; if ((*bitsp & mask) == mode_info[i].bits) wrapf ("%s", mode_info[i].name); else if (mode_info[i].flags & REV) wrapf ("-%s", mode_info[i].name); } putchar ('\n'); current_col = 0; } static void display_speed (mode, fancy) struct termios *mode; int fancy; { if (cfgetispeed (mode) == 0 || cfgetispeed (mode) == cfgetospeed (mode)) wrapf (fancy ? "speed %lu baud;" : "%lu\n", baud_to_value (cfgetospeed (mode))); else wrapf (fancy ? "ispeed %lu baud; ospeed %lu baud;" : "%lu %lu\n", baud_to_value (cfgetispeed (mode)), baud_to_value (cfgetospeed (mode))); if (!fancy) current_col = 0; } static void display_recoverable (mode) struct termios *mode; { int i; printf ("%lx:%lx:%lx:%lx", (unsigned long) mode->c_iflag, (unsigned long) mode->c_oflag, (unsigned long) mode->c_cflag, (unsigned long) mode->c_lflag); for (i = 0; i < NCCS; ++i) printf (":%x", (unsigned int) mode->c_cc[i]); putchar ('\n'); } static int recover_mode (arg, mode) char *arg; struct termios *mode; { int i, n; unsigned int chr; unsigned long iflag, oflag, cflag, lflag; /* Scan into temporaries since it is too much trouble to figure out the right format for `tcflag_t'. */ if (sscanf (arg, "%lx:%lx:%lx:%lx%n", &iflag, &oflag, &cflag, &lflag, &n) != 4) return 0; mode->c_iflag = iflag; mode->c_oflag = oflag; mode->c_cflag = cflag; mode->c_lflag = lflag; arg += n; for (i = 0; i < NCCS; ++i) { if (sscanf (arg, ":%x%n", &chr, &n) != 1) return 0; mode->c_cc[i] = chr; arg += n; } return 1; } struct speed_map { char *string; /* ASCII representation. */ speed_t speed; /* Internal form. */ unsigned long value; /* Numeric value. */ }; struct speed_map speeds[] = { {"0", B0, 0}, {"50", B50, 50}, {"75", B75, 75}, {"110", B110, 110}, {"134", B134, 134}, {"134.5", B134, 134}, {"150", B150, 150}, {"200", B200, 200}, {"300", B300, 300}, {"600", B600, 600}, {"1200", B1200, 1200}, {"1800", B1800, 1800}, {"2400", B2400, 2400}, {"4800", B4800, 4800}, {"9600", B9600, 9600}, {"19200", B19200, 19200}, {"38400", B38400, 38400}, {"exta", B19200, 19200}, {"extb", B38400, 38400}, #ifdef B57600 {"57600", B57600, 57600}, #endif #ifdef B115200 {"115200", B115200, 115200}, #endif {NULL, 0, 0} }; static speed_t string_to_baud (arg) char *arg; { int i; for (i = 0; speeds[i].string != NULL; ++i) if (!strcmp (arg, speeds[i].string)) return speeds[i].speed; return (speed_t) -1; } static unsigned long baud_to_value (speed) speed_t speed; { int i; for (i = 0; speeds[i].string != NULL; ++i) if (speed == speeds[i].speed) return speeds[i].value; return 0; } static void sane_mode (mode) struct termios *mode; { int i; tcflag_t *bitsp; for (i = 0; control_info[i].name; ++i) { #if VMIN == VEOF if (!strcmp (control_info[i].name, "min")) break; #endif mode->c_cc[control_info[i].offset] = control_info[i].saneval; } for (i = 0; mode_info[i].name != NULL; ++i) { if (mode_info[i].flags & SANE_SET) { bitsp = mode_type_flag (mode_info[i].type, mode); *bitsp = (*bitsp & ~mode_info[i].mask) | mode_info[i].bits; } else if (mode_info[i].flags & SANE_UNSET) { bitsp = mode_type_flag (mode_info[i].type, mode); *bitsp = *bitsp & ~mode_info[i].mask & ~mode_info[i].bits; } } } /* Return a string that is the printable representation of character CH. */ /* Adapted from `cat' by Torbjorn Granlund. */ static char * visible (ch) unsigned char ch; { static char buf[10]; char *bpout = buf; if (ch == _POSIX_VDISABLE) return ""; if (ch >= 32) { if (ch < 127) *bpout++ = ch; else if (ch == 127) { *bpout++ = '^'; *bpout++ = '?'; } else { *bpout++ = 'M', *bpout++ = '-'; if (ch >= 128 + 32) { if (ch < 128 + 127) *bpout++ = ch - 128; else { *bpout++ = '^'; *bpout++ = '?'; } } else { *bpout++ = '^'; *bpout++ = ch - 128 + 64; } } } else { *bpout++ = '^'; *bpout++ = ch + 64; } *bpout = '\0'; return buf; } /* Parse string S as an integer, using decimal radix by default, but allowing octal and hex numbers as in C. */ /* From `od' by Richard Stallman. */ static long integer_arg (s) char *s; { long value; int radix = 10; char *p = s; int c; if (*p != '0') radix = 10; else if (*++p == 'x') { radix = 16; p++; } else radix = 8; value = 0; while (((c = *p++) >= '0' && c <= '9') || (radix == 16 && (c & ~40) >= 'A' && (c & ~40) <= 'Z')) { value *= radix; if (c >= '0' && c <= '9') value += c - '0'; else value += (c & ~40) - 'A'; } if (c == 'b') value *= 512; else if (c == 'B') value *= 1024; else p--; if (*p) { error (0, 0, "invalid integer argument `%s'", s); usage (1); } return value; } sh-utils-1.10/src/uname.c100666 74504 1 11547 5555072464 14633 0ustar meyeringdaemon/* uname -- print system information Copyright (C) 89, 90, 91, 92, 93, 1994 Free Software Foundation, Inc. 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 2, 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, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ /* Option Example -s, --sysname SunOS -n, --nodename rocky8 -r, --release 4.0 -v, --version -m, --machine sun -a, --all SunOS rocky8 4.0 sun The default behavior is equivalent to `-s'. David MacKenzie */ #ifdef HAVE_CONFIG_H #if defined (CONFIG_BROKETS) /* We use instead of "config.h" so that a compilation using -I. -I$srcdir will use ./config.h rather than $srcdir/config.h (which it would do because it found this file in $srcdir). */ #include #else #include "config.h" #endif #endif #include #include #include #include #include "system.h" #include "version.h" void error (); static void print_element (); static void usage (); /* Values that are bitwise or'd into `toprint'. */ /* Operating system name. */ #define PRINT_SYSNAME 1 /* Node name on a communications network. */ #define PRINT_NODENAME 2 /* Operating system release. */ #define PRINT_RELEASE 4 /* Operating system version. */ #define PRINT_VERSION 8 /* Machine hardware name. */ #define PRINT_MACHINE 16 /* Mask indicating which elements of the name to print. */ static unsigned char toprint; /* The name this program was run with, for error messages. */ char *program_name; /* If non-zero, display usage information and exit. */ static int show_help; /* If non-zero, print the version on standard output and exit. */ static int show_version; static struct option const long_options[] = { {"help", no_argument, &show_help, 1}, {"machine", no_argument, NULL, 'm'}, {"nodename", no_argument, NULL, 'n'}, {"release", no_argument, NULL, 'r'}, {"sysname", no_argument, NULL, 's'}, {"version", no_argument, &show_version, 1}, {"all", no_argument, NULL, 'a'}, {NULL, 0, NULL, 0} }; void main (argc, argv) int argc; char **argv; { struct utsname name; int c; program_name = argv[0]; toprint = 0; while ((c = getopt_long (argc, argv, "snrvma", long_options, (int *) 0)) != EOF) { switch (c) { case 0: break; case 's': toprint |= PRINT_SYSNAME; break; case 'n': toprint |= PRINT_NODENAME; break; case 'r': toprint |= PRINT_RELEASE; break; case 'v': toprint |= PRINT_VERSION; break; case 'm': toprint |= PRINT_MACHINE; break; case 'a': toprint = PRINT_SYSNAME | PRINT_NODENAME | PRINT_RELEASE | PRINT_VERSION | PRINT_MACHINE; break; default: usage (1); } } if (show_version) { printf ("uname - %s\n", version_string); exit (0); } if (show_help) usage (0); if (optind != argc) usage (1); if (toprint == 0) toprint = PRINT_SYSNAME; if (uname (&name) == -1) error (1, errno, "cannot get system name"); print_element (PRINT_SYSNAME, name.sysname); print_element (PRINT_NODENAME, name.nodename); print_element (PRINT_RELEASE, name.release); print_element (PRINT_VERSION, name.version); print_element (PRINT_MACHINE, name.machine); exit (0); } /* If the name element set in MASK is selected for printing in `toprint', print ELEMENT; then print a space unless it is the last element to be printed, in which case print a newline. */ static void print_element (mask, element) unsigned char mask; char *element; { if (toprint & mask) { toprint &= ~mask; printf ("%s%c", element, toprint ? ' ' : '\n'); } } static void usage (status) int status; { if (status != 0) fprintf (stderr, "Try `%s --help' for more information.\n", program_name); else { printf ("Usage: %s [OPTION]...\n", program_name); printf ("\ \n\ -a, --all print all information\n\ -m, --machine print the machine (hardware) type\n\ -n, --nodename print the machine's network node hostname\n\ -r, --release print the operating system release\n\ -s, --sysname print the operating system name\n\ -v print the operating system version\n\ --help display this help and exit\n\ --version output version information and exit\n\ \n\ Without any OPTION, assume -s.\n\ "); } exit (status); } sh-utils-1.10/src/version.c100666 74504 13 601 5566745203 14676 0ustar meyeringuser#ifdef HAVE_CONFIG_H #if defined (CONFIG_BROKETS) /* We use instead of "config.h" so that a compilation using -I. -I$srcdir will use ./config.h rather than $srcdir/config.h (which it would do because it found this file in $srcdir). */ #include #else #include "config.h" #endif #endif #include "version.h" const char *version_string = "GNU sh-utils 1.10"; sh-utils-1.10/src/groups.sh100777 74504 1 2625 5555072440 15207 0ustar meyeringdaemon#!/bin/sh # groups -- print the groups a user is in # Copyright (C) 1991 Free Software Foundation, Inc. # 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 2, 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, write to the Free Software # Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. # Written by David MacKenzie . # Make sure we get GNU id, if possible; also allow # it to be somewhere else in PATH if not installed yet. PATH=@bindir@:$PATH usage="Usage: $0 [OPTION]... [USERNAME]... --help display this help and exit --version output version information and exit Same as id -Gn. If no USERNAME, use current process." case $# in 1 ) case "z${1}" in z--help ) echo "$usage"; exit 0 ;; z--version ) echo "groups - @VERSION@"; exit 0 ;; * ) ;; esac ;; * ) ;; esac if [ $# -eq 0 ]; then id -Gn else for name in "$@"; do echo $name : `id -Gn $name` done fi sh-utils-1.10/src/nohup.sh100777 74504 1 3766 5555072446 15036 0ustar meyeringdaemon#!/bin/sh # nohup -- run a command immume to hangups, with output to a non-tty # Copyright (C) 1991 Free Software Foundation, Inc. # 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 2, 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, write to the Free Software # Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. # Written by David MacKenzie . # Make sure we get GNU nice, if possible; also allow # it to be somewhere else in PATH if not installed yet. PATH=@bindir@:$PATH usage="Usage: $0 COMMAND [ARG]... or: $0 OPTION" usage_try=" Try \`$0 --help' for more information." usage_help=" --help display this help and exit --version output version information and exit" if [ $# -eq 0 ]; then echo >&2 "$usage" echo >&2 "$usage_try" exit 1 fi case $# in 1 ) case "z${1}" in z--help ) echo "$usage"; echo "$usage_help"; exit 0 ;; z--version ) echo "nohup - @VERSION@"; exit 0 ;; * ) ;; esac ;; * ) ;; esac trap "" 1 oldmask=`umask`; umask 077 # Only redirect the output if the user didn't already do it. if [ -t 1 ]; then # If we cannot write to the current directory, use the home directory. if cat /dev/null >> nohup.out; then echo "nohup: appending output to \`nohup.out'" 2>&1 umask $oldmask exec nice -5 "$@" >> nohup.out 2>&1 else cat /dev/null >> $HOME/nohup.out echo "nohup: appending output to \`$HOME/nohup.out'" 2>&1 umask $oldmask exec nice -5 "$@" >> $HOME/nohup.out 2>&1 fi else umask $oldmask exec nice -5 "$@" fi sh-utils-1.10/src/false.sh100755 74504 1 503 5555072436 14734 0ustar meyeringdaemon#!/bin/sh usage="Usage: $0 [OPTION]... --help display this help and exit --version output version information and exit" case $# in 1 ) case "z${1}" in z--help ) echo "$usage"; exit 0 ;; z--version ) echo "false - @VERSION@"; exit 0 ;; * ) ;; esac ;; * ) ;; esac exit 1 sh-utils-1.10/src/true.sh100755 74504 1 504 5555072461 14620 0ustar meyeringdaemon#!/bin/sh usage="Usage: $0 [OPTION]... --help display this help and exit --version output version information and exit" case $# in 1 ) case "z${1}" in z--help ) echo "$usage"; exit 0 ;; z--version ) echo "true - @VERSION@"; exit 0 ;; * ) ;; esac ;; * ) ;; esac exit 0 sh-utils-1.10/src/version.h100666 74504 13 43 5456412472 14660 0ustar meyeringuserextern const char *version_string; sh-utils-1.10/src/long-options.h100666 74504 13 34 5462540254 15620 0ustar meyeringuservoid parse_long_options (); sh-utils-1.10/man/ 40777 74504 1 0 5566761540 13223 5ustar meyeringdaemonsh-utils-1.10/man/Makefile.in100666 74504 13 4443 5566761053 15127 0ustar meyeringuser# Makefile for GNU shell utilities documentation. # Copyright (C) 1991, 1992, 1993, 1994 Free Software Foundation, Inc. # 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 2, 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, write to the Free Software # Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. SHELL = /bin/sh srcdir = @srcdir@ VPATH = @srcdir@ prefix = /usr/local exec_prefix = $(prefix) mandir = $(prefix)/man/man1 manprefix = $(binprefix) manext = 1 INSTALL = @INSTALL@ INSTALL_DATA = @INSTALL_DATA@ # Files to install on all systems MANFILES1 = basename.1 date.1 dirname.1 echo.1 env.1 expr.1 false.1 groups.1 \ hostname.1 id.1 logname.1 pathchk.1 printenv.1 printf.1 pwd.1 sleep.1 \ tee.1 test.1 true.1 tty.1 users.1 who.1 whoami.1 yes.1 # Files to install if configure determines we can build the corresponding # executables. MANFILES2 = nice.1 nohup.1 su.1 stty.1 uname.1 # Files to install. MANFILES = $(MANFILES1) @MAN@ DISTFILES = Makefile.in $(MANFILES1) $(MANFILES2) all: Makefile: ../config.status Makefile.in CONFIG_FILES=$@ CONFIG_HEADERS= ../config.status install: all for f in $(MANFILES); do \ $(INSTALL_DATA) $(srcdir)/$$f \ $(mandir)/$(manprefix)`basename $$f 1`$(manext); \ done @if test `../src/id -u` = 0; then \ echo you are root, so installing su.1; \ $(INSTALL_DATA) $(srcdir)/su.1 $(mandir)/$(manprefix)su.$(manext); \ else echo WARNING: you are not root, so not installing su.1; fi uninstall: for f in $(MANFILES) su.1; do \ rm -f $(mandir)/$(manprefix)`basename $$f 1`$(manext); \ done TAGS: clean: mostlyclean: clean distclean: clean rm -f Makefile realclean: distclean rm -f TAGS dist: ln $(DISTFILES) ../`cat ../.fname`/man # Tell versions [3.59,3.63) of GNU make not to export all variables. # Otherwise a system limit (for SysV at least) may be exceeded. .NOEXPORT: sh-utils-1.10/man/basename.1100666 74504 13 1306 5554634675 14720 0ustar meyeringuser.TH BASENAME 1L "GNU Shell Utilities" "FSF" \" -*- nroff -*- .SH NAME basename \- strip directory and suffix from filenames .SH SYNOPSIS .B basename name [suffix] .br .B basename {\-\-help,\-\-version} .SH DESCRIPTION This manual page documents the GNU version of .BR basename . The .B basename command removes any leading directory components from .IR name ; If .I suffix is specified and is identical to the end of .IR name , it is removed from .I name as well. .B basename prints the resulting name on the standard output. .SS OPTIONS .TP .I "\-\-help" Print a usage message on standard output and exit successfully. .TP .I "\-\-version" Print version information on standard output then exit successfully. sh-utils-1.10/man/date.1100666 74504 1 10302 5537115136 14323 0ustar meyeringdaemon.TH DATE 1L "GNU Shell Utilities" "FSF" \" -*- nroff -*- .SH NAME date \- print or set the system date and time .SH SYNOPSIS .B date [\-u] [\-d datestr] [\-s datestr] [\-\-uct] [\-\-universal] [\-\-date=datestr] [\-\-set=datestr] [\-\-help] [\-\-version] [+FORMAT] [MMDDhhmm[[CC]YY][.ss]] .SH DESCRIPTION This manual page documents the GNU version of .BR date . .B date with no arguments prints the current time and date (in the format of the `%c' directive described below). If given an argument that starts with a `+', it prints the current time and date in a format controlled by that argument, which has the same format as the format string passed to the `strftime' function. Except for directives that start with `%', characters in that string are printed unchanged. .PP The directives are: .IP % a literal % .IP n a newline .IP t a horizontal tab .PP Time fields: .IP %H hour (00..23) .IP %I hour (01..12) .IP %k hour ( 0..23) .IP %l hour ( 1..12) .IP %M minute (00..59) .IP %p locale's AM or PM .IP %r time, 12-hour (hh:mm:ss [AP]M) .IP %s seconds since 1970-01-01 00:00:00 UCT (a nonstandard extension) .IP %S second (00..61) .IP %T time, 24-hour (hh:mm:ss) .IP %X locale's time representation (%H:%M:%S) .IP %Z time zone (e.g., EDT), or nothing if no time zone is determinable .PP Date fields: .IP %a locale's abbreviated weekday name (Sun..Sat) .IP %A locale's full weekday name, variable length (Sunday..Saturday) .IP %b locale's abbreviated month name (Jan..Dec) .IP %B locale's full month name, variable length (January..December) .IP %c locale's date and time (Sat Nov 04 12:02:33 EST 1989) .IP %d day of month (01..31) .IP %D date (mm/dd/yy) .IP %h same as %b .IP %j day of year (001..366) .IP %m month (01..12) .IP %U week number of year with Sunday as first day of week (00..53) .IP %w day of week (0..6) with 0 corresponding to Sunday .IP %W week number of year with Monday as first day of week (00..53) .IP %x locale's date representation (mm/dd/yy) .IP %y last two digits of year (00..99) .IP %Y year (1970...) .PP By default, .BR date pads numeric fields with zeroes. GNU .BR date recognizes the following nonstandard numeric modifiers: .IP \- (hyphen) do not pad the field .IP _ (underscore) pad the field with spaces .PP If given an argument that does not start with `+', .B date sets the system clock to the time and date specified by that argument. The argument must consist entirely of digits, which have the following meaning: .IP MM month .IP DD day within month .IP hh hour .IP mm minute .IP CC first two digits of year (optional) .IP YY last two digits of year (optional) .IP ss second (optional) .PP Only the superuser can set the system clock. .SS OPTIONS .TP .I "\-d datestr, \-\-date datestr" Display the time and date specified in .IR datestr , which can be in almost any common format. The display is in the default output format, or if an argument starting with `+' is given to .BR date , in the format specified by that argument. .TP .I "\-\-help" Print a usage message on standard output and exit successfully. .TP .I "\-s datestr, \-\-set datestr" Set the time and date to .IR datestr , which can be in almost any common format. It can contain month names, timezones, `am' and `pm', etc. .TP .I "\-u, \-\-universal" Print or set the time and date in Universal Coordinated Time (also known as Greenwich Mean Time) instead of in local (wall clock) time. .TP .I "\-\-version" Print version information on standard output then exit successfully. .SH EXAMPLES .PP To print the date of the day before yesterday .IP date \-\-date \'2 days ago\' .PP To print the date of the day three months and one day hence .IP date \-\-date \'3 months 1 day\' .PP To print the day of year of Christmas in the current year .IP date --date \'25 Dec\' +%j .PP To print the current date in a format including the full month name and the day of the month .IP date \'+%B %d\' .PP But this may not be what you want because for the first nine days of the month, the \`%d\' expands to a zero-padded two-digit field, for example \`date \-d 1-may \'+%B %d\'\' will print \`May 01\'. .PP To print the same date but without the leading zero for one-digit days of month, you can use the nonstandard \`\-\' modifier to suppress the padding altogether. .IP date \-d 1-may \'+%B %-d\' sh-utils-1.10/man/dirname.1100666 74504 13 1162 5554634676 14565 0ustar meyeringuser.TH DIRNAME 1L "GNU Shell Utilities" "FSF" \" -*- nroff -*- .SH NAME dirname \- strip non-directory suffix from file name .SH SYNOPSIS .B dirname filename .br .B dirname {\-\-help,\-\-version} .SH DESCRIPTION This manual page documents the GNU version of .BR dirname . .B dirname prints all but the final slash-delimited component of .IR filename . If .I filename is a single component, .B dirname prints `.' (meaning the current directory). .SS OPTIONS .TP .I "\-\-help" Print a usage message on standard output and exit successfully. .TP .I "\-\-version" Print version information on standard output then exit successfully. sh-utils-1.10/man/echo.1100666 74504 13 2303 5476553307 14054 0ustar meyeringuser.TH ECHO 1L "GNU Shell Utilities" "FSF" \" -*- nroff -*- .SH NAME echo \- display a line of text .SH SYNOPSIS \fBecho\fP [\fB\-ne\fP] [\fIstring\fP ...] .br .B echo {\-\-help,\-\-version} .SH DESCRIPTION This manual page documents the GNU version of .BR echo . Note that most shells have a built-in command by the same name and with similar functionality. .PP .B echo writes each given \fIstring\fP to the standard output, with a space between them and a newline after the last one. .SS OPTIONS .TP .I \-n Do not output the trailing newline. .TP .I \-e Enable interpretation of the following backslash-escaped characters in the strings: .RS .PD 0 .TP .B \ea alert (bell) .TP .B \eb backspace .TP .B \ec suppress trailing newline .TP .B \ef form feed .TP .B \en new line .TP .B \er carriage return .TP .B \et horizontal tab .TP .B \ev vertical tab .TP .B \e\e backslash .TP .B \ennn the character whose ASCII code is \fInnn\fP (octal) .PD .RE .SS OPTIONS When GNU .B echo is invoked with exactly one argument, the following options are recognized: .TP .I "\-\-help" Print a usage message on standard output and exit successfully. .TP .I "\-\-version" Print version information on standard output then exit successfully. sh-utils-1.10/man/env.1100666 74504 13 2631 5465530373 13726 0ustar meyeringuser.TH ENV 1L "GNU Shell Utilities" "FSF" \" -*- nroff -*- .SH NAME env \- run a program in a modified environment .SH SYNOPSIS .B env [\-] [\-i] [\-u name] [\-\-ignore-environment] [\-\-unset=name] [\-\-help] [\-\-version] [name=value]... [command [args...]] .br .B env .SH DESCRIPTION This manual page documents the GNU version of .BR env . .B env runs a command with an environment modified as specified by the command line arguments. Arguments of the form `variable=value' set the environment variable .I variable to value .IR value . .I value may be empty (`variable='). Setting a variable to an empty value is different from unsetting it. .PP The first remaining argument specifies a program to invoke; it is searched for according to the specification of the PATH environment variable. Any arguments following that are passed as arguments to that program. .PP If no command name is specified following the environment specifications, the resulting environment is printed. This is like specifying a command name of `printenv'. .SS OPTIONS .TP .I "\-\-help" Print a usage message on standard output and exit successfully. .TP .I "\-u, \-\-unset name" Remove variable .I name from the environment, if it was in the environment. .TP .I "\-, \-i, \-\-ignore-environment" Start with an empty environment, ignoring the inherited environment. .TP .I "\-\-version" Print version information on standard output then exit successfully. sh-utils-1.10/man/expr.1100666 74504 13 7320 5554634676 14126 0ustar meyeringuser.TH EXPR 1L "GNU Shell Utilities" "FSF" \" -*- nroff -*- .SH NAME expr \- evaluate expressions .SH SYNOPSIS .B expr expression... .br .B expr {\-\-help,\-\-version} .br .SH DESCRIPTION This manual page documents the GNU version of .BR expr . .B expr evaluates an expression and writes the result on its standard output. Each token of the expression must be a separate argument. Operands are either numbers or strings. Strings are not quoted for \fBexpr\fP, though you may need to quote them to protect them from the shell. .B expr coerces anything appearing in an operand position to an integer or a string depending on the operation being applied to it. .PP The operators (in order of increasing precedence) are: .IP "\fI|\fP" Yields its first argument if it is neither null nor 0, otherwise its second argument. This is the usual `or' operation. .IP "\fI&\fP" Yields its first argument if neither argument is null or 0, otherwise 0. .IP "\fI<\fP\0 \fI<=\fP\0 \fI=\fP\0 \fI==\fP\0 \fI!=\fP\0 \fI>=\fP\0 \fI>\fP" Compare their arguments and return 1 if the relation is true, 0 otherwise. (\fI==\fP is a synonym for \fI=\fP.) \fBexpr\fP tries to coerce both arguments to numbers and do a numeric comparison; if it fails when trying to coerce either argument it then does a lexicographic comparison. .IP "\fI+\fP\0 \fI-\fP" Perform arithmetic operations. Both arguments are coerced to numbers; an error occurs if this cannot be done. .IP "\fI*\fP\0 \fI/\fP\0 \fI%\fP" Perform arithmetic operations (`%' is the remainder operation, as in C). Both arguments are coerced to numbers; an error occurs if this cannot be done. .IP "\fI:\fP" Perform pattern matching. Its arguments are coerced to strings and the second one is considered to be a regular expression, with a `^' implicitly added at the beginning. The first argument is then matched against this regular expression. If the match succeeds and part of the string is enclosed in `\e(' and `\e)', that part is the value of the \fI:\fP expression; otherwise an integer whose value is the number of characters matched is returned. If the match fails, the \fI:\fP operator returns the null string if `\e(' and `\e)' are used, otherwise 0. Only one `\e(' and `\e)' pair can be used. .TP In addition, the following keywords are recognized: .TP .BI match " string regex" An alternative way to do pattern matching. This is the same as ``\fIstring\fP \fB:\fP \fIregex\fP''. .TP .BI substr " string position length" Return the substring of \fIstring\fP beginning at \fIposition\fP with length at most \fIlength\fP. If either \fIposition\fP or \fIlength\fP is negative or non-numeric, return a null string. .TP .BI index " string character-class" Return the first position in \fIstring\fP where the first character in \fIcharacter-class\fP was found. If no character in \fIcharacter-class\fP is found in \fIstring\fP, return 0. .TP .BI length " string" Return the length of \fIstring\fP. .PP Parentheses are used for grouping in the usual manner. The keywords cannot be used as strings. .SS OPTIONS When GNU .B expr is invoked with exactly one argument, the following options are recognized: .TP .I "\-\-help" Print a usage message on standard output and exit successfully. .TP .I "\-\-version" Print version information on standard output then exit successfully. .SH EXAMPLES .PP To add 1 to the shell variable .IR a : .IP a=\`expr $a + 1\` .PP The following may be used to print the non-directory part of the file name stored in variable .IR a (the value in .IR a need not contain `/'): .IP expr $a : \'.*/\e(\^.*\e)\' \'\^|\' $a .LP Note the quoted shell metacharacters. .PP .B expr returns the following exit status: .PP 0 if the expression is neither null nor 0, .br 1 if the expression is null or 0, .br 2 for invalid expressions. sh-utils-1.10/man/false.1100666 74504 13 1324 5465530374 14227 0ustar meyeringuser.TH FALSE 1L "GNU Shell Utilities" "FSF" \" -*- nroff -*- .SH NAME false \- do nothing, unsuccessfully .SH SYNOPSIS .B false .br .B false {\-\-help,\-\-version} .SH DESCRIPTION This manual page documents the GNU version of .B false (and probably every other version, as well). .B false does nothing except return an exit status of 1, meaning ``failure''. It can be used as a place holder in shell scripts where an unsuccessful command is needed. .SS OPTIONS When GNU .B false is invoked with exactly one argument, the following options are recognized: .TP .I "\-\-help" Print a usage message on standard output and exit successfully. .TP .I "\-\-version" Print version information on standard output then exit successfully. sh-utils-1.10/man/groups.1100666 74504 13 1513 5465530375 14455 0ustar meyeringuser.TH GROUPS 1L "GNU Shell Utilities" "FSF" \" -*- nroff -*- .SH NAME groups \- print the groups a user is in .SH SYNOPSIS .B groups [username...] .br .B groups {\-\-help,\-\-version} .SH DESCRIPTION This manual page documents the GNU version of .BR groups . .B groups prints the names of the supplementary groups that each given .IR username , or the current process if none are given, is in. If user names are given, the name of each user is printed before the list of that user's groups. .PP The group lists are equivalent to the output of the command `id \-Gn'. .SS OPTIONS When GNU .B groups is invoked with exactly one argument, the following options are recognized: .TP .I "\-\-help" Print a usage message on standard output and exit successfully. .TP .I "\-\-version" Print version information on standard output then exit successfully. sh-utils-1.10/man/hostname.1100644 74504 1 1233 5564704321 15203 0ustar meyeringdaemon.TH HOSTNAME 1L "GNU Shell Utilities" "FSF" \" -*- nroff -*- .SH NAME hostname \- set or print the name of the current host system .SH SYNOPSIS .B hostname [name] .br .B hostname {\-\-help,\-\-version} .SH DESCRIPTION This manual page documents the GNU version of .BR hostname . With no arguments, .B hostname prints the name of the current host system. With one argument, it sets the current host name to the specified string. Usually, only a privileged user may set the host name. .SS OPTIONS .TP .I "\-\-help" Print a usage message on standard output and exit successfully. .TP .I "\-\-version" Print version information on standard output then exit successfully. sh-utils-1.10/man/id.1100666 74504 13 2554 5465530376 13541 0ustar meyeringuser.TH ID 1L "GNU Shell Utilities" "FSF" \" -*- nroff -*- .SH NAME id \- print real and effective UIDs and GIDs .SH SYNOPSIS .B id [\-gnruG] [\-\-group] [\-\-name] [\-\-real] [\-\-user] [\-\-groups] [\-\-help] [\-\-version] [username] .SH DESCRIPTION This manual page documents the GNU version of .BR id . .B id prints information about the given user, or the process running it if no user is specified. By default, it prints the real user ID, real group ID, effective user ID if different from the real user ID, effective group ID if different from the real group ID, and supplemental group IDs. It prints each of these values preceded by a string identifying it and followed by the corresponding user or group name in parentheses. .PP The options cause .B id to print only part of the above information. .SS OPTIONS .TP .I "\-g, \-\-group" Print only the group ID. .TP .I "\-G, \-\-groups" Print only the supplementary groups. .TP .I "\-\-help" Print a usage message on standard output and exit successfully. .TP .I "\-n, \-\-name" Print the user or group name instead of the ID number. Requires .IR \-u , .IR \-g , or .IR \-G . .TP .I "\-r, \-\-real" Print the real, instead of effective, user or group ID. Requires .IR \-u , .IR \-g , or .IR \-G . .TP .I "\-u, \-\-user" Print only the user ID. .TP .I "\-\-version" Print version information on standard output then exit successfully. sh-utils-1.10/man/logname.1100666 74504 13 1200 5465530377 14553 0ustar meyeringuser.TH LOGNAME 1L "GNU Shell Utilities" "FSF" \" -*- nroff -*- .SH NAME logname \- print user's login name .SH SYNOPSIS .B logname [\-\-help] [\-\-version] .SH DESCRIPTION This manual page documents the GNU version of .BR logname . .B logname prints the calling user's name, as found in the file /etc/utmp, and exits with a status of 0. If there is no /etc/utmp entry for the calling process, .B logname prints an error message and exits with a status of 1. .SS OPTIONS .TP .I "\-\-help" Print a usage message on standard output and exit successfully. .TP .I "\-\-version" Print version information on standard output then exit successfully. sh-utils-1.10/man/pathchk.1100666 74504 13 2424 5554634677 14573 0ustar meyeringuser.TH PATHCHK 1L "GNU Shell Utilities" "FSF" \" -*- nroff -*- .SH NAME pathchk \- check whether file names are valid or portable .SH SYNOPSIS .B pathchk [-p] [\-\-portability] [\-\-help] [\-\-version] filename... .SH DESCRIPTION This manual page documents the GNU version of .BR pathchk . For each .IR filename , .B pathchk prints a message if any of these conditions are false: .br \(bu all existing directories in .I filename have search (execute) permission .br \(bu the length of .I filename is no larger than its filesystem's maximum file name length .br \(bu the length of each component of .I filename corresponding to an existing directory name is no larger than its filesystem's maximum length for a file name component .PP The exit status is: .nf 0 if all file names passed all of the tests, 1 otherwise. .fi .SS OPTIONS .TP .I "\-\-help" Print a usage message on standard output and exit successfully. .TP .I "\-p, \-\-portability" Instead of performing length checks on the underlying filesystem, test the length of each file name and its components against the POSIX.1 minimum limits for portability. Also check that the file name contains no characters not in the portable filename character set. .TP .I "\-\-version" Print version information on standard output then exit successfully. sh-utils-1.10/man/printenv.1100666 74504 13 1422 5465530401 14770 0ustar meyeringuser.TH PRINTENV 1L "GNU Shell Utilities" "FSF" \" -*- nroff -*- .SH NAME printenv \- print all or part of environment .SH SYNOPSIS .B printenv [\-\-help] [\-\-version] [variable...] .SH DESCRIPTION This manual page documents the GNU version of .BR printenv . If no arguments are given, .B printenv prints the entire environment. If one or more variable names are given, it prints the value of each one that is set, and nothing for each one that is not set. .PP The exit status is: .nf 0 if all variables specified were found 1 if at least one specified variable was not found 2 if a write error occurred .SS OPTIONS .TP .I "\-\-help" Print a usage message on standard output and exit successfully. .TP .I "\-\-version" Print version information on standard output then exit successfully. sh-utils-1.10/man/printf.1100666 74504 13 2261 5465530402 14430 0ustar meyeringuser.TH PRINTF 1L "GNU Shell Utilities" "FSF" \" -*- nroff -*- .SH NAME printf \- format and print data .SH SYNOPSIS .B printf format [argument...] .br .B printf {\-\-help,\-\-version} .SH DESCRIPTION This manual page documents the GNU version of .BR printf . .B printf prints the .I format string, interpreting `%' directives and `\e' escapes in the same way as the C `printf' function. The .I format argument is re-used as many times as necessary to convert all of the given arguments. .P .B printf interprets `\e0ooo' as a an octal number (`ooo' is 0 to 3 digits) specifying a character to print, and `\exhhh' as a hexadecimal number (`hhh' is 1 to 3 digits) specifying a character to print. It has an additional escape, `\ec', which causes .B printf to produce no further output, and an additional directive, `%b', which prints its argument string with `\e' escapes interpreted the way they are in the .I format string. .SS OPTIONS When GNU .B printf is invoked with exactly one argument, the following options are recognized: .TP .I "\-\-help" Print a usage message on standard output and exit successfully. .TP .I "\-\-version" Print version information on standard output then exit successfully. sh-utils-1.10/man/pwd.1100644 74504 1 1430 5560725050 14154 0ustar meyeringdaemon.TH PWD 1L "GNU Shell Utilities" "FSF" \" -*- nroff -*- .SH NAME pwd \- print name of current/working directory .SH SYNOPSIS .B pwd .br .B pwd {\-\-help,\-\-version} .SH DESCRIPTION This manual page documents the GNU version of .BR pwd . .B pwd prints the fully resolved name of the current directory. That is, all components of the printed name will be actual directory names \-\- none will be symbolic links. .PP Note that most Unix shells provide a built-in .B pwd command with similar functionality so the unadorned, interactive .B pwd command will usually execute the built-in version and not this one. .SS OPTIONS .TP .I "\-\-help" Print a usage message on standard output and exit successfully. .TP .I "\-\-version" Print version information on standard output then exit successfully. sh-utils-1.10/man/sleep.1100666 74504 13 1256 5465530403 14242 0ustar meyeringuser.TH SLEEP 1L "GNU Shell Utilities" "FSF" \" -*- nroff -*- .SH NAME sleep \- delay for a specified amount of time .SH SYNOPSIS .B sleep [\-\-help] [\-\-version] number[smhd]... .SH DESCRIPTION This manual page documents the GNU version of .BR sleep . .B sleep pauses for an amount of time specified by the sum of the values of the command line arguments. Each argument is a number followed by an optional unit; the default is seconds. The units are: .IP s seconds .IP m minutes .IP h hours .IP d days .SS OPTIONS .TP .I "\-\-help" Print a usage message on standard output and exit successfully. .TP .I "\-\-version" Print version information on standard output then exit successfully. sh-utils-1.10/man/tee.1100666 74504 13 1666 5465530406 13717 0ustar meyeringuser.TH TEE 1L "GNU Shell Utilities" "FSF" \" -*- nroff -*- .SH NAME tee \- read from standard input and write to standard output and files .SH SYNOPSIS .B tee [\-ai] [\-\-append] [\-\-ignore-interrupts] [\-\-help] [\-\-version] [file...] .SH DESCRIPTION This manual page documents the GNU version of .BR tee . The .B tee command copies the standard input to the standard output and any files given as arguments. .P If a file being written to does not already exist, it is created. If a file being written to already exists, the data it previously contained is overwritten unless the .I \-a option is used. .SS OPTIONS .TP .I "\-a, \-\-append" Append the standard input to the given files rather than overwriting them. .TP .I "\-\-help" Print a usage message on standard output and exit successfully. .TP .I "\-i, \-\-ignore-interrupts" Ignore interrupt signals. .TP .I "\-\-version" Print version information on standard output then exit successfully. sh-utils-1.10/man/test.1100666 74504 13 6717 5476553310 14124 0ustar meyeringuser.TH TEST 1L "GNU Shell Utilities" "FSF" \" -*- nroff -*- .SH NAME test \- check file types and compare values .SH SYNOPSIS .B test [expr] .br .B test {\-\-help,\-\-version} .SH DESCRIPTION This manual page documents the GNU version of .BR test . Note that most shells have a built-in command by the same name and with similar functionality. .PP .B test returns a status of 0 (true) or 1 (false) depending on the evaluation of the conditional expression .IR expr . Expressions may be unary or binary. Unary expressions are often used to examine the status of a file. There are string operators and numeric comparison operators as well. .PD 0 .TP .B \-b \fIfile\fP True if \fIfile\fP exists and is block special. .TP .B \-c \fIfile\fP True if \fIfile\fP exists and is character special. .TP .B \-d \fIfile\fP True if \fIfile\fP exists and is a directory. .TP .B \-e \fIfile\fP True if \fIfile\fP exists .TP .B \-f \fIfile\fP True if \fIfile\fP exists and is a regular file. .TP .B \-g \fIfile\fP True if \fIfile\fP exists and is set-group-id. .TP .B \-k \fIfile\fP True if \fIfile\fP has its ``sticky'' bit set. .TP .B \-L \fIfile\fP True if \fIfile\fP exists and is a symbolic link. .TP .B \-p \fIfile\fP True if \fIfile\fP exists and is a named pipe. .TP .B \-r \fIfile\fP True if \fIfile\fP exists and is readable. .TP .B \-s \fIfile\fP True if \fIfile\fP exists and has a size greater than zero. .TP .B \-S \fIfile\fP True if \fIfile\fP exists and is a socket. .TP .B \-t [\fIfd\fP] True if .I fd is opened on a terminal. If .I fd is omitted, it defaults to 1 (standard output). .TP .B \-u \fIfile\fP True if \fIfile\fP exists and its set-user-id bit is set. .TP .B \-w \fIfile\fP True if \fIfile\fP exists and is writable. .TP .B \-x \fIfile\fP True if \fIfile\fP exists and is executable. .TP .B \-O \fIfile\fP True if \fIfile\fP exists and is owned by the effective user id. .TP .B \-G \fIfile\fP True if \fIfile\fP exists and is owned by the effective group id. .TP \fIfile1\fP \-\fBnt\fP \fIfile2\fP True if \fIfile1\fP is newer (according to modification date) than \fIfile2\fP. .TP \fIfile1\fP \-\fBot\fP \fIfile2\fP True if \fIfile1\fP is older than file2. .TP \fIfile1\fP \fB\-ef\fP \fIfile2\fP True if \fIfile1\fP and \fIfile2\fP have the same device and inode numbers. .TP .B \-z \fIstring\fP True if the length of \fIstring\fP is zero. .TP .B \-n \fIstring\fP .TP \fIstring\fP True if the length of .I string is non-zero. .TP \fIstring1\fP \fB=\fP \fIstring2\fP True if the strings are equal. .TP \fIstring1\fP \fB!=\fP \fIstring2\fP True if the strings are not equal. .TP .B ! \fIexpr\fP True if .I expr is false. .TP \fIexpr1\fP \-\fBa\fP \fIexpr2\fP True if both .I expr1 and .I expr2 are true. .TP \fIexpr1\fP \-\fBo\fP \fIexpr2\fP True if either .I expr1 or .I expr2 is true. .TP .I arg1 \fBOP\fP arg2 .SM .B OP is one of .BR \-eq , .BR \-ne , .BR \-lt , .BR \-le , .BR \-gt , or .BR \-ge . These arithmetic binary operators return true if \fIarg1\fP is equal, not-equal, less-than, less-than-or-equal, greater-than, or greater-than-or-equal than \fIarg2\fP, respectively. .I arg1 and .I arg2 may be positive integers, negative integers, or the special expression \fB\-l\fP \fIstring\fP, which evaluates to the length of .IR string . .SS OPTIONS When GNU .B test is invoked with exactly one argument, the following options are recognized: .TP .I "\-\-help" Print a usage message on standard output and exit successfully. .TP .I "\-\-version" Print version information on standard output then exit successfully. sh-utils-1.10/man/true.1100666 74504 13 1424 5465530407 14112 0ustar meyeringuser.TH TRUE 1L "GNU Shell Utilities" "FSF" \" -*- nroff -*- .SH NAME true \- do nothing, successfully .SH SYNOPSIS .B true .br .B true {\-\-help,\-\-version} .SH DESCRIPTION This manual page documents the GNU version of .B true (and probably every other version, as well). .B true does nothing except return an exit status of 0, meaning ``success''. It can be used as a place holder in shell scripts where a successful command is needed, although the shell built-in command `:' (colon) does the same thing faster. .SS OPTIONS When GNU .B true is invoked with exactly one argument, the following options are recognized: .TP .I "\-\-help" Print a usage message on standard output and exit successfully. .TP .I "\-\-version" Print version information on standard output then exit successfully. sh-utils-1.10/man/tty.1100666 74504 13 1501 5554634677 13764 0ustar meyeringuser.TH TTY 1L "GNU Shell Utilities" "FSF" \" -*- nroff -*- .SH NAME tty \- print the file name of the terminal connected to standard input .SH SYNOPSIS .B tty [\-s] [\-\-silent] [\-\-quiet] [\-\-help] [\-\-version] .SH DESCRIPTION This manual page documents the GNU version of .BR tty . .B tty prints the file name of the tty connected to its standard input. It prints `not a tty' if the standard input is not a tty. Its exit status is: .nf 0 if the standard input is a tty 1 if the standard input is not a tty 2 if given incorrect arguments 3 if a write error occurs .fi .SS OPTIONS .TP .I "\-\-help" Print a usage message on standard output and exit successfully. .TP .I "\-s, \-\-silent, \-\-quiet" Print nothing; only return an exit status. .TP .I "\-\-version" Print version information on standard output then exit successfully. sh-utils-1.10/man/users.1100644 74504 1 1654 5560725430 14535 0ustar meyeringdaemon.TH USERS 1L "GNU Shell Utilities" "FSF" \" -*- nroff -*- .SH NAME users \- print the user names of users currently logged in to the current host .SH SYNOPSIS .B users [FILE] .br .B users {\-\-help,\-\-version} .SH DESCRIPTION This manual page documents the GNU version of .BR users . .B users prints on a single line a blank-separated list of user names of users currently logged in to the current host. Each output user name corresponds to a login session, so if a user has more than one login session, that user's name will appear the same number of times in the output. With no file argument, .B users extracts its information from the file .B /etc/utmp . If a file argument is given, .B users uses that file instead. A common choice is .B /etc/wtmp . .SS OPTIONS .TP .I "\-\-help" Print a usage message on standard output and exit successfully. .TP .I "\-\-version" Print version information on standard output then exit successfully. sh-utils-1.10/man/who.1100666 74504 13 3573 5465530411 13732 0ustar meyeringuser.TH WHO 1L "GNU Shell Utilities" "FSF" \" -*- nroff -*- .SH NAME who \- show who is logged on .SH SYNOPSIS .B who [\-imqsuwHT] [\-\-count] [\-\-idle] [\-\-heading] [\-\-help] [\-\-message] [\-\-mesg] [\-\-version] [\-\-writable] [file] [am i] .SH DESCRIPTION This manual page documents the GNU version of .BR who . If given no non-option arguments, .B who prints the following information for each user currently logged on: .RS .nf login name terminal line login time remote hostname or X display .fi .RE .PP If given one non-option argument, .B who uses that instead of /etc/utmp as the name of the file containing the record of users logged on. /etc/wtmp is commonly given as an argument to .B who to look at who has previously logged on. .PP If given two non-option arguments, .B who prints only the entry for the user running it (determined from its standard input), preceded by the hostname. Traditionally, the two arguments given are `am i', as in `who am i'. .SS OPTIONS .TP .I \-m Same as `who am i'. .TP .I "\-q, \-\-count" Print only the login names and the number of users logged on. Overrides all other options. .TP .I \-s Ignored; for compatibility with other versions of .BR who . .TP .I "\-i, \-u, \-\-idle" After the login time, print the number of hours and minutes that the user has been idle. `.' means the user was active in last minute. `old' means the user was idle for more than 24 hours. .TP .I "\-H, \-\-heading" Print a line of column headings. .TP .I "\-w, \-T, \-\-mesg, \-\-message, \-\-writable" Like .IR \-s , plus after the login name print a character indicating the user's message status: .RS .IP + allowing \fBwrite\fP messages .IP \- disallowing \fBwrite\fP messages .IP ? cannot find terminal device .RE .TP .I "\-\-help" Print a usage message on standard output and exit successfully. .TP .I "\-\-version" Print version information on standard output then exit successfully. sh-utils-1.10/man/whoami.1100666 74504 13 1021 5465530412 14404 0ustar meyeringuser.TH WHOAMI 1L "GNU Shell Utilities" "FSF" \" -*- nroff -*- .SH NAME whoami \- print effective userid .SH SYNOPSIS .B whoami [\-\-help] [\-\-version] .SH DESCRIPTION This manual page documents the GNU version of .BR whoami . .B whoami prints the user name associated with the current effective user ID. It is equivalent to the command `id \-un'. .SS OPTIONS .TP .I "\-\-help" Print a usage message on standard output and exit successfully. .TP .I "\-\-version" Print version information on standard output then exit successfully. sh-utils-1.10/man/yes.1100666 74504 13 1333 5465530412 13726 0ustar meyeringuser.TH YES 1L "GNU Shell Utilities" "FSF" \" -*- nroff -*- .SH NAME yes \- output a string repeatedly until killed .SH SYNOPSIS .B yes [string...] .br .B yes {\-\-help,\-\-version} .SH DESCRIPTION This manual page documents the GNU version of .BR yes . .B yes prints the command line arguments, separated by spaces and followed by a newline, forever until it is killed. If no arguments are given, it prints `y' followed by a newline forever until killed. .SS OPTIONS When GNU .B false is invoked with exactly one argument, the following options are recognized: .TP .I "\-\-help" Print a usage message on standard output and exit successfully. .TP .I "\-\-version" Print version information on standard output then exit successfully. sh-utils-1.10/man/nice.1100666 74504 13 2166 5476553310 14055 0ustar meyeringuser.TH NICE 1L "GNU Shell Utilities" "FSF" \" -*- nroff -*- .SH NAME nice \- run a program with modified scheduling priority .SH SYNOPSIS .B nice [\-n adjustment] [\-adjustment] [\-\-adjustment=adjustment] [\-\-help] [\-\-version] [command [arg...]] .SH DESCRIPTION This manual page documents the GNU version of .BR nice . Note that most shells have a built-in command by the same name and with similar functionality. .PP If no arguments are given, .B nice prints the current scheduling priority, which it inherited. Otherwise, .B nice runs the given .I command with its scheduling priority adjusted. If no .I adjustment is given, the priority of the command is incremented by 10. The superuser can specify a negative adjustment. The priority can be adjusted by .B nice over the range of -20 (the highest priority) to 19 (the lowest). .SS OPTIONS .TP .I "\-n adjustment, \-adjustment, \-\-adjustment=adjustment" Add .I adjustment instead of 10 to the command's priority. .TP .I "\-\-help" Print a usage message on standard output and exit successfully. .TP .I "\-\-version" Print version information on standard output then exit successfully. sh-utils-1.10/man/nohup.1100666 74504 13 2516 5465530400 14260 0ustar meyeringuser.TH NOHUP 1L "GNU Shell Utilities" "FSF" \" -*- nroff -*- .SH NAME nohup \- run a command immune to hangups, with output to a non-tty .SH SYNOPSIS .B nohup command [arg...] .br .B nohup {\-\-help,\-\-version} .SH DESCRIPTION This manual page documents the GNU version of .BR nohup . .B nohup runs the given .I command with hangup signals ignored and the scheduling priority increased by 5, so that the command can continue running in the background after you log out. If the standard output is a tty, it and the standard error are redirected so that they are appended to the file `nohup.out'; if that cannot be written to, they are appended to the file `$HOME/nohup.out'. If that cannot be written to, the command is not run. .PP If .B nohup creates the file `nohup.out' or `$HOME/nohup.out', it creates it with no access permissions for group or other. It does not change the permissions of those files if they already existed. .PP .B nohup does not automatically put the command it runs in the background; you must do that explicitly, by ending the command line with an `&'. .SS OPTIONS When GNU .B nohup is invoked with exactly one argument, the following options are recognized: .TP .I "\-\-help" Print a usage message on standard output and exit successfully. .TP .I "\-\-version" Print version information on standard output then exit successfully. sh-utils-1.10/man/su.1100666 74504 13 6473 5465530405 13571 0ustar meyeringuser.TH SU 1L "GNU Shell Utilities" "FSF" \" -*- nroff -*- .SH NAME su \- run a shell with substitute user and group IDs .SH SYNOPSIS .B su [\-flmp] [\-c command] [\-s shell] [\-\-login] [\-\-fast] [\-\-preserve-environment] [\-\-command=command] [\-\-shell=shell] [\-] [\-\-help] [\-\-version] [user [arg...]] .SH DESCRIPTION This manual page documents the GNU version of .BR su . .B su allows one user to temporarily become another user. It runs a shell with the real and effective user ID, group ID, and supplemental groups of USER. If no USER is given, the default is root, the super-user. The shell run is taken from USER's password entry, or /bin/sh if none is specified there. If USER has a password, .B su prompts for the password unless run by a user with real user ID 0 (the super-user). .PP By default, .B su does not change the current directory. It sets the environment variables `HOME' and `SHELL' from the password entry for USER, and if USER is not the super-user, sets `USER' and `LOGNAME' to USER. By default, the shell is not a login shell. .PP If one or more ARGs are given, they are passed as additional arguments to the shell. .PP .B su does not handle /bin/sh or other shells specially (setting argv[0] to "-su", passing -c only to certain shells, etc.). .PP On systems that have syslog, .B su can be compiled to report failed, and optionally successful, .B su attempts using syslog. .PP This program does not support a "wheel group" that restricts who can .B su to super-user accounts, because that can help fascist system administrators hold unwarranted power over other users. .SS OPTIONS .TP .I "\-c COMMAND, \-\-command=COMMAND" Pass COMMAND, a single command line to run, to the shell with a .I \-c option instead of starting an interactive shell. .TP .I "\-f, \-\-fast" Pass the .I \-f option to the shell. This probably only makes sense with .B csh and .BR tcsh , for which the .I \-f option prevents reading the startup file (.cshrc). With Bourne-like shells, the .I \-f option disables filename pattern expansion, which is not a generally desirable thing to do. .TP .I "\-\-help" Print a usage message on standard output and exit successfully. .TP .I "\-, \-l, \-\-login" Make the shell a login shell. This means the following. Unset all environment variables except `TERM', `HOME', and `SHELL' (which are set as described above), and `USER' and `LOGNAME' (which are set, even for the super-user, as described above), and set `PATH' to a compiled-in default value. Change to USER's home directory. Prepend "\-" to the shell's name, to make it read its login startup file(s). .TP .I "\-m, \-p, \-\-preserve\-environment" Do not change the environment variables `HOME', `USER', `LOGNAME', or `SHELL'. Run the shell given in the environment variable `SHELL' instead of USER's shell from /etc/passwd, unless the user running .B su is not the superuser and USER's shell is restricted. A restricted shell is one that is not listed in the file /etc/shells, or in a compiled-in list if that file does not exist. Parts of what this option does can be overridden by .I \-\-login and .IR \-\-shell . .TP .I "\-s, \-\-shell shell" Run SHELL instead of USER's shell from /etc/passwd, unless the user running .B su is not the superuser and USER's shell is restricted. .TP .I "\-\-version" Print version information on standard output then exit successfully. sh-utils-1.10/man/stty.1100666 74504 1 20656 5527765353 14441 0ustar meyeringdaemon.TH STTY 1L "GNU Shell Utilities" "FSF" \" -*- nroff -*- .SH NAME stty \- change and print terminal line settings .SH SYNOPSIS .B stty [setting...] .br .B stty {\-a,\-\-all,\-g,\-\-help,\-\-save,\-\-version} .SH DESCRIPTION This manual page documents the GNU version of .BR stty . If given no arguments, .B stty prints the baud rate, line discipline number (on systems that support it), and line settings that have been changed from the values set by `stty sane'. Mode reading and setting are performed on the tty line connected to the standard input. .PP .B stty accepts the following non-option arguments that change aspects of the terminal line operation. A `[\-]' before a capability means that it can be turned off by preceding it with a `\-'. Some arguments are not available on all systems, since they use non-POSIX extensions. Such arguments are marked below with `(np)'. .PP Control settings: .IP [\-]parenb Generate parity bit in output and expect parity bit in input. .IP [\-]parodd Set odd parity (even with `\-'). .IP "cs5 cs6 cs7 cs8" Set character size to 5, 6, 7, or 8 bits. .IP "[\-]hupcl [\-]hup" Send a hangup signal when the last process closes the tty. .IP [\-]cstopb Use two stop bits per character (one with `\-'). .IP [\-]cread Allow input to be received. .IP [\-]clocal Disable modem control signals. .IP "[\-]crtscts (np)" Enable RTS/CTS handshaking. .PP Input settings: .IP [\-]ignbrk Ignore breaks. .IP [\-]brkint Breaks cause an interrupt signal. .IP [\-]ignpar Ignore parity errors. .IP [\-]parmrk Mark parity errors (with a 255-0-character sequence). .IP [\-]inpck Enable input parity checking. .IP [\-]istrip Clear high (8th) bit of input characters. .IP [\-]inlcr Translate newline to carriage return. .IP [\-]igncr Ignore carriage return. .IP [\-]icrnl Translate carriage return to newline. .IP [\-]ixon Enable XON/XOFF flow control. .IP "[\-]ixoff [\-]tandem" Enable sending of stop character when the system input buffer is almost full, and start character when it becomes almost empty again. .IP "[\-]iuclc (np)" Translate uppercase characters to lowercase. .IP "[\-]ixany (np)" Allow any character to restart output (only the start character with `\-'). .IP "[\-]imaxbel (np)" Enable beeping and not flushing input buffer if a character arrives when the input buffer is full. .PP Output settings: .IP [\-]opost Postprocess output. .IP "[\-]olcuc (np)" Translate lowercase characters to uppercase. .IP "[\-]ocrnl (np)" Translate carriage return to newline. .IP "[\-]onlcr (np)" Translate newline to carriage return-newline. .IP "[\-]onocr (np)" Do not print carriage returns in the first column. .IP "[\-]onlret (np)" Newline performs a carriage return. .IP "[\-]ofill (np)" Use fill (padding) characters instead of timing for delays. .IP "[\-]ofdel (np)" Use delete characters for fill instead of null characters. .IP "nl1 nl0 (np)" Newline delay style. .IP "cr3 cr2 cr1 cr0 (np)" Carriage return delay style. .IP "tab3 tab2 tab1 tab0 (np)" Horizontal tab delay style. .IP "bs1 bs0 (np)" Backspace delay style. .IP "vt1 vt0 (np)" Vertical tab delay style. .IP "ff1 ff0 (np)" Form feed delay style. .PP Local settings: .IP [\-]isig Enable interrupt, quit, and suspend special characters. .IP [\-]icanon Enable erase, kill, werase, and rprnt special characters. .IP [\-]iexten Enable non-POSIX special characters. .IP [\-]echo Echo input characters. .IP "[\-]echoe, [\-]crterase" Echo erase characters as backspace-space-backspace. .IP [\-]echok Echo a newline after a kill character. .IP [\-]echonl Echo newline even if not echoing other characters. .IP [\-]noflsh Disable flushing after interrupt and quit special characters. .IP "[\-]xcase (np)" Enable input and output of uppercase characters by preceding their lowercase equivalents with `\e', when icanon is set. .IP "[\-]tostop (np)" Stop background jobs that try to write to the terminal. .IP "[\-]echoprt [\-]prterase (np)" Echo erased characters backward, between `\e' and '/'. .IP "[\-]echoctl [\-]ctlecho (np)" Echo control characters in hat notation (`^c') instead of literally. .IP "[\-]echoke [\-]crtkill (np)" Echo the kill special character by erasing each character on the line as indicated by the echoprt and echoe settings, instead of by the echoctl and echok settings. .PP Combination settings: .IP "[\-]evenp [\-]parity" Same as parenb \-parodd cs7. With `\-', same as \-parenb cs8. .IP [\-]oddp Same as parenb parodd cs7. With `\-', same as \-parenb cs8. .IP [\-]nl Same as \-icrnl \-onlcr. With `\-', same as icrnl \-inlcr \-igncr onlcr \-ocrnl \-onlret. .IP ek Reset the erase and kill special characters to their default values. .IP sane Same as cread \-ignbrk brkint \-inlcr \-igncr icrnl \-ixoff \-iuclc \-ixany imaxbel opost \-olcuc \-ocrnl onlcr \-onocr \-onlret \-ofill \-ofdel nl0 cr0 tab0 bs0 vt0 ff0 isig icanon iexten echo echoe echok \-echonl \-noflsh \-xcase \-tostop \-echoprt echoctl echoke, and also sets all special characters to their default values. .IP [\-]cooked Same as brkint ignpar istrip icrnl ixon opost isig icanon, plus sets the eof and eol characters to their default values if they are the same as the min and time characters. With `\-', same as raw. .IP [\-]raw Same as \-ignbrk \-brkint \-ignpar \-parmrk \-inpck \-istrip \-inlcr \-igncr \-icrnl \-ixon \-ixoff \-iuclc \-ixany \-imaxbel \-opost \-isig \-icanon \-xcase min 1 time 0. With `\-', same as cooked. .IP [\-]cbreak Same as \-icanon. .IP [\-]pass8 Same as \-parenb \-istrip cs8. With `\-', same as parenb istrip cs7. .IP [\-]litout Same as \-parenb \-istrip \-opost cs8. With `\-', same as parenb istrip opost cs7. .IP "[\-]decctlq (np)" Same as \-ixany. .IP "[\-]tabs (np)" Same as tab0. With `\-', same as tab3. .IP "[\-]lcase [\-]LCASE (np)" Same as xcase iuclc olcuc. .IP crt Same as echoe echoctl echoke. .IP dec Same as echoe echoctl echoke \-ixany, and also sets the interrupt special character to Ctrl-C, erase to Del, and kill to Ctrl-U. .PP Special characters: .PP The special characters' default values vary from system to system. They are set with the syntax `name value', where the names are listed below and the value can be given either literally, in hat notation (`^c'), or as an integer which may start with `0x' to indicate hexadecimal, `0' to indicate octal, or any other digit to indicate decimal. Giving a value of `^\-' or `undef' disables that special character. .IP intr Send an interrupt signal. .IP quit Send a quit signal. .IP erase Erase the last character typed. .IP kill Erase the current line. .IP eof Send an end of file (terminate the input). .IP eol End the line. .IP "eol2 (np)" Alternate character to end the line. .IP "swtch (np)" Switch to a different shell layer. .IP start Restart the output after stopping it. .IP stop Stop the output. .IP susp Send a terminal stop signal. .IP "dsusp (np)" Send a terminal stop signal after flushing the input. .IP "rprnt (np)" Redraw the current line. .IP "werase (np)" Erase the last word typed. .IP "lnext (np)" Enter the next character typed literally, even if it is a special character. .PP Special settings: .IP "min N" Set the minimum number of characters that will satisfy a read until the time value has expired, when \-icanon is set. .IP "time N" Set the number of tenths of a second before reads time out if the min number of characters have not been read, when \-icanon is set. .IP "ispeed N" Set the input speed to N. .IP "ospeed N" Set the output speed to N. .IP "rows N (np)" Tell the kernel that the terminal has N rows. .IP "cols N columns N (np)" Tell the kernel that the terminal has N columns. .IP "size (np)" Print the number of rows and columns that the kernel thinks the terminal has. (Systems that don't support rows and cols in the kernel typically use the environment variables .B LINES and .B COLUMNS instead; however, GNU .B stty does not know anything about them.) .IP "line N (np)" Use line discipline N. .IP "speed" Print the terminal speed. .IP N Set the input and output speeds to N. N can be one of: 0 50 75 110 134 134.5 150 200 300 600 1200 1800 2400 4800 9600 19200 38400 exta extb. exta is the same as 19200; extb is the same as 38400. 0 hangs up the line if \-clocal is set. .SS OPTIONS .TP .I "\-a, \-\-all" Print all current settings in human-readable form. .TP .I "\-\-help" Print a usage message on standard output and exit successfully. .TP .I "\-g, \-\-save" Print all current settings in a form that can be used as an argument to another .B stty command to restore the current settings. .TP .I "\-\-version" Print version information on standard output then exit successfully. sh-utils-1.10/man/uname.1100666 74504 13 2172 5465530411 14234 0ustar meyeringuser.TH UNAME 1L "GNU Shell Utilities" "FSF" \" -*- nroff -*- .SH NAME uname \- print system information .SH SYNOPSIS .B uname [\-snrvma] [\-\-sysname] [\-\-nodename] [\-\-release] [\-\-machine] [\-\-all] [\-\-help] [\-\-version] .SH DESCRIPTION This manual page documents the GNU version of .BR uname . .B uname prints information about the machine and operating system it is run on. If no options are given, .B uname acts as if the .I \-s option were given. If multiple options are given or the .I \-a option is given, the selected information is printed in the order `snrvm' with a space between items. .SS OPTIONS .TP .I "\-m, \-\-machine" Print the machine (hardware) type. .TP .I "\-n, \-\-nodename" Print the machine's network node hostname. .TP .I "\-r, \-\-release" Print the operating system release. .TP .I "\-s, \-\-sysname" Print the operating system name. .TP .I "\-v" Print the operating system version. .TP .I "\-a, \-\-all" Print all of the above information. .TP .I "\-\-help" Print a usage message on standard output and exit successfully. .TP .I "\-\-version" Print version information on standard output then exit successfully.